From dde73f4ded354f7db5d55db4c4d1d71b715b63f9 Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Thu, 13 Jun 2024 20:20:15 +0200 Subject: [PATCH 01/11] Refactor preconditioner to accept instances of TensorOperator --- src/pydvl/influence/torch/pre_conditioner.py | 69 ++++++++------------ 1 file changed, 26 insertions(+), 43 deletions(-) diff --git a/src/pydvl/influence/torch/pre_conditioner.py b/src/pydvl/influence/torch/pre_conditioner.py index f42852c2c..eb6a7eecc 100644 --- a/src/pydvl/influence/torch/pre_conditioner.py +++ b/src/pydvl/influence/torch/pre_conditioner.py @@ -1,12 +1,15 @@ from __future__ import annotations from abc import ABC, abstractmethod -from typing import Callable, Optional +from typing import TYPE_CHECKING, Optional import torch from ..base_influence_function_model import NotFittedException -from .functional import LowRankProductRepresentation, randomized_nystroem_approximation +from .functional import LowRankProductRepresentation, operator_nystroem_approximation + +if TYPE_CHECKING: + from .operator import TensorOperator __all__ = ["JacobiPreConditioner", "NystroemPreConditioner", "PreConditioner"] @@ -31,20 +34,14 @@ def is_fitted(self): @abstractmethod def fit( self, - mat_mat_prod: Callable[[torch.Tensor], torch.Tensor], - size: int, - dtype: torch.dtype, - device: torch.device, + operator: "TensorOperator", regularization: float = 0.0, ): r""" Implement this to fit the pre-conditioner to the matrix represented by the mat_mat_prod Args: - mat_mat_prod: a callable that computes the matrix-matrix product - size: size of the matrix represented by `mat_mat_prod` - dtype: data type of the matrix represented by `mat_mat_prod` - device: device of the matrix represented by `mat_mat_prod` + operator: The preconditioner is fitted to this operator regularization: regularization parameter $\lambda$ in the equation $ ( A + \lambda \operatorname{I})x = \operatorname{rhs} $ Returns: @@ -112,29 +109,27 @@ def is_fitted(self): def fit( self, - mat_mat_prod: Callable[[torch.Tensor], torch.Tensor], - size: int, - dtype: torch.dtype, - device: torch.device, + operator: "TensorOperator", regularization: float = 0.0, ): r""" Fits by computing an estimate of the diagonal of the matrix represented by - `mat_mat_prod` via Hutchinson's estimator + a [TensorOperator][pydvl.influence.torch.base.TensorOperator] + via Hutchinson's estimator Args: - mat_mat_prod: a callable representing the matrix-matrix product - size: size of the square matrix - dtype: needed data type of inputs for the mat_mat_prod - device: needed device for inputs of mat_mat_prod + operator: The preconditioner is fitted to this operator regularization: regularization parameter $\lambda$ in $(A+\lambda I)x=b$ """ random_samples = torch.randn( - size, self.num_samples_estimator, device=device, dtype=dtype + operator.input_size, + self.num_samples_estimator, + device=operator.device, + dtype=operator.dtype, ) diagonal_estimate = torch.sum( - torch.mul(random_samples, mat_mat_prod(random_samples)), dim=1 + torch.mul(random_samples, operator.apply(random_samples)), dim=1 ) diagonal_estimate /= self.num_samples_estimator self._diag = diagonal_estimate @@ -196,10 +191,7 @@ def is_fitted(self): def fit( self, - mat_mat_prod: Callable[[torch.Tensor], torch.Tensor], - size: int, - dtype: torch.dtype, - device: torch.device, + operator: "TensorOperator", regularization: float = 0.0, ): r""" @@ -207,39 +199,30 @@ def fit( `mat_mat_prod` via Nystroem approximation Args: - mat_mat_prod: a callable representing the matrix-matrix product - size: size of the square matrix - dtype: needed data type of inputs for the mat_mat_prod - device: needed device for inputs of mat_mat_prod + operator: The preconditioner is fitted to this operator regularization: regularization parameter $\lambda$ in $(A+\lambda I)x=b$ """ - self._low_rank_approx = randomized_nystroem_approximation( - mat_mat_prod, size, self._rank, dtype, mat_vec_device=device - ) + self._low_rank_approx = operator_nystroem_approximation(operator, self._rank) self._regularization = regularization def _solve(self, rhs: torch.Tensor): rhs_is_one_dim = rhs.ndim == 1 + b = torch.atleast_2d(rhs).t() if rhs_is_one_dim else rhs - rhs_view = torch.atleast_2d(rhs).t() if rhs_is_one_dim else rhs + U = self._low_rank_approx.projections - regularized_eigenvalues = ( - self._low_rank_approx.eigen_vals + self._regularization - ) + Sigma = self._low_rank_approx.eigen_vals + self._regularization lambda_rank = self._low_rank_approx.eigen_vals[-1] + self._regularization - proj_rhs = self._low_rank_approx.projections.t() @ rhs_view + U_t_b = U.t() @ b - inverse_regularized_eigenvalues = lambda_rank / regularized_eigenvalues - - result = self._low_rank_approx.projections @ ( - proj_rhs * inverse_regularized_eigenvalues.unsqueeze(-1) - ) + Sigma_inv = lambda_rank / Sigma - result += rhs_view - self._low_rank_approx.projections @ proj_rhs + result = U @ (U_t_b * Sigma_inv.unsqueeze(-1)) + result += b - U @ U_t_b if rhs_is_one_dim: result = result.squeeze() From 22cf2b20af7750a4cf43bbee758fb1b096a5d48b Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Thu, 13 Jun 2024 20:21:01 +0200 Subject: [PATCH 02/11] Implement block-diagonal and Gauss-Newton approximation for CG: * rename parameters of CGInfluence hessian_regularization -> regularization, pre_conditioner -> preconditioner * remove parameter x0 from CGInfluence * refactor preconditioners to accept instances of TensorOperator --- .../torch/influence_function_model.py | 354 +++--------------- src/pydvl/influence/torch/operator.py | 277 ++++++++++++++ src/pydvl/influence/torch/pre_conditioner.py | 80 +++- tests/influence/torch/test_influence_model.py | 24 +- tests/influence/torch/test_pre_conditioner.py | 14 +- 5 files changed, 423 insertions(+), 326 deletions(-) diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index 3ece8d149..f8bac7d44 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -6,6 +6,7 @@ from __future__ import annotations +import copy import logging from abc import ABC, abstractmethod from collections import OrderedDict @@ -43,6 +44,7 @@ operator_spectral_approximation, ) from .operator import ( + CgOperator, DirectSolveOperator, GaussNewtonOperator, HessianOperator, @@ -437,7 +439,7 @@ def is_thread_safe(self) -> bool: return False -class CgInfluence(TorchInfluenceFunctionModel): +class CgInfluence(TorchComposableInfluence[CgOperator]): r""" Given a model and training data, it uses conjugate gradient to calculate the inverse of the Hessian Vector Product. More precisely, it finds x such that \(Hx = @@ -449,9 +451,8 @@ class CgInfluence(TorchInfluenceFunctionModel): this model's parameters. loss: A callable that takes the model's output and target as input and returns the scalar loss. - hessian_regularization: Optional regularization parameter added + regularization: Optional regularization parameter added to the Hessian-vector product for numerical stability. - x0: Initial guess for hvp. If None, defaults to b. rtol: Maximum relative tolerance of result. atol: Absolute tolerance of result. maxiter: Maximum number of iterations. If None, defaults to 10*len(b). @@ -468,6 +469,8 @@ class CgInfluence(TorchInfluenceFunctionModel): warn_on_max_iteration: If True, logs a warning, if the desired tolerance is not achieved within `maxiter` iterations. If False, the log level for this information is `logging.DEBUG` + block_structure: Union[BlockMode, OrderedDict[str, List[str]]] = BlockMode.FULL, + second_order_mode: SecondOrderMode = SecondOrderMode.HESSIAN, """ @@ -475,327 +478,84 @@ def __init__( self, model: nn.Module, loss: Callable[[torch.Tensor, torch.Tensor], torch.Tensor], - hessian_regularization: float = 0.0, - x0: Optional[torch.Tensor] = None, - rtol: float = 1e-7, - atol: float = 1e-7, + regularization: Optional[Union[float, Dict[str, Optional[float]]]] = None, + rtol: float = 1e-4, + atol: float = 1e-6, maxiter: Optional[int] = None, progress: bool = False, precompute_grad: bool = False, - pre_conditioner: Optional[PreConditioner] = None, + preconditioner: Optional[PreConditioner] = None, use_block_cg: bool = False, warn_on_max_iteration: bool = True, + block_structure: Union[BlockMode, OrderedDict[str, List[str]]] = BlockMode.FULL, + second_order_mode: SecondOrderMode = SecondOrderMode.HESSIAN, ): - super().__init__(model, loss) + super().__init__(model, block_structure, regularization) + self.loss = loss self.warn_on_max_iteration = warn_on_max_iteration self.use_block_cg = use_block_cg - self.pre_conditioner = pre_conditioner + self.preconditioner = preconditioner self.precompute_grad = precompute_grad self.progress = progress self.maxiter = maxiter self.atol = atol self.rtol = rtol - self.x0 = x0 - self.hessian_regularization = hessian_regularization - - train_dataloader: DataLoader - - @property - def is_fitted(self): - try: - return self.train_dataloader is not None - except AttributeError: - return False - - @log_duration(log_level=logging.INFO) - def fit(self, data: DataLoader) -> CgInfluence: - self.train_dataloader = data - if self.pre_conditioner is not None: - hvp = create_hvp_function( - self.model, - self.loss, - self.train_dataloader, - precompute_grad=self.precompute_grad, - ) - - def model_hessian_mat_mat_prod(x: torch.Tensor): - return torch.func.vmap(hvp, in_dims=1, randomness="same")(x).t() - - self.pre_conditioner.fit( - model_hessian_mat_mat_prod, - self.n_parameters, - self.model_dtype, - self.model_device, - self.hessian_regularization, - ) - return self - - @log_duration - def influences( - self, - x_test: torch.Tensor, - y_test: torch.Tensor, - x: Optional[torch.Tensor] = None, - y: Optional[torch.Tensor] = None, - mode: InfluenceMode = InfluenceMode.Up, - ) -> torch.Tensor: - r""" - Compute an approximation of - - \[ \langle H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, - f_{\theta}(x_{\text{test}})), - \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle, \] - - for the case of up-weighting influence, resp. - - \[ \langle H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, - f_{\theta}(x_{\text{test}})), - \nabla_{x} \nabla_{\theta} \ell(y, f_{\theta}(x)) \rangle \] - - for the case of perturbation-type influence. The approximate action of - $H^{-1}$ is achieved via the [conjugate gradient - method](https://en.wikipedia.org/wiki/Conjugate_gradient_method). + self.second_order_mode = second_order_mode + def with_regularization( + self, regularization: Union[float, Dict[str, Optional[float]]] + ) -> TorchComposableInfluence: + """ + Update the regularization parameter. Args: - x_test: model input to use in the gradient computations of - $H^{-1}\nabla_{\theta} \ell(y_{\text{test}}, - f_{\theta}(x_{\text{test}}))$ - y_test: label tensor to compute gradients - x: optional model input to use in the gradient computations - $\nabla_{\theta}\ell(y, f_{\theta}(x))$, - resp. $\nabla_{x}\nabla_{\theta}\ell(y, f_{\theta}(x))$, - if None, use $x=x_{\text{test}}$ - y: optional label tensor to compute gradients - mode: enum value of [InfluenceMode] - [pydvl.influence.base_influence_function_model.InfluenceMode] + regularization: Either a positive float or a dictionary with the + block names as keys and the regularization values as values. Returns: - A tensor representing the element-wise scalar products for the - provided batch. + The modified instance """ - return super().influences(x_test, y_test, x, y, mode=mode) - - @log_duration - def _solve_hvp(self, rhs: torch.Tensor) -> torch.Tensor: - if len(self.train_dataloader) == 0: - raise ValueError("Training dataloader must not be empty.") - - if self.use_block_cg: - return self._solve_pbcg(rhs) - - hvp = create_hvp_function( - self.model, - self.loss, - self.train_dataloader, - precompute_grad=self.precompute_grad, - ) - - def reg_hvp(v: torch.Tensor): - return hvp(v) + self.hessian_regularization * v.type(rhs.dtype) - - y_norm = torch.linalg.norm(rhs, dim=0) - - stopping_val = torch.clamp(self.rtol**2 * y_norm, min=self.atol**2) - - batch_cg = torch.zeros_like(rhs) - - for idx, (bi, _tol) in enumerate( - tqdm( - zip(rhs, stopping_val), - disable=not self.progress, - desc="Conjugate gradient", - ) - ): - batch_result = self._solve_pcg( - reg_hvp, - bi, - tol=_tol, - x0=self.x0, - maxiter=self.maxiter, - ) - batch_cg[idx] = batch_result - - return batch_cg + self._regularization_dict = self._build_regularization_dict(regularization) + for k, reg in self._regularization_dict.items(): + self.block_mapper.composable_block_dict[k].op.regularization = reg + return self - def _solve_pcg( + def _create_block( self, - hvp: Callable[[torch.Tensor], torch.Tensor], - b: torch.Tensor, - *, - tol: float, - x0: Optional[torch.Tensor] = None, - maxiter: Optional[int] = None, - ) -> torch.Tensor: - r""" - Conjugate gradient solver for the Hessian vector product. - - Args: - hvp: A callable Hvp, operating with tensors of size N. - b: A vector or matrix, the right hand side of the equation \(Hx = b\). - x0: Initial guess for hvp. - rtol: Maximum relative tolerance of result. - atol: Absolute tolerance of result. - maxiter: Maximum number of iterations. If None, defaults to 10*len(b). - - Returns: - A tensor with the solution of \(Ax=b\). - """ - - if x0 is None: - x0 = torch.clone(b) - if maxiter is None: - maxiter = len(b) * 10 - - x = x0 - - r0 = b - hvp(x) - - if self.pre_conditioner is not None: - p = z0 = self.pre_conditioner.solve(r0) - else: - p = z0 = r0 - - for k in range(maxiter): - if torch.norm(r0) < tol: - logger.debug(f"Terminated cg after {k} iterations with residuum={r0}") - break - Ap = hvp(p) - alpha = torch.dot(r0, z0) / torch.dot(p, Ap) - x += alpha * p - r = r0 - alpha * Ap - - if self.pre_conditioner is not None: - z = self.pre_conditioner.solve(r) - else: - z = r - - beta = torch.dot(r, z) / torch.dot(r0, z0) + block_params: Dict[str, torch.nn.Parameter], + data: DataLoader, + regularization: Optional[float], + ) -> TorchOperatorGradientComposition: + op: Union[HessianOperator, GaussNewtonOperator] - r0 = r - p = z + beta * p - z0 = z - else: - log_level = logging.WARNING if self.warn_on_max_iteration else logging.DEBUG - logger.log( - log_level, - f"Reached max number of iterations {maxiter=} without " - f"achieving the desired tolerance {tol}. \n" - f"Achieved residuum is {torch.norm(r0)}.\n" - f"Consider increasing 'maxiter', the desired tolerance or the " - f"parameter 'hessian_regularization'.", + if self.second_order_mode is SecondOrderMode.GAUSS_NEWTON: + op = GaussNewtonOperator( + self.model, self.loss, data, restrict_to=block_params ) + else: + op = HessianOperator(self.model, self.loss, data, restrict_to=block_params) - return x - - def _solve_pbcg( - self, - rhs: torch.Tensor, - ): - hvp = create_hvp_function( - self.model, - self.loss, - self.train_dataloader, - precompute_grad=self.precompute_grad, - ) + preconditioner = None + if self.preconditioner is not None: + preconditioner = copy.copy(self.preconditioner).fit(op, regularization) - # The block variant of conjugate gradient is known to suffer from breakdown, - # due to the possibility of rank deficiency of the iterates of the parameter - # matrix P^tAP, which destabilizes the direct solver. - # The paper `Randomized Nyström Preconditioning, - # Frangella, Zachary and Tropp, Joel A. and Udell, Madeleine, - # SIAM J. Matrix Anal. Appl., 2023` - # proposes a simple orthogonalization pre-processing. However, we observed, that - # this stabilization only worked for double precision. We thus implement - # a different stabilization strategy described in - # `A breakdown-free block conjugate gradient method, Ji, Hao and Li, Yaohang, - # BIT Numerical Mathematics, 2017` - - def mat_mat(x: torch.Tensor): - return torch.vmap( - lambda u: hvp(u) + self.hessian_regularization * u, - in_dims=1, - randomness="same", - )(x) - - X = torch.clone(rhs.T) - - R = (rhs - mat_mat(X)).T - Z = R if self.pre_conditioner is None else self.pre_conditioner.solve(R) - P, _, _ = torch.linalg.svd(Z, full_matrices=False) - active_indices = torch.as_tensor( - list(range(X.shape[-1])), dtype=torch.long, device=self.model_device + cg_op = CgOperator( + op, + regularization, + rtol=self.rtol, + atol=self.atol, + maxiter=self.maxiter, + progress=self.progress, + preconditioner=preconditioner, + use_block_cg=self.use_block_cg, + warn_on_max_iteration=self.warn_on_max_iteration, ) + gp = TorchGradientProvider(self.model, self.loss, restrict_to=block_params) + return TorchOperatorGradientComposition(cg_op, gp) - maxiter = self.maxiter if self.maxiter is not None else len(rhs) * 10 - y_norm = torch.linalg.norm(rhs, dim=1) - tol = torch.clamp(self.rtol**2 * y_norm, min=self.atol**2) - - # In the case the parameter dimension is smaller than the number of right - # hand sides, we do not shrink the indices due to resulting wrong - # dimensionality of the svd decomposition. We consider this an edge case, which - # does not need optimization - shrink_finished_indices = rhs.shape[0] <= rhs.shape[1] - - for k in range(maxiter): - Q = mat_mat(P).T - p_t_ap = P.T @ Q - alpha = torch.linalg.solve(p_t_ap, P.T @ R) - X[:, active_indices] += P @ alpha - R -= Q @ alpha - - B = torch.linalg.norm(R, dim=0) - non_finished_indices = torch.nonzero(B > tol) - num_remaining_indices = non_finished_indices.numel() - non_finished_indices = non_finished_indices.squeeze() - - if num_remaining_indices == 1: - non_finished_indices = non_finished_indices.unsqueeze(-1) - - if num_remaining_indices == 0: - logger.debug( - f"Terminated block cg after {k} iterations with max " - f"residuum={B.max()}" - ) - break - - # Reduce problem size by removing finished columns from the iteration - if shrink_finished_indices: - active_indices = active_indices[non_finished_indices] - R = R[:, non_finished_indices] - P = P[:, non_finished_indices] - Q = Q[:, non_finished_indices] - p_t_ap = p_t_ap[:, non_finished_indices][non_finished_indices, :] - tol = tol[non_finished_indices] - - Z = R if self.pre_conditioner is None else self.pre_conditioner.solve(R) - beta = -torch.linalg.solve(p_t_ap, Q.T @ Z) - Z_tmp = Z + P @ beta - - if Z_tmp.ndim == 1: - Z_tmp = Z_tmp.unsqueeze(-1) - - # Orthogonalization search directions to stabilize the action of - # (P^tAP)^{-1} - P, _, _ = torch.linalg.svd(Z_tmp, full_matrices=False) - else: - log_level = logging.WARNING if self.warn_on_max_iteration else logging.DEBUG - logger.log( - log_level, - f"Reached max number of iterations {maxiter=} of block cg " - f"without achieving the desired tolerance {tol.min()}. \n" - f"Achieved max residuum is " - f"{torch.linalg.norm(R, dim=0).max()}.\n" - f"Consider increasing 'maxiter', the desired tolerance or " - f"the parameter 'hessian_regularization'.", - ) - - return X.T - - def to(self, device: torch.device): - if self.pre_conditioner is not None: - self.pre_conditioner = self.pre_conditioner.to(device) - return super().to(device) + @property + def is_thread_safe(self) -> bool: + return False class LissaInfluence(TorchComposableInfluence[LissaOperator[BatchOperationType]]): diff --git a/src/pydvl/influence/torch/operator.py b/src/pydvl/influence/torch/operator.py index 9b52330c3..d7e71eb2c 100644 --- a/src/pydvl/influence/torch/operator.py +++ b/src/pydvl/influence/torch/operator.py @@ -1,4 +1,5 @@ import logging +import warnings from typing import Callable, Dict, Generic, Optional, Tuple import torch @@ -23,6 +24,8 @@ TensorAveragingType, ) from .functional import LowRankProductRepresentation +from .pre_conditioner import PreConditioner +from .util import LossType logger = logging.getLogger(__name__) @@ -609,3 +612,277 @@ def _apply_to_mat(self, mat: torch.Tensor) -> torch.Tensor: def input_size(self) -> int: result: int = self.matrix.shape[-1] return result + + +class CgOperator(TensorOperator): + r""" + Given an operator , it uses conjugate gradient to calculate the + action of its inverse. More precisely, it finds x such that \(Ax = + A\), with \(A\) being the matrix represented by the operator. For more info, see + [Conjugate Gradient][conjugate-gradient]. + + Args: + operator: + regularization: Optional regularization parameter added + to the matrix vector product for numerical stability. + rtol: Maximum relative tolerance of result. + atol: Absolute tolerance of result. + maxiter: Maximum number of iterations. If None, defaults to 10*len(b). + progress: If True, display progress bars for computing in the non-block mode + (use_block_cg=False). + preconditioner: Optional pre-conditioner to improve convergence of conjugate + gradient method + use_block_cg: If True, use block variant of conjugate gradient method, which + solves several right hand sides simultaneously + warn_on_max_iteration: If True, logs a warning, if the desired tolerance is not + achieved within `maxiter` iterations. If False, the log level for this + information is `logging.DEBUG` + + """ + + def __init__( + self, + operator: TensorOperator, + regularization: Optional[float] = None, + rtol: float = 1e-7, + atol: float = 1e-7, + maxiter: Optional[int] = None, + progress: bool = False, + preconditioner: Optional[PreConditioner] = None, + use_block_cg: bool = False, + warn_on_max_iteration: bool = True, + ): + + if regularization is not None and regularization < 0: + raise ValueError("regularization must be non-negative") + + self.progress = progress + self.warn_on_max_iteration = warn_on_max_iteration + self.use_block_cg = use_block_cg + self.preconditioner = preconditioner + self.maxiter = maxiter + self.atol = atol + self.rtol = rtol + self._regularization = regularization + self.operator = operator + + @property + def regularization(self): + return self._regularization + + @regularization.setter + def regularization(self, value: float): + if value < 0: + raise ValueError("regularization must be non-negative") + self._regularization = value + if self.preconditioner is not None: + if self.preconditioner.modify_regularization_requires_fit: + warnings.warn( + "Modifying the regularization value requires " + "re-fitting the preconditioner" + ) + self.preconditioner = self.preconditioner.fit(self.operator, value) + else: + self.preconditioner.regularization = value + + @property + def device(self): + return self.operator.device + + @property + def dtype(self): + return self.operator.dtype + + def to(self, device: torch.device): + self.operator = self.operator.to(device) + if self.preconditioner is not None: + self.preconditioner = self.preconditioner.to(device) + return self + + def _reg_operator_apply(self, x: torch.Tensor): + result = self.operator.apply(x) + if self._regularization is not None: + result += self._regularization * x + return result + + @property + def input_size(self) -> int: + return self.operator.input_size + + def _apply_to_vec(self, vec: torch.Tensor) -> torch.Tensor: + return self._apply_to_mat(vec.unsqueeze(0)) + + def _apply_to_mat(self, mat: torch.Tensor) -> torch.Tensor: + + if self.use_block_cg: + return self._solve_pbcg(mat) + + y_norm = torch.linalg.norm(mat, dim=0) + + stopping_val = torch.clamp(self.rtol**2 * y_norm, min=self.atol**2) + + batch_cg = torch.zeros_like(mat) + + for idx, (bi, _tol) in enumerate( + tqdm( + zip(mat, stopping_val), + disable=not self.progress, + desc="Conjugate gradient", + ) + ): + batch_result = self._solve_pcg(bi, _tol) + batch_cg[idx] = batch_result + + return batch_cg + + def _solve_pcg( + self, + b: torch.Tensor, + tol: float, + ) -> torch.Tensor: + + x0 = torch.clone(b) + maxiter = self.maxiter + if maxiter is None: + maxiter = len(b) * 10 + + x = x0 + + r0 = b - self._reg_operator_apply(x) + + if self.preconditioner is not None: + p = z0 = self.preconditioner.solve(r0) + else: + p = z0 = r0 + + residuum = torch.norm(r0) + + for k in range(maxiter): + if residuum < tol: + logger.debug( + f"Terminated cg after {k} iterations with residuum={residuum}" + ) + break + Ap = self._reg_operator_apply(p) + alpha = torch.dot(r0, z0) / torch.dot(p, Ap) + x += alpha * p + r = r0 - alpha * Ap + + if self.preconditioner is not None: + z = self.preconditioner.solve(r) + else: + z = r + + beta = torch.dot(r, z) / torch.dot(r0, z0) + + r0 = r + residuum = torch.norm(r0) + p = z + beta * p + z0 = z + else: + log_msg = ( + f"Reached max number of iterations {maxiter=} without " + f"achieving the desired tolerance {tol}. \n" + f"Achieved residuum is {residuum}.\n" + f"Consider increasing 'maxiter', the desired tolerance or the " + f"parameter 'hessian_regularization'." + ) + if self.warn_on_max_iteration: + warnings.warn(log_msg) + else: + logger.debug(log_msg) + return x + + def _solve_pbcg( + self, + rhs: torch.Tensor, + ): + + # The block variant of conjugate gradient is known to suffer from breakdown, + # due to the possibility of rank deficiency of the iterates of the parameter + # matrix P^tAP, which destabilizes the direct solver. + # The paper `Randomized Nyström Preconditioning, + # Frangella, Zachary and Tropp, Joel A. and Udell, Madeleine, + # SIAM J. Matrix Anal. Appl., 2023` + # proposes a simple orthogonalization pre-processing. However, we observed, that + # this stabilization only worked for double precision. We thus implement + # a different stabilization strategy described in + # `A breakdown-free block conjugate gradient method, Ji, Hao and Li, Yaohang, + # BIT Numerical Mathematics, 2017` + + X = torch.clone(rhs.T) + + R = (rhs - self._reg_operator_apply(X.t())).T + B = torch.linalg.norm(R, dim=0) + Z = R if self.preconditioner is None else self.preconditioner.solve(R) + P, _, _ = torch.linalg.svd(Z, full_matrices=False) + active_indices = torch.as_tensor( + list(range(X.shape[-1])), dtype=torch.long, device=self.device + ) + + maxiter = self.maxiter if self.maxiter is not None else len(rhs) * 10 + y_norm = torch.linalg.norm(rhs, dim=1) + tol = torch.clamp(self.rtol**2 * y_norm, min=self.atol**2) + + # In the case the parameter dimension is smaller than the number of right + # hand sides, we do not shrink the indices due to resulting wrong + # dimensionality of the svd decomposition. We consider this an edge case, which + # does not need optimization + shrink_finished_indices = rhs.shape[0] <= rhs.shape[1] + + for k in range(maxiter): + Q = self._reg_operator_apply(P.t()).T + p_t_ap = P.T @ Q + alpha = torch.linalg.solve(p_t_ap, P.T @ R) + X[:, active_indices] += P @ alpha + R -= Q @ alpha + + B = torch.linalg.norm(R, dim=0) + non_finished_indices = torch.nonzero(B > tol) + num_remaining_indices = non_finished_indices.numel() + non_finished_indices = non_finished_indices.squeeze() + + if num_remaining_indices == 1: + non_finished_indices = non_finished_indices.unsqueeze(-1) + + if num_remaining_indices == 0: + logger.debug( + f"Terminated block cg after {k} iterations with max " + f"residuum={B.max()}" + ) + break + + # Reduce problem size by removing finished columns from the iteration + if shrink_finished_indices: + active_indices = active_indices[non_finished_indices] + R = R[:, non_finished_indices] + P = P[:, non_finished_indices] + Q = Q[:, non_finished_indices] + p_t_ap = p_t_ap[:, non_finished_indices][non_finished_indices, :] + tol = tol[non_finished_indices] + + Z = R if self.preconditioner is None else self.preconditioner.solve(R) + beta = -torch.linalg.solve(p_t_ap, Q.T @ Z) + Z_tmp = Z + P @ beta + + if Z_tmp.ndim == 1: + Z_tmp = Z_tmp.unsqueeze(-1) + + # Orthogonalization search directions to stabilize the action of + # (P^tAP)^{-1} + P, _, _ = torch.linalg.svd(Z_tmp, full_matrices=False) + else: + log_msg = ( + f"Reached max number of iterations {maxiter=} of block cg " + f"without achieving the desired tolerance {tol.min()}. \n" + f"Achieved max residuum is " + f"{B.max()}.\n" + f"Consider increasing 'maxiter', the desired tolerance or " + f"the parameter 'hessian_regularization'." + ) + if self.warn_on_max_iteration: + warnings.warn(log_msg) + else: + logger.debug(log_msg) + + return X.T diff --git a/src/pydvl/influence/torch/pre_conditioner.py b/src/pydvl/influence/torch/pre_conditioner.py index eb6a7eecc..2b50bd5d2 100644 --- a/src/pydvl/influence/torch/pre_conditioner.py +++ b/src/pydvl/influence/torch/pre_conditioner.py @@ -25,17 +25,41 @@ class PreConditioner(ABC): condition number than $A + \lambda \operatorname{I}$. """ + _reg: Optional[float] + + @property + def regularization(self): + return self._reg + + @regularization.setter + def regularization(self, value: float): + if self.modify_regularization_requires_fit: + raise NotImplementedError( + f"Adapting regularization for instances of type " + f"{type(self)} without re-fitting is not " + f"supported. Call the fit method instead." + ) + self._validate_regularization(value) + self._reg = value + + def _validate_regularization(self, value: Optional[float]): + if value is not None and value < 0: + raise ValueError("regularization must be non-negative") @property @abstractmethod - def is_fitted(self): + def modify_regularization_requires_fit(self) -> bool: pass + @property @abstractmethod + def is_fitted(self): + pass + def fit( self, operator: "TensorOperator", - regularization: float = 0.0, + regularization: Optional[float] = None, ): r""" Implement this to fit the pre-conditioner to the matrix represented by the @@ -47,6 +71,11 @@ def fit( Returns: self """ + self._validate_regularization(regularization) + return self._fit(operator, regularization) + + @abstractmethod + def _fit(self, operator: "TensorOperator", regularization: Optional[float] = None): pass def solve(self, rhs: torch.Tensor): @@ -98,19 +127,24 @@ class JacobiPreConditioner(PreConditioner): """ _diag: torch.Tensor - _reg: float def __init__(self, num_samples_estimator: int = 1): self.num_samples_estimator = num_samples_estimator @property def is_fitted(self): - return self._diag is not None and self._reg is not None + has_diag = hasattr(self, "_diag") and self._diag is not None + has_regularization = hasattr(self, "_reg") + return has_diag and has_regularization - def fit( + @property + def modify_regularization_requires_fit(self) -> bool: + return False + + def _fit( self, operator: "TensorOperator", - regularization: float = 0.0, + regularization: Optional[float] = None, ): r""" Fits by computing an estimate of the diagonal of the matrix represented by @@ -129,14 +163,19 @@ def fit( dtype=operator.dtype, ) diagonal_estimate = torch.sum( - torch.mul(random_samples, operator.apply(random_samples)), dim=1 + torch.mul(random_samples, operator.apply(random_samples.t())), dim=1 ) diagonal_estimate /= self.num_samples_estimator self._diag = diagonal_estimate self._reg = regularization def _solve(self, rhs: torch.Tensor): - inv_diag = 1.0 / (self._diag + self._reg) + diag = self._diag + + if self._reg is not None: + diag = diag + self._reg + + inv_diag = 1.0 / diag if rhs.ndim == 1: return rhs * inv_diag @@ -172,7 +211,6 @@ class NystroemPreConditioner(PreConditioner): """ _low_rank_approx: LowRankProductRepresentation - _regularization: float def __init__(self, rank: int): self._rank = rank @@ -187,12 +225,20 @@ def rank(self): @property def is_fitted(self): - return self._low_rank_approx is not None and self._regularization is not None + has_low_rank_approx = ( + hasattr(self, "_low_rank_approx") and self._low_rank_approx is not None + ) + has_regularization = hasattr(self, "_reg") and self._reg is not None + return has_low_rank_approx and has_regularization - def fit( + @property + def modify_regularization_requires_fit(self) -> bool: + return False + + def _fit( self, operator: "TensorOperator", - regularization: float = 0.0, + regularization: Optional[float] = None, ): r""" Fits by computing a low-rank approximation of the matrix represented by @@ -205,7 +251,7 @@ def fit( """ self._low_rank_approx = operator_nystroem_approximation(operator, self._rank) - self._regularization = regularization + self._reg = regularization def _solve(self, rhs: torch.Tensor): @@ -214,8 +260,12 @@ def _solve(self, rhs: torch.Tensor): U = self._low_rank_approx.projections - Sigma = self._low_rank_approx.eigen_vals + self._regularization - lambda_rank = self._low_rank_approx.eigen_vals[-1] + self._regularization + Sigma = self._low_rank_approx.eigen_vals + lambda_rank = self._low_rank_approx.eigen_vals[-1] + + if self._reg is not None: + Sigma = Sigma + self._reg + lambda_rank = lambda_rank + self._reg U_t_b = U.t() @ b diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index 409c0f27c..65527a51a 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -370,7 +370,7 @@ def direct_influences_from_factors( [ [ lambda model, loss, train_dataLoader, hessian_reg: CgInfluence( - model, loss, hessian_regularization=hessian_reg + model, loss, regularization=hessian_reg ).fit(train_dataLoader), 1e-1, ], @@ -396,8 +396,8 @@ def direct_influences_from_factors( lambda model, loss, train_dataLoader, hessian_reg: CgInfluence( model, loss, - hessian_regularization=hessian_reg, - pre_conditioner=NystroemPreConditioner(10), + regularization=hessian_reg, + preconditioner=NystroemPreConditioner(10), use_block_cg=True, ).fit(train_dataLoader), 1e-4, @@ -742,7 +742,7 @@ def test_influences_ekfac( @pytest.mark.torch @pytest.mark.parametrize("use_block_cg", [True, False]) @pytest.mark.parametrize( - "pre_conditioner", + "preconditioner", [ JacobiPreConditioner(), NystroemPreConditioner(rank=5), @@ -762,7 +762,7 @@ def test_influences_cg( direct_influences, direct_factors, use_block_cg: bool, - pre_conditioner: PreConditioner, + preconditioner: PreConditioner, device: torch.device, ): model, loss, x_train, y_train, x_test, y_test = model_and_data @@ -775,7 +775,7 @@ def test_influences_cg( loss, test_case.hessian_reg, maxiter=5, - pre_conditioner=pre_conditioner, + preconditioner=preconditioner, use_block_cg=use_block_cg, ) influence_model = influence_model.fit(train_dataloader) @@ -850,6 +850,18 @@ def test_influences_cg( second_order_mode=SecondOrderMode.GAUSS_NEWTON, use_woodbury=True, ), + partial( + CgInfluence, + maxiter=10, + preconditioner=JacobiPreConditioner(), + use_block_cg=True, + ), + partial( + CgInfluence, + maxiter=10, + preconditioner=NystroemPreConditioner(rank=5), + use_block_cg=True, + ), ] diff --git a/tests/influence/torch/test_pre_conditioner.py b/tests/influence/torch/test_pre_conditioner.py index 8aa05b863..97c5f8c00 100644 --- a/tests/influence/torch/test_pre_conditioner.py +++ b/tests/influence/torch/test_pre_conditioner.py @@ -1,6 +1,7 @@ import pytest import torch +from pydvl.influence.torch.operator import MatrixOperator from pydvl.influence.torch.pre_conditioner import ( JacobiPreConditioner, NystroemPreConditioner, @@ -35,6 +36,7 @@ def low_rank_mat(): return approx_low_rank_matrix(size, rank) +@pytest.mark.torch @pytest.mark.parametrize("num_samples_estimator", [1, 3, 5]) def test_jacobi_preconditioner_condition_number(high_cond_mat, num_samples_estimator): preconditioner = JacobiPreConditioner(num_samples_estimator=num_samples_estimator) @@ -45,9 +47,7 @@ def test_jacobi_preconditioner_condition_number(high_cond_mat, num_samples_estim A = high_cond_mat original_cond_number = torch.linalg.cond(A + regularization * torch.eye(size)) - preconditioner.fit( - lambda x: A @ x, size, high_cond_mat.dtype, high_cond_mat.device, regularization - ) + preconditioner.fit(MatrixOperator(A), regularization) assert preconditioner.is_fitted preconditioned_A = preconditioner.solve(A + regularization * torch.eye(size)) @@ -55,10 +55,11 @@ def test_jacobi_preconditioner_condition_number(high_cond_mat, num_samples_estim # Assert that the condition number has decreased assert preconditioned_cond_number < original_cond_number * 10 ** ( - -0.5 * (num_samples_estimator) + -0.5 * num_samples_estimator ) +@pytest.mark.torch def test_nystroem_preconditioner_condition_number(low_rank_mat): preconditioner = NystroemPreConditioner(60) size = low_rank_mat.shape[0] @@ -70,10 +71,7 @@ def test_nystroem_preconditioner_condition_number(low_rank_mat): ) preconditioner.fit( - lambda x: low_rank_mat @ x, - low_rank_mat.shape[0], - low_rank_mat.dtype, - low_rank_mat.device, + MatrixOperator(low_rank_mat), regularization, ) assert preconditioner.is_fitted From bee3e374f7f06f92228b44b6b7418095c8c24998 Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Fri, 14 Jun 2024 13:40:16 +0200 Subject: [PATCH 03/11] Add missing transpose in MatrixOperator --- src/pydvl/influence/torch/operator.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/pydvl/influence/torch/operator.py b/src/pydvl/influence/torch/operator.py index d7e71eb2c..bc5d87e1d 100644 --- a/src/pydvl/influence/torch/operator.py +++ b/src/pydvl/influence/torch/operator.py @@ -606,7 +606,7 @@ def _apply_to_vec(self, vec: torch.Tensor) -> torch.Tensor: return self._apply_to_mat(vec.unsqueeze(dim=0)) def _apply_to_mat(self, mat: torch.Tensor) -> torch.Tensor: - return self.matrix @ mat.t() + return (self.matrix @ mat.t()).t() @property def input_size(self) -> int: @@ -681,7 +681,7 @@ def regularization(self, value: float): "Modifying the regularization value requires " "re-fitting the preconditioner" ) - self.preconditioner = self.preconditioner.fit(self.operator, value) + self.preconditioner.fit(self.operator, value) else: self.preconditioner.regularization = value From 8169c5954ff999123866ba782ecc2e42521d5c60 Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Fri, 14 Jun 2024 13:46:53 +0200 Subject: [PATCH 04/11] Fix parameter names in notebooks --- notebooks/influence_synthetic.ipynb | 2 +- notebooks/influence_wine.ipynb | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/notebooks/influence_synthetic.ipynb b/notebooks/influence_synthetic.ipynb index 6a58dbc79..25b7ada53 100644 --- a/notebooks/influence_synthetic.ipynb +++ b/notebooks/influence_synthetic.ipynb @@ -848,7 +848,7 @@ "influence_model = CgInfluence(\n", " model,\n", " F.binary_cross_entropy,\n", - " hessian_regularization=0.0,\n", + " regularization=0.0,\n", ")\n", "influence_model = influence_model.fit(train_corrupted_data_loader)\n", "influence_values = influence_model.influences(\n", diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index c95397353..a8e523af7 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -748,10 +748,10 @@ "cg_influence_model = CgInfluence(\n", " nn_model,\n", " F.cross_entropy,\n", - " hessian_regularization=0.1,\n", + " regularization=0.1,\n", " progress=True,\n", " use_block_cg=True,\n", - " pre_conditioner=NystroemPreConditioner(rank=5),\n", + " preconditioner=NystroemPreConditioner(rank=5),\n", ")\n", "cg_influence_model = cg_influence_model.fit(training_data_loader)\n", "cg_train_influences = cg_influence_model.influences(\n", From af2f4977f782ba4b7d0638a111b69c6f511aab45 Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Fri, 14 Jun 2024 16:46:51 +0200 Subject: [PATCH 05/11] Fix incorrect transposition of matrix in preconditioner --- src/pydvl/influence/torch/pre_conditioner.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/pydvl/influence/torch/pre_conditioner.py b/src/pydvl/influence/torch/pre_conditioner.py index 2b50bd5d2..caf3f2686 100644 --- a/src/pydvl/influence/torch/pre_conditioner.py +++ b/src/pydvl/influence/torch/pre_conditioner.py @@ -157,14 +157,16 @@ def _fit( $\lambda$ in $(A+\lambda I)x=b$ """ random_samples = torch.randn( - operator.input_size, self.num_samples_estimator, + operator.input_size, device=operator.device, dtype=operator.dtype, ) + diagonal_estimate = torch.sum( - torch.mul(random_samples, operator.apply(random_samples.t())), dim=1 + torch.mul(random_samples, operator.apply(random_samples)), dim=0 ) + diagonal_estimate /= self.num_samples_estimator self._diag = diagonal_estimate self._reg = regularization From fb6a4af83e04517587fb656421075ad4941b9d14 Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Fri, 14 Jun 2024 16:47:30 +0200 Subject: [PATCH 06/11] Refactor preconditoner, change names PreConditioner -> Preconditioner --- docs/influence/influence_function_model.md | 6 +++--- src/pydvl/influence/torch/__init__.py | 2 +- .../torch/influence_function_model.py | 4 ++-- src/pydvl/influence/torch/operator.py | 4 ++-- src/pydvl/influence/torch/pre_conditioner.py | 14 +++++++------- tests/influence/torch/test_influence_model.py | 18 +++++++++--------- tests/influence/torch/test_pre_conditioner.py | 8 ++++---- 7 files changed, 28 insertions(+), 28 deletions(-) diff --git a/docs/influence/influence_function_model.md b/docs/influence/influence_function_model.md index e496d45e4..fc0527fbf 100644 --- a/docs/influence/influence_function_model.md +++ b/docs/influence/influence_function_model.md @@ -30,11 +30,11 @@ https://en.wikipedia.org/wiki/Preconditioner#Jacobi_(or_diagonal)_preconditioner based on Hutchinson's diagonal estimator [@bekas_estimator_2007], or a [Nyström approximation based pre-conditioner ][pydvl.influence.torch.pre_conditioner.NystroemPreConditioner], -described in [@frangella_randomized_2023]. +described in [@frangella_randomized_2023]. ```python from pydvl.influence.torch import CgInfluence -from pydvl.influence.torch.pre_conditioner import NystroemPreConditioner +from pydvl.influence.torch.pre_conditioner import NystroemPreconditioner if_model = CgInfluence( model, @@ -44,7 +44,7 @@ if_model = CgInfluence( atol=1e-7, maxiter=None, use_block_cg=True, - pre_conditioner=NystroemPreConditioner(rank=10) + pre_conditioner=NystroemPreconditioner(rank=10) ) if_model.fit(train_loader) ``` diff --git a/src/pydvl/influence/torch/__init__.py b/src/pydvl/influence/torch/__init__.py index 9dc3a175b..934e3e040 100644 --- a/src/pydvl/influence/torch/__init__.py +++ b/src/pydvl/influence/torch/__init__.py @@ -7,5 +7,5 @@ LissaInfluence, NystroemSketchInfluence, ) -from .pre_conditioner import JacobiPreConditioner, NystroemPreConditioner +from .pre_conditioner import JacobiPreconditioner, NystroemPreconditioner from .util import BlockMode, SecondOrderMode diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index f8bac7d44..edb2b9d4e 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -52,7 +52,7 @@ LissaOperator, LowRankOperator, ) -from .pre_conditioner import PreConditioner +from .pre_conditioner import Preconditioner from .util import ( BlockMode, EkfacRepresentation, @@ -484,7 +484,7 @@ def __init__( maxiter: Optional[int] = None, progress: bool = False, precompute_grad: bool = False, - preconditioner: Optional[PreConditioner] = None, + preconditioner: Optional[Preconditioner] = None, use_block_cg: bool = False, warn_on_max_iteration: bool = True, block_structure: Union[BlockMode, OrderedDict[str, List[str]]] = BlockMode.FULL, diff --git a/src/pydvl/influence/torch/operator.py b/src/pydvl/influence/torch/operator.py index bc5d87e1d..b0c0de3e2 100644 --- a/src/pydvl/influence/torch/operator.py +++ b/src/pydvl/influence/torch/operator.py @@ -24,7 +24,7 @@ TensorAveragingType, ) from .functional import LowRankProductRepresentation -from .pre_conditioner import PreConditioner +from .pre_conditioner import Preconditioner from .util import LossType logger = logging.getLogger(__name__) @@ -648,7 +648,7 @@ def __init__( atol: float = 1e-7, maxiter: Optional[int] = None, progress: bool = False, - preconditioner: Optional[PreConditioner] = None, + preconditioner: Optional[Preconditioner] = None, use_block_cg: bool = False, warn_on_max_iteration: bool = True, ): diff --git a/src/pydvl/influence/torch/pre_conditioner.py b/src/pydvl/influence/torch/pre_conditioner.py index caf3f2686..cb559cc54 100644 --- a/src/pydvl/influence/torch/pre_conditioner.py +++ b/src/pydvl/influence/torch/pre_conditioner.py @@ -11,10 +11,10 @@ if TYPE_CHECKING: from .operator import TensorOperator -__all__ = ["JacobiPreConditioner", "NystroemPreConditioner", "PreConditioner"] +__all__ = ["JacobiPreconditioner", "NystroemPreconditioner", "Preconditioner"] -class PreConditioner(ABC): +class Preconditioner(ABC): r""" Abstract base class for implementing pre-conditioners for improving the convergence of CG for systems of the form @@ -99,12 +99,12 @@ def _solve(self, rhs: torch.Tensor): pass @abstractmethod - def to(self, device: torch.device) -> PreConditioner: + def to(self, device: torch.device) -> Preconditioner: """Implement this to move the (potentially fitted) preconditioner to a specific device""" -class JacobiPreConditioner(PreConditioner): +class JacobiPreconditioner(Preconditioner): r""" Pre-conditioner for improving the convergence of CG for systems of the form @@ -184,13 +184,13 @@ def _solve(self, rhs: torch.Tensor): return rhs * inv_diag.unsqueeze(-1) - def to(self, device: torch.device) -> JacobiPreConditioner: + def to(self, device: torch.device) -> JacobiPreconditioner: if self._diag is not None: self._diag = self._diag.to(device) return self -class NystroemPreConditioner(PreConditioner): +class NystroemPreconditioner(Preconditioner): r""" Pre-conditioner for improving the convergence of CG for systems of the form @@ -281,7 +281,7 @@ def _solve(self, rhs: torch.Tensor): return result - def to(self, device: torch.device) -> NystroemPreConditioner: + def to(self, device: torch.device) -> NystroemPreconditioner: if self._low_rank_approx is not None: self._low_rank_approx = self._low_rank_approx.to(device) return self diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index 65527a51a..92978506b 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -20,9 +20,9 @@ NystroemSketchInfluence, ) from pydvl.influence.torch.pre_conditioner import ( - JacobiPreConditioner, - NystroemPreConditioner, - PreConditioner, + JacobiPreconditioner, + NystroemPreconditioner, + Preconditioner, ) from pydvl.influence.torch.util import BlockMode, SecondOrderMode from pydvl.influence.types import UnsupportedInfluenceModeException @@ -397,7 +397,7 @@ def direct_influences_from_factors( model, loss, regularization=hessian_reg, - preconditioner=NystroemPreConditioner(10), + preconditioner=NystroemPreconditioner(10), use_block_cg=True, ).fit(train_dataLoader), 1e-4, @@ -744,8 +744,8 @@ def test_influences_ekfac( @pytest.mark.parametrize( "preconditioner", [ - JacobiPreConditioner(), - NystroemPreConditioner(rank=5), + JacobiPreconditioner(), + NystroemPreconditioner(rank=5), None, ], ) @@ -762,7 +762,7 @@ def test_influences_cg( direct_influences, direct_factors, use_block_cg: bool, - preconditioner: PreConditioner, + preconditioner: Preconditioner, device: torch.device, ): model, loss, x_train, y_train, x_test, y_test = model_and_data @@ -853,13 +853,13 @@ def test_influences_cg( partial( CgInfluence, maxiter=10, - preconditioner=JacobiPreConditioner(), + preconditioner=JacobiPreconditioner(), use_block_cg=True, ), partial( CgInfluence, maxiter=10, - preconditioner=NystroemPreConditioner(rank=5), + preconditioner=NystroemPreconditioner(rank=5), use_block_cg=True, ), ] diff --git a/tests/influence/torch/test_pre_conditioner.py b/tests/influence/torch/test_pre_conditioner.py index 97c5f8c00..02b804d3d 100644 --- a/tests/influence/torch/test_pre_conditioner.py +++ b/tests/influence/torch/test_pre_conditioner.py @@ -3,8 +3,8 @@ from pydvl.influence.torch.operator import MatrixOperator from pydvl.influence.torch.pre_conditioner import ( - JacobiPreConditioner, - NystroemPreConditioner, + JacobiPreconditioner, + NystroemPreconditioner, ) @@ -39,7 +39,7 @@ def low_rank_mat(): @pytest.mark.torch @pytest.mark.parametrize("num_samples_estimator", [1, 3, 5]) def test_jacobi_preconditioner_condition_number(high_cond_mat, num_samples_estimator): - preconditioner = JacobiPreConditioner(num_samples_estimator=num_samples_estimator) + preconditioner = JacobiPreconditioner(num_samples_estimator=num_samples_estimator) size = high_cond_mat.shape[0] regularization = 0.1 @@ -61,7 +61,7 @@ def test_jacobi_preconditioner_condition_number(high_cond_mat, num_samples_estim @pytest.mark.torch def test_nystroem_preconditioner_condition_number(low_rank_mat): - preconditioner = NystroemPreConditioner(60) + preconditioner = NystroemPreconditioner(60) size = low_rank_mat.shape[0] regularization = 1e-2 From 3b253675808347bb29ee5614b36c9351ee543ffb Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Fri, 14 Jun 2024 16:48:33 +0200 Subject: [PATCH 07/11] Rename module pre_conditioner -> preconditioner --- docs/influence/influence_function_model.md | 2 +- src/pydvl/influence/torch/__init__.py | 2 +- src/pydvl/influence/torch/influence_function_model.py | 2 +- src/pydvl/influence/torch/operator.py | 2 +- .../influence/torch/{pre_conditioner.py => preconditioner.py} | 0 tests/influence/torch/test_influence_model.py | 2 +- tests/influence/torch/test_pre_conditioner.py | 2 +- 7 files changed, 6 insertions(+), 6 deletions(-) rename src/pydvl/influence/torch/{pre_conditioner.py => preconditioner.py} (100%) diff --git a/docs/influence/influence_function_model.md b/docs/influence/influence_function_model.md index fc0527fbf..fcfa0fa27 100644 --- a/docs/influence/influence_function_model.md +++ b/docs/influence/influence_function_model.md @@ -34,7 +34,7 @@ described in [@frangella_randomized_2023]. ```python from pydvl.influence.torch import CgInfluence -from pydvl.influence.torch.pre_conditioner import NystroemPreconditioner +from pydvl.influence.torch.preconditioner import NystroemPreconditioner if_model = CgInfluence( model, diff --git a/src/pydvl/influence/torch/__init__.py b/src/pydvl/influence/torch/__init__.py index 934e3e040..417910de0 100644 --- a/src/pydvl/influence/torch/__init__.py +++ b/src/pydvl/influence/torch/__init__.py @@ -7,5 +7,5 @@ LissaInfluence, NystroemSketchInfluence, ) -from .pre_conditioner import JacobiPreconditioner, NystroemPreconditioner +from .preconditioner import JacobiPreconditioner, NystroemPreconditioner from .util import BlockMode, SecondOrderMode diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index edb2b9d4e..acdfdbffa 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -52,7 +52,7 @@ LissaOperator, LowRankOperator, ) -from .pre_conditioner import Preconditioner +from .preconditioner import Preconditioner from .util import ( BlockMode, EkfacRepresentation, diff --git a/src/pydvl/influence/torch/operator.py b/src/pydvl/influence/torch/operator.py index b0c0de3e2..9941712d0 100644 --- a/src/pydvl/influence/torch/operator.py +++ b/src/pydvl/influence/torch/operator.py @@ -24,7 +24,7 @@ TensorAveragingType, ) from .functional import LowRankProductRepresentation -from .pre_conditioner import Preconditioner +from .preconditioner import Preconditioner from .util import LossType logger = logging.getLogger(__name__) diff --git a/src/pydvl/influence/torch/pre_conditioner.py b/src/pydvl/influence/torch/preconditioner.py similarity index 100% rename from src/pydvl/influence/torch/pre_conditioner.py rename to src/pydvl/influence/torch/preconditioner.py diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index 92978506b..dd998b4f7 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -19,7 +19,7 @@ LissaInfluence, NystroemSketchInfluence, ) -from pydvl.influence.torch.pre_conditioner import ( +from pydvl.influence.torch.preconditioner import ( JacobiPreconditioner, NystroemPreconditioner, Preconditioner, diff --git a/tests/influence/torch/test_pre_conditioner.py b/tests/influence/torch/test_pre_conditioner.py index 02b804d3d..5e658ab9e 100644 --- a/tests/influence/torch/test_pre_conditioner.py +++ b/tests/influence/torch/test_pre_conditioner.py @@ -2,7 +2,7 @@ import torch from pydvl.influence.torch.operator import MatrixOperator -from pydvl.influence.torch.pre_conditioner import ( +from pydvl.influence.torch.preconditioner import ( JacobiPreconditioner, NystroemPreconditioner, ) From cdb3b4cb8ea3229356d39a9a97b52b359d56a1cb Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Fri, 14 Jun 2024 16:58:06 +0200 Subject: [PATCH 08/11] Fix import from renamed module in notebook --- notebooks/influence_wine.ipynb | 68 +++++++++++++++++----------------- 1 file changed, 34 insertions(+), 34 deletions(-) diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index a8e523af7..a0810e303 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -272,7 +272,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2d32133485e7424c8079260a4424c5bd", + "model_id": "e2cb0003db824943874a926f33a57b58", "version_major": 2, "version_minor": 0 }, @@ -334,7 +334,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -373,7 +373,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAysAAAKvCAYAAABqAVAmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABBiklEQVR4nO3deZilZ1kn/u/dne7O0p3ORjbCkgQIA8FhiWxGBGMQEQVE1FFk0RmEQYdtmDH+MEJQcBgmgxpGBRWCKAoICEoIsgkoBAiGJSYhkAQI2bdOJ53eqp7fH+c0VKq7uruW95y3Tn8+1/Ve1e/zLs9dlZyk7r6fpVprAQAA6JsV4w4AAABgVyQrAABAL0lWAACAXpKsAAAAvSRZAQAAekmyAgAA9JJkBQAA6CXJCgAA0Ev7jTuApVRVleTYJBvHHQsAAN+zLsk1bR/bjbyq9k+yekzdb22tbR5T30tmopKVDBKVq8cdBAAAOzkuyXfHHcSoVNX+Rx+58q7rbpgaVwjXVdXxyz1hmbRkZWOSfOtL983Ba41wg73x9Ac8ZNwhADDBtmdbPpMPJfveyJfV190wlW9deN8cvG60v5fevnE693nEVUdnUNWRrPTNwWtXjPxfCliu9qtV4w4BgEm2Tw382tnadZW162qkfU5ntP11yW/0AABAL0lWAACAXprIYWAAANAHU206UyMeCjfVpkfbYYdUVgAAgF5SWQEAgI5Mp2V6xKsMjLq/LqmsAAAAvaSyAgAAHZnOdEY9g2T0PXZHZQUAAOglyQoAANBLhoEBAEBHplrLVBvthPdR99cllRUAAKCXVFYAAKAjli5eHJUVAACglyQrAABALxkGBgAAHZlOy5RhYAumsgIAAPSSygoAAHTEBPvFUVkBAAB6SWUFAAA6YlPIxVFZAQAAekmyAgAA9JJhYAAA0JHp4THqPieFygoAAOzDquqMqvpCVW2sqhuq6v1VddKse/avqjdV1c1VdUdV/V1VHbWH91ZVnVVV11bVXVX10aq6/3xik6wAAEBHpoabQo76mKcfSfKmJI9OcnqSVUk+UlUHzbjn/yb5qSTPHN5/bJL37uG9/yPJf0vygiSPSnJnkvOrav+9DcwwMAAA2Ie11p4087yqnpvkhiSPSPKpqlqf5FeT/GJr7ePDe56X5JKqenRr7XOz31lVleQlSX63tfb3w7ZnJ7k+ydOS/M3exKayAgAAk2ldVR0841izl8+tH369Zfj1ERlUWz6644bW2qVJvp3kMXO84/gkR896ZkOSC3bzzE5UVgAAoCNTbXCMus+hq2ddenWSV+3u2apakeSNSf6ltfa1YfPRSba21m6bdfv1w2u7cvSMe/b2mZ1IVgAAYDIdl2TjjPMte/HMm5KcnOTUTiKaJ8kKAAB0ZMxLF29srd2+t89V1TlJnpLkca21mVWZ65KsrqpDZlVXjhpe25XrZtxz7axnLtrbmMxZAQCAfdhwieFzkjw9yY+21q6cdcuFSbYlOW3GMycluXeSz87x2iszSFhmPnNwBquCzfXMTlRWAACgI9OpTKVG3uc8vSnJLyZ5apKNVbVjTsmG1tpdrbUNVfXnSc6uqluS3J7kj5J8duZKYFV1aZIzWmvva621qnpjkldW1eUZJC+vSXJNkvfvbWCSFQAA2Le9cPj1k7Pan5fkbcM/vzSDEWZ/l2RNkvOT/NdZ95+U768kliSvT3JQkjcnOSTJZ5I8qbW2eW8Dk6wAAMA+rLW2x1LMMMF40fDYq/e01lqSM4fHgkhWAACgI9NtcIy6z0lhgj0AANBLKisAANCRqTFMsB91f11SWQEAAHpJsgIAAPSSYWAAANARw8AWR2UFAADoJZUVAADoyHSrTO95G5Ml73NSqKwAAAC9pLICAAAdMWdlcVRWAACAXpKsAAAAvWQYGAAAdGQqKzI14vrA1Eh765bKCgAA0EsqKwAA0JE2hqWLm6WLAQAAuiVZAQAAeskwMAAA6Ih9VhZHZQUAAOgllRUAAOjIVFuRqTbipYvbSLvrlMoKAADQSyorAADQkelUpkdcH5jO5JRWVFYAAIBekqwAAAC9ZBgYAAB0xNLFi6OyAgAA9JLKCgAAdGQ8SxebYA8AANApyQoAANBLhoEBAEBHBvusjHbC+6j765LKCgAA0EsqKwAA0JHprMiUHewXTGUFAADoJckKAADQS4aBAQBAR+yzsjgqKwAAQC+prAAAQEemsyLTJtgvmMoKAADQSyorAADQkalWmWqj3aRx1P11SWUFAADoJckKAADQS4aBAQBAR6bGsIP9lAn2AAAA3VJZAQCAjky3FZke8aaQ0zaFBAAA6JZkBQAA6CXDwAAAoCMm2C+OygoAANBLKisAANCR6Yx+R/npkfbWLZUVAACgl1RWAACgI9NZkekR1wdG3V+XJuc7AQAAJopkBQAA6CXDwAAAoCNTbUWmRryD/aj769LkfCcAAMBEUVkBAICOTKcynVEvXTza/rqksgIAAPSSZAUAAOglw8AAAKAjJtgvjmSFRbvsogPyT+86LF/+17W5/jurc/ChU3ngI+7Mc//HdTnuxC3fu+/Sfzsw//Suw3Lplw7MlZcckKntlfOvuWh8gUMPrVo9nWe/4rqc9oxbs3b9VK685ICc+/qj86VPrRt3aNBLPjMw2SYn7WJs3vWmo/IvHzokDzv1jrzwrO/myc+6OV/73Nq86McfkKsu3f97933hYwfnw399WKqSY+69ZTdvhH3Xy9/4nfzM82/Mx993aP74zHtmejp5zV9ekQc/8o5xhwa95DND301lxViOSVGttXHHsGSq6uAkG279+gk5eN3k/EPqu4u/cGAe8B/vyqrV3/936btXrM6vnfbA/PBP3pb/ec63kyS33rhfDlw7lTUHtJzzW/fMB992D5WVHvjxYx867hAYOumhm/KHH7o8bznrmLznT45MkqxaM503f/yy3HbzfnnpT99/zBFCv/jMLA/b27Z8Mn+fJOtba7ePO55R2fF76Ru+eGoOWDvawUx33bE9//2UzyQT8DPv5W/0VfWiqrqqqjZX1QVV9chxx8TcHvyDm+6WqCTJPU/Ymvs8YHO+ffn3KyuH3mN71hwwOckxLLVTn3JbprYnH3rH4d9r27ZlRT78zsPyoFM25R7Hbh1jdNA/PjMsB9OtxnLMR1U9rqo+WFXXVFWrqqfNut7mOF6xm3e+ahf3Xzrfn1/vkpWq+vkkZyd5dZKHJ/lykvOr6sixBsa8tJbcdtN+WX/Y9nGHAsvG/U6+K1dfsSab7lh5t/bLLjowSXLCg+8aR1jQWz4zsGQOyuB37hfNcf2YWcevJGlJ/m4P77141nOnzjewPk6wf1mSt7TW3pokVfWCJD+ZwQ/l98cZGHvv4+89NDdduzrP/u/XjTsUWDYOO3J7brl+1U7tO9oOP0ryDzP5zMDSaK2dl+S8JKnauSrTWrvbL3RV9dQkn2itXbGHV2+f/ex89SpZqarVSR6R5HU72lpr01X10SSP2cX9a5KsmdFk6Y8e+Pbla3LObx2X//CIO/NjP3fLuMOBZWP1/tPZtnXn/0ls3TJoW7P/9KhDgl7zmWE5mB7DhPfp7/e3blbysaW1tqhVjqrqqAwKCc/Zi9vvX1XXJNmc5LNJzmitfXs+/fVtGNgRSVYmuX5W+/VJjt7F/Wck2TDjuLrT6NijW27YL2c++4QctG4qv/2WK7Ny5Z6fAQa2bl6x0/yvJFm9ZtC2ZXPf/pMN4+UzA3t0de7+u/IZS/DO5yTZmOS9e7jvgiTPTfKkJC9McnyST1fVvIoLvaqsLMDrMpjfssO6SFjG5s7bV+SVv3RC7rh9Zf7P+y7P4Ucrv8N83HLDfjn86G07tR921KDt5uuX+3+yYWn5zLAcTLcVmR7xJo0z+jsug8Rih6XYO+JXkvxVa23z7m4aDi3b4StVdUGSbyX5uSR/vred9e2vHG5KMpXkqFntRyXZabxba21La+32HUfu/g+DEdq6uXLmc07I1VesyVnnXpH7PMA+KjBf37z4gBx3wpYcuHbqbu0PfNimJMkVFx8wjrCgt3xmYI82zvxdeQmGgP1wkpOS/Nl8n22t3Zbk60nuN5/nepWstNa2JrkwyWk72qpqxfD8s+OKi92bmkp+7wX3zSUXHpRXvvmqPOiUTeMOCZalT//D+qzcL3nys27+Xtuq1dN54s/fkksuPDA3XrN6jNFB//jMwMj9apILW2tfnu+DVbU2yYlJrp3Pc32sj56d5Nyq+mKSzyd5SQbLqb11nEExtze/+p753EfW59Gnb8jG2/bLx/7u0LtdP+0ZtyZJrr96VT72nsOSJJd/ZbCs5F+/cVBEO/K4rfmxn711hFFD/1z2bwflUx9Yn+edcW3WH7E911y5Jqf/3C056l5bc/bL7zXu8KB3fGZYDqZSmcr89j1Zij7nY5hIzKx4HF9VD01yy44J8cNNLp+Z5OVzvONjSd7XWjtneP6GJB/MYOjXsRlsSzKV5J3zia13yUpr7W+r6h5JzspgUv1FSZ7UWps96Z6e2FFm/9w/rc/n/mn9Ttd3JCvXfXtNzn39MXe7tuP8Bx5zh2QFkrz+xffOc757XU57xq1Zt34qV16yf8589vH52gVrxx0a9JLPDCyJU5J8Ysb5jjnh52YwST5JfiFJZe5k48QMFsva4bjhvYcnuTHJZ5I8urV243wCq9YmZ0fxYca34davn5CD1/VqhBv01o8f+9BxhwDABNvetuWT+fskWT+cY7xP2PF76asv+LHsv3a09YHNd2zP7zzqo8kE/Mz9Rg8AAPRS74aBAQDApJjK/OeQLEWfk0JlBQAA6CXJCgAA0EuGgQEAQEfGvIP9sjc53wkAADBRVFYAAKAjU21FpkZc6Rh1f12anO8EAACYKJIVAACglwwDAwCAjrRUpke8z0obcX9dUlkBAAB6SWUFAAA6YoL94kzOdwIAAEwUlRUAAOjIdKtMt9HOIRl1f11SWQEAAHpJsgIAAPSSYWAAANCRqazI1IjrA6Pur0uT850AAAATRWUFAAA6YoL94qisAAAAvSRZAQAAeskwMAAA6Mh0VmR6xPWBUffXpcn5TgAAgImisgIAAB2ZapWpEU94H3V/XVJZAQAAekllBQAAOmLp4sVRWQEAAHpJsgIAAPSSYWAAANCR1lZkuo22PtBG3F+XJuc7AQAAJorKCgAAdGQqlamMeOniEffXJZUVAACglyQrAABALxkGBgAAHZluo9/3ZLqNtLtOqawAAAC9pLICAAAdmR7D0sWj7q9Lk/OdAAAAE0WyAgAA9JJhYAAA0JHpVKZHvO/JqPvrksoKAADQSyorAADQkalWmRrx0sWj7q9LKisAAEAvqawAAEBHLF28OJPznQAAABNFsgIAAPSSYWAAANCR6VSmRzzh3dLFAAAAHVNZAQCAjrQxbArZVFYAAAC6JVkBAAB6yTAwAADoyHQbwwR7O9gDAAB0S2UFAAA6Ygf7xZmc7wQAAJgoKisAANARc1YWR2UFAADoJckKAADQS4aBAQBAR6bHsIP9qPvrksoKAADQSyorAADQERPsF0dlBQAA6CXJCgAA0EuSFQAA6MiOYWCjPuajqh5XVR+sqmuqqlXV02Zdf9uwfebx4b1474uq6qqq2lxVF1TVI+f305OsAADAvu6gJF9O8qLd3PPhJMfMOP7T7l5YVT+f5Owkr07y8OH7z6+qI+cTmAn2AADQkeUwwb61dl6S85Kkas5nt7TWrpvHa1+W5C2ttbcO3/uCJD+Z5FeS/P7evkRlBQAA2JPHV9UNVXVZVf1xVR0+141VtTrJI5J8dEdba216eP6Y+XSqsgIAAB0Zc2Vl3axKyZbW2pYFvPLDSd6b5MokJyZ5bZLzquoxrbWpXdx/RJKVSa6f1X59kgfOp2PJCgAATKarZ52/Osmr5vuS1trfzDj9alV9Jck3kzw+yccWGtzekKwAAMBkOi7JxhnnC6mq7KS1dkVV3ZTkftl1snJTkqkkR81qPyrJfOa9mLMCAABdaUmmUyM92ve739hau33GsSTJSlUdl+TwJNfu8ntubWuSC5OcNuOZFcPzz86nL5UVAADYh1XV2gyqJDscX1UPTXLL8PidJH+XQVXkxCSvT/KNJOfPeMfHkryvtXbOsOnsJOdW1ReTfD7JSzJYIvmt84lNsgIAAB1ZDksXJzklySdmnJ89/Hpukhcm+YEkz0lySJJrknwkyW/PqtScmMHE+iRJa+1vq+oeSc5KcnSSi5I8qbU2e9L9bklWAABgH9Za+2SS3WU4P74X77jvLtrOSXLOznfvPXNWAACAXlJZAQCAjiyTYWC9pbICAAD0ksoKAAB0RGVlcVRWAACAXlJZAQCAjqisLI7KCgAA0EuSFQAAoJcMAwMAgI60VmkjHpY16v66pLICAAD0ksoKAAB0ZDqV6Yx4gv2I++uSygoAANBLkhUAAKCXDAMDAICO2GdlcVRWAACAXlJZAQCAjli6eHFUVgAAgF5SWQEAgI6Ys7I4KisAAEAvSVYAAIBeMgwMAAA6YoL94qisAAAAvaSyAgAAHWljmGA/SZWViUxWnv6Ah2S/WjXuMGBZ+KVLrx53CLDs/O1P/NC4Q4DlY3pLctW4g2C5MgwMAADopYmsrAAAQB+0JK2Nvs9JobICAAD0ksoKAAB0ZDqVyoh3sB9xf11SWQEAAHpJZQUAADpiU8jFUVkBAAB6SbICAAD0kmFgAADQkelWqREPy5o2DAwAAKBbKisAANCR1sawKeQE7QqpsgIAAPSSZAUAAOglw8AAAKAj9llZHJUVAACgl1RWAACgIyori6OyAgAA9JJkBQAA6CXDwAAAoCN2sF8clRUAAKCXVFYAAKAjdrBfHJUVAACgl1RWAACgI4PKyqiXLh5pd51SWQEAAHpJsgIAAPSSYWAAANARO9gvjsoKAADQSyorAADQkTY8Rt3npFBZAQAAekmyAgAA9JJhYAAA0BET7BdHZQUAAOgllRUAAOiKGfaLorICAAD0ksoKAAB0ZQxzVmLOCgAAQLckKwAAQC8ZBgYAAB1pbXCMus9JobICAAD0kmQFAAA6smNTyFEf81FVj6uqD1bVNVXVquppM66tqqr/VVVfrao7h/e8vaqO3cM7XzV818zj0vn+/CQrAACwbzsoyZeTvGgX1w5M8vAkrxl+/ZkkJyX5wF689+Ikx8w4Tp1vYOasAADAPqy1dl6S85KkqmZf25Dk9JltVfXrST5fVfdurX17N6/e3lq7bjGxSVYAAKArrUa/78n3+1s3K/nY0lrbsgQ9rE/Skty2h/vuX1XXJNmc5LNJzthDcrMTw8AAAGAyXZ1kw4zjjMW+sKr2T/K/kryztXb7bm69IMlzkzwpyQuTHJ/k01W1bj79qawAAEBHxrx08XFJNs64tKiqSlWtSvKuJJVBArKbGNp5M06/UlUXJPlWkp9L8ud726dkBQAAJtPGPVQ/9tqMROU+SX50vu9trd1WVV9Pcr/5PGcYGAAAdKWN6VhCMxKV+yf5sdbazQt4x9okJya5dj7PSVYAAGAfVlVrq+qhVfXQYdPxw/N7DxOV9yQ5JckvJVlZVUcPj9Uz3vGx4SphO87fUFU/UlX3rarHJnlfkqkk75xPbIaBAQDAvu2UJJ+YcX728Ou5SV6V5KeH5xfNeu4JST45/POJSY6Yce24DBKTw5PcmOQzSR7dWrtxPoFJVgAAoCML2VF+Kfqc3/3tkxlMmp/LHl/YWrvvrPNfmFcQczAMDAAA6CWVFQAA6NKIly6eJCorAABAL0lWAACAXjIMDAAAOrIcJtj3mcoKAADQSyorAADQlQ52lN+rPieEygoAANBLKisAANCZyl7sqdhBn5NBZQUAAOglyQoAANBLhoEBAEBXTLBfFJUVAACgl/aqslJVj1vIy1trn1rIcwAAMBFUVhZlb4eBfTLz+7ZreP/K+QYEAACQ7H2y8oROowAAAJhlr5KV1to/dx0IAABMnFaDY9R9TohFT7CvqmOq6j9W1UFLERAAAECyiGSlqp5aVZcmuTrJl5I8ath+RFX9W1U9bWlCBACA5am18RyTYkHJSlX9VJL3JrkpyaszmFCfJGmt3ZTku0metxQBAgAA+6aFVlbOTPKp1tqpSd60i+ufTfKwBUcFAACToI3pmBALTVZOTvKu3Vy/PsmRC3w3AADAgpOVTUl2N6H+hCQ3L/DdAAAAC05WPpHkOVW109LHVXV0kv+S5COLCQwAAJa9HUsXj/qYEAtNVv6/JMcl+UKSX8tgZNyPV9XvJvlqBhPuX70kEQIAAPukvd3B/m5aa5dV1alJ/iDJazJITl4xvPzJJC9qrV21FAECAMByVW1wjLrPSbGgZCVJWmsXJ/mxqjo0yf0yqNJc0Vq7camCAwAA9l0LTlZ2aK3dmsFwMAAAgCWzmB3s71FVb6iqf6+qTcPj34dtRy1lkAAAsCzZZ2VRFrqD/YMzmEj/siQbkrx7eGwYtn2lqk5eqiABAIB9z0KHgb0pycokj2qt3W0IWFU9MsmHkvxRkicsLjwAAFjGxrGUsKWL88gkfzA7UUmS1trnM1gl7FGLCQwAANi3LbSyckOSzbu5vnl4DwAA7LvGMYdkX5+zkuSNSV443K3+bqrq2CQvHN4DAACwIHtVWamql+2i+Y4k36iq9yX5xrDt/kmeNjyfnMFyAADAyO3tMLA37ObaL+2i7QeGz/zfeUcEAACTwjCwRdnbZOX4TqMAAACYZa+Sldbat7oOBAAAJo7KyqIseAd7AACALi106eJU1Q8k+Y0kD0+yPjsnPq21duIiYgMAAPZhC6qsVNXjk3w+yVOSXJPkhCRXDP98nwxWCvvUkkQIAADL1Y4d7Ed9TIiFDgM7K4Pk5KQkzxu2vba1dmqSxyY5Lsm7Fh8eAACwr1posvLwJH/eWrs9ydSwbWWStNYuSPKnSV6z+PAAAGD5qjaeY1IsNFnZnmTj8M+3JdmW5MgZ169I8qCFhwUAAOzrFjrB/hsZ7Faf1lqrqkuTPD3JXw2v/2SS6xYfHsvdqtXTefYrrstpz7g1a9dP5cpLDsi5rz86X/rUunGHBmO17c7KJX++Ljd9ZXVu/urqbN2wIo9+7S058Wc27XTvt847IJe8bW1uv2JVakXLIfffngf954255+M3jyFy6I/7P/DWnPbk7+QHHn5zjjp6U27fsDqXXXxo3v6WB+aa76wdd3jAElhoZeVDSf5TVe1Ids5O8jNVdXlVXZ7kpzMYCsY+7uVv/E5+5vk35uPvOzR/fOY9Mz2dvOYvr8iDH3nHuEODsdpy64p89f8dnA1X7JdDT9o6532X/eVB+cxLD8+aQ6bz0JdvyEP+68Zsu6PyyRcckW9/ZP8RRgz987PP+kZ+6EeuzZe/eET+9A9Ozoc/cJ+c/NCb84d/8c+5z/G3jzs8GGhjOibEQisrr0nyBxnOV2mtnVtVU0meMWz7vdba25YkQpatkx66KU942m15y1nH5D1/Mhgl+NH3HJo3f/yy/OdXXpuX/vT9xxwhjM8BR07lZz59TQ64x3Ru/uqqfPiZu048LnvH2hz+kK15/J/cnBou7nLiM+7Mex93TK58/0G59xNVV9h3vf9vTsz/ftUjsn379//u9dMfOzZvevsn88xfvjxvOOsRY4wOWAoLqqy01ra11m5urbUZbe9orT29tfazC01UqupxVfXBqrqmqlpVPW0h76EfTn3KbZnannzoHYd/r23blhX58DsPy4NO2ZR7HDv33ybDpFu5OjngHtN7vG/bnSuy5rCp7yUqSbJqbct+B7Ws3H+C/uoMFuCSrx12t0QlSa65em2+feW63Os+KvgwCfq2g/1BSb6c5EXjDoTFu9/Jd+XqK9Zk0x0r79Z+2UUHJklOePBd4wgLlpWjHrkl135m/1z2lwfljqtXZsMV++XzZx2SbRsrJ/2yX8ZgZy2HHLYlGzasHncgwBLYq2FgVfXxBby7tdZOm+cD5yU5b9jnArqkTw47cntuuX7VTu072g4/avuoQ4Jl55T/77ZsuXVFvvh7h+aLvzdoW3PoVE576025x8NUJ2G2Jzzx6hxx5Oa8488eOO5QIElSGf1SwpP0W/TezllZkflP1ZmknxMLsHr/6WzbuvO/Blu3DNrW7L/nITCwr1u5f8u647fnwKPuzD0fvznb7qxceu7afOq/HZ4nvuOGrLvP1J5fAvuI4+69MS98+VdzyVcPzcfOu9e4wwGWwF4lK621x3ccx4JU1Zoka2Y0WQ+3R7ZuXpFVq3fOcVevGbRt2dy3UYjQP59+yeFZsbLl8X9y8/fajjvtrnzgx4/ORW9cnx/+v7eMMTroj0MP25xXveGC3HnHqrz2lT+Y6Wl/ZwqTYLn/tnhGkg0zjqvHGw4z3XLDfjnsqG07te9ou/n6hS5GB/uGjd9ZmWs/vX+O+9G7r/i15pCWIx+xNTd+yZh8SJIDD9qWV/+fz+Wgtdty5ssfnVtusqw3PdJqPMeEWO7JyuuSrJ9xHDfecJjpmxcfkONO2JID1959mMoDHzbY9O6Kiw8YR1iwbGy+abA4xfQuRkxOb0/a1OT8zwgWatXqqfzO6y/IPe91Z179ikflO1cZZAGTZFknK621La2123ccSTaOOya+79P/sD4r90ue/KzvD19ZtXo6T/z5W3LJhQfmxmv8rTDszrr7bE+taPn2hw5ImzGictN1K3PDF9fk0P+wc+US9iUrVrT85lkX5oEn35rX/fYpufTiw8YdEuzMppCL0qtxOFW1Nsn9ZjQdX1UPTXJLa+3b44mKhbrs3w7Kpz6wPs8749qsP2J7rrlyTU7/uVty1L225uyXm/gIl73joGzduCJ33TCooHz3E/tn0/WDP5/0rDuy/2HTOeEZd+ab716bjz33iNzr9Luy7c4VufydB2VqS+XBz7dDN/u2X/2Ni/PoH74uF3zmqKxbtzVPeOJ37nb9Ex/x/xpY7nqVrCQ5JcknZpyfPfx6bpLnjjwaFu31L753nvPd63LaM27NuvVTufKS/XPms4/P1y5YO+7QYOwu+Yt1ufOa7/9n+Dv/dGC+80+DPx//U5uyet1UHvk7t+XQk7blm393UC46e32S5PCHbM1jfv/WHPWDli5m33bC/TYkSR516vV51KnX73RdsgLLX6+SldbaJ2PJ44mybcuK/Nlrjs2fvebYcYcCvfO0j1+3x3tW7Jec9Kw7c9Kz7hxBRLC8nPEbPzTuEGDPxjEsyzCwgaq6Z5LHJTkyyd+11q6uqpUZTHbf0FqzAQAAALAgC0pWarC9/P9J8uvDd7QkX81g6eC1Sa5KcmaSNy5FkAAAsBxVG8MO9hNUWVnoamCvSPLiJG9IcnpmDN1qrW1I8t4kz1h0dAAAwD5rocPA/kuSt7fWfquqDt/F9a8k+YmFhwUAABPAnJVFWWhl5V5J/nU31+9McvAC3w0AAIxIVT2uqj5YVddUVauqp826XlV1VlVdW1V3VdVHq+r+e/HeF1XVVVW1uaouqKpHzje2hSYrN2SQsMzlEUnsiwIAAP13UJIvJ3nRHNf/R5L/luQFSR6VQWHi/Kraf64XVtXPZ7ANyauTPHz4/vOr6sj5BLbQZOW9SV5QVSfMaGvDwJ6YwZ4o717guwEAYDIsgx3sW2vntdZe2Vp73+xrw4W1XpLkd1trf99a+0qSZyc5NsnTdvPalyV5S2vtra21f88g0dmU5FfmE9tCk5XfSXJtkouSvD2DH8n/rKrPJDkvgzkrr13guwEAgMVbV1UHzzjWLOAdxyc5OslHdzQMF9S6IMljdvVAVa3OYKTVzGemh+e7fGYuC0pWhgE+Osnrk9wzyeYkP5LkkAxKPT/cWtu0kHcDAMCk2LF08aiPoauTbJhxnLGAb+Ho4dfrZ7VfP+PabEckWTnPZ3ZpwZtCttbuSvK7wwMAAOiX45JsnHG+ZVyBLNRCh4EBAAD9trG1dvuMYyHJynXDr0fNaj9qxrXZbkoyNc9ndmmhO9j/xV7c1lprv7qQ9wMAwERoNThG3efSuTKDBOO0DOarp6oOzmBVsD/eZfetba2qC4fPvH/4zIrh+Tnz6Xyhw8B+NDuvM7AyyTHDrzdmsKQZAADQY1W1Nsn9ZjQdX1UPTXJLa+3bVfXGJK+sqsszSF5ek+SaDBOR4Ts+luR9rbUdycjZSc6tqi8m+XwGK4odlOSt84ltQclKa+2+u2qvqlVJfm0YzOkLeTcAAEyM5bGD/SlJPjHj/Ozh13Mz2JLk9RkkGm/OYEGtzyR5Umtt84xnTsxgYv0ghNb+tqrukeSsDCbVXzR8Zvak+91a8AT7XWmtbUtyTlU9KIMSz08u5fsBAICl1Vr7ZJI5x4611lqSM4fHXPfcdxdt52Sew75mW9JkZYYvJ/nljt4NAADLwqylhEfW56ToajWw0zPYoRIAAGBBFroa2FwloEOSPC7Jw5P8/gJjAgAAWPAwsFfN0X5rkm8meUGStyzw3QAAMBmWxwT73lroamA2kwQAADo176Sjqg6oqrOr6qe6CAgAACZG+/4k+1Edk1RZmXey0lq7K4O9VI5a+nAAAAAGFjqc68IkJy9lIAAAADMtdIL9S5J8qKq+luRtrbXtSxcSAABMCBPsF2Wvk5WqelySS1prNyY5N8l0kj9N8odV9d0kd816pLXW/uOSRQoAAOxT5lNZ+USSZyV5Z5Kbk9yU5LIuggIAgImgsrIo80lWaniktfb4TqIBAAAYWuicFQAAYA++t5zwiPucFPNdDWyCvnUAAKDP5pusvKOqpvbysEIYAACwYPMdBvbRJF/vIhAAAICZ5pusnNta++tOIgEAAJjBBHsAAOiKpYsXZb5zVgAAAEZCsgIAAPTSXg8Da61JbAAAYB7ss7I4EhAAAKCXTLAHAIAuTVClY9RUVgAAgF5SWQEAgK5YunhRVFYAAIBekqwAAAC9ZBgYAAB0xNLFi6OyAgAA9JLKCgAAdMUE+0VRWQEAAHpJsgIAAPSSYWAAANARE+wXR2UFAADoJZUVAADoign2i6KyAgAA9JLKCgAAdEVlZVFUVgAAgF6SrAAAAL1kGBgAAHTE0sWLo7ICAAD0ksoKAAB0xQT7RVFZAQAAekmyAgAA9JJhYAAA0BXDwBZFZQUAAOgllRUAAOiIpYsXR2UFAADoJckKAADQS4aBAQBAV0ywXxSVFQAAoJdUVgAAoCMm2C+OygoAANBLKisAANAVc1YWRWUFAADoJckKAADQS4aBAQBAVwwDWxSVFQAAoJdUVgAAoCM1PEbd56RQWQEAAHpJsgIAAPSSYWAAANAVE+wXRWUFAAD2YVV1VVW1XRxvmuP+5+7i3s1dxKayAgAAHak2OEbd5zz9YJKVM85PTvJPSd69m2duT3LSjPNOvkvJCgAA7MNaazfOPK+q30zyzST/vPvH2nWdBhbDwAAAoDttTMcCVdXqJM9K8hettd29aW1VfauqvlNVf19VD154r3OTrAAAwGRaV1UHzzjW7MUzT0tySJK37eaey5L8SpKnZpDYrEjyr1V13OLC3ZlkBQAAJtPVSTbMOM7Yi2d+Ncl5rbVr5rqhtfbZ1trbW2sXtdb+OcnPJLkxya8tQcx3Y84KAAB0aXxLCR+XZOOM8y27u7mq7pPkxzJIPvZaa21bVf1bkvvNO8I9UFkBAIDJtLG1dvuMY7fJSpLnJbkhyT/Op5OqWpnkIUmuXWCcc1JZAQCAjiyTpYtTVSsySFbOba1tn3Xt7Um+21o7Y3h+ZpLPJflGBvNbXpHkPkn+bDFx74pkBQAA+LEk907yF7u4du8k0zPOD03yliRHJ7k1yYVJHtta+/elDkqyAgAA+7jW2keS1BzXHj/r/KVJXjqCsCQrAADQmUXue7LgPieECfYAAEAvqawAAEBHlssE+75SWQEAAHpJZQUAALpizsqiqKwAAAC9JFkBAAB6yTAwAADoiAn2iyNZgX3cXz3wuHGHAMvOt9998LhDgGVjatPm5NnjjoLlSrICAABdMcF+UcxZAQAAekmyAgAA9JJhYAAA0BXDwBZFZQUAAOgllRUAAOiIpYsXR2UFAADoJZUVAADoijkri6KyAgAA9JJkBQAA6CXDwAAAoCPVWqqNdlzWqPvrksoKAADQSyorAADQFRPsF0VlBQAA6CXJCgAA0EuGgQEAQEfsYL84KisAAEAvqawAAEBXTLBfFJUVAACgl1RWAACgI+asLI7KCgAA0EuSFQAAoJcMAwMAgK6YYL8oKisAAEAvqawAAEBHTLBfHJUVAACglyQrAABALxkGBgAAXTHBflFUVgAAgF5SWQEAgA5N0oT3UVNZAQAAekllBQAAutLa4Bh1nxNCZQUAAOglyQoAANBLhoEBAEBH7GC/OCorAABAL6msAABAV2wKuSgqKwAAQC9JVgAAgF4yDAwAADpS04Nj1H1OCpUVAACgl1RWAACgKybYL4rKCgAA0EuSFQAAoJcMAwMAgI7YwX5xVFYAAIBeUlkBAICutDY4Rt3nhFBZAQAAekllBQAAOmLOyuKorAAAAL0kWQEAAHrJMDAAAOiKHewXRWUFAADoJZUVAADoiAn2i6OyAgAA+7CqelVVtVnHpXt45plVdWlVba6qr1bVk7uITbICAABcnOSYGcepc91YVY9N8s4kf57kYUnen+T9VXXyUgdlGBgAAHRl+exgv721dt1e3vviJB9urf3v4flvV9XpSX49yQsW0vlcVFYAAGAyrauqg2cca3Zz7/2r6pqquqKq/qqq7r2bex+T5KOz2s4fti8pyQoAAHRkxwT7UR9DVyfZMOM4Y44wL0jy3CRPSvLCJMcn+XRVrZvj/qOTXD+r7fph+5IyDAwAACbTcUk2zjjfsqubWmvnzTj9SlVdkORbSX4ug3kpYyNZAQCArox3U8iNrbXb5/14a7dV1deT3G+OW65LctSstqOG7UvKMDAAAOB7qmptkhOTXDvHLZ9NctqsttOH7UtKsgIAAPuwqnpDVf1IVd13uCzx+5JMZbA8carq7VX1uhmP/EGSJ1XVy6vqgVX1qiSnJDlnqWMzDAwAADqyTHawPy6DxOTwJDcm+UySR7fWbhxev3eS6R03t9b+tap+McnvJnltksuTPK219rXFRb4zyQoAAOzDWmu/sIfrj99F27uTvLurmHaQrAAAQFem2+AYdZ8TwpwVAACglyQrAABALxkGBgAAXRnvPivLnsoKAADQSyorAADQkcoYli4ebXedUlkBAAB6SWUFAAC60trgGHWfE0JlBQAA6CXJCgAA0EuGgQEAQEeqjWGC/eSMAlNZAQAA+kllBQAAumJTyEVRWQEAAHpJsgIAAPSSYWAAANCRai014n1PRt1fl1RWAACAXlJZAQCArkwPj1H3OSFUVgAAgF5SWQEAgI6Ys7I4KisAAEAvSVYAAIBeMgwMAAC6Ygf7RVFZAQAAekllBQAAutLa4Bh1nxNCZQUAAOglyQoAANBLhoEBAEBHqg2OUfc5KVRWAACAXlJZoVOrVk/n2a+4Lqc949asXT+VKy85IOe+/uh86VPrxh0a9JLPDMyt7prKwR+4Kasv35TV37grK++cys3/9bjc+YRD73bfQR+9JQd96rasumZLVtw5lalD98vmB6/NhmcemakjV48pevZZJtgvisoKnXr5G7+Tn3n+jfn4+w7NH595z0xPJ6/5yyvy4EfeMe7QoJd8ZmBuKzZOZf17bsiq727JtvvuP+d9q6+8K9uPXJXbn3pEbvkvx+bOxx2SA/5tY47+zW9k5S3bRhgxsFgqK3TmpIduyhOedlvectYxec+fHJkk+eh7Ds2bP35Z/vMrr81Lf/r+Y44Q+sVnBnZv6tD9cvWbH5jpQ1dl9Tc35ejf/OYu77v1v9xzp7ZNP7g+x/zmN3LQP9+a259+ZNehwvfU9OAYdZ+TQmWFzpz6lNsytT350DsO/17bti0r8uF3HpYHnbIp9zh26xijg/7xmYE9WLUi04euWtCjU0cOnqs7J+i3ONgH9CpZqaozquoLVbWxqm6oqvdX1UnjjouFud/Jd+XqK9Zk0x0r79Z+2UUHJklOePBd4wgLestnBpbWio3bs2LD9qz+5qYc9qarkyRbHnLQmKMC5qNvw8B+JMmbknwhg9hem+QjVfWg1tqdY42MeTvsyO255fqd/wZsR9vhR20fdUjQaz4zsLTu+WuXprYNJhpPrVuZW37lmGz+jxarYMRMsF+UXiUrrbUnzTyvqucmuSHJI5J8ahwxsXCr95/Otq21U/vWLYO2NfsrxcNMPjOwtG74rfumtrWsunpzDvr0bVmx2WcIlpteJSu7sH749ZZdXayqNUnWzGjy1yU9snXziqxavXNmv3rNoG3L5l6NQoSx85mBpbXl5LVJks0PW5e7fvDgHP2yyzO9/4rc8RNHjDky9ilteIy6zwnR2//zVdWKJG9M8i+tta/NcdsZSTbMOK4eTXTsjVtu2C+HHbXzEpE72m6+vu+5MoyWzwx0Z/vRa7Lt+ANy0KdvG3cowDz0NlnJYO7KyUl+YTf3vC6D6suO47gRxMVe+ubFB+S4E7bkwLVTd2t/4MM2JUmuuPiAcYQFveUzA92qrdNZsclQMFhOepmsVNU5SZ6S5AmttTmrJa21La2123ccSTaOLEj26NP/sD4r90ue/Kybv9e2avV0nvjzt+SSCw/MjdfYRRhm8pmBJTDVUndM7dS8+vJNWfXtzdl6oqSf0arWxnJMil6NKaiqSvJHSZ6e5PGttSvHHBKLcNm/HZRPfWB9nnfGtVl/xPZcc+WanP5zt+Soe23N2S+/17jDg97xmYE9W3veTVmxafp7O9EfcOHt3/vzxicN9ii65wsuzabHrs+2e61J239FVn1rcw765K2ZPnBlNvysDSFhOelVspLB0K9fTPLUJBur6uhh+4bWmg0GlqHXv/jeec53r8tpz7g169ZP5cpL9s+Zzz4+X7tg7bhDg17ymYHdO/iDN2W/G78/t+vAC27PgRfcniS584cPydSh++WO0w7N/hffmQM/tyG1tWXqsP2y6YcOyYZnHJmpI1UoGTFLFy9KtR59M1U1VzDPa629bS+ePzjJhsfnqdmvFrbDLQDsybff/ZBxhwDLxtSmzfnms1+XJOuHw/b3CTt+L33CI87IfvvtP9K+t2/fnE9cOBk/815VVlprO28wAAAAy1VLMup1HfpTi1i0Xk6wBwAAkKwAAAC91KthYAAAMEnGsZTwJC1drLICAAD0ksoKAAB0pWUMSxePtrsuqawAAAC9JFkBAAB6yTAwAADoih3sF0VlBQAA6CWVFQAA6Mp0khpDnxNCZQUAAOglyQoAANBLhoEBAEBH7GC/OCorAABAL6msAABAVyxdvCgqKwAAQC+prAAAQFdUVhZFZQUAAOglyQoAAOzDquqMqvpCVW2sqhuq6v1VddIennluVbVZx+aljs0wMAAA6MryGAb2I0nelOQLGeQHr03ykap6UGvtzt08d3uSmUnNkn+jkhUAANiHtdaeNPO8qp6b5IYkj0jyqd0/2q7rMDTJCgAAdGY6SY2hz4F1VXfrfEtrbctevGH98Oste7hvbVV9K4OpJV9K8luttYvnEekembMCAACT6eokG2YcZ+zpgapakeSNSf6ltfa13dx6WZJfSfLUJM/KIK/416o6bpEx343KCgAATKbjkmyccb43VZU3JTk5yam7u6m19tkkn91xXlX/muSSJL+W5LfnHekcJCsAANCRai014gn2M/rb2Fq7fa+fqzonyVOSPK61dvV8+mytbauqf0tyv/k8tyeGgQEAwD6sBs5J8vQkP9pau3IB71iZ5CFJrl3K2FRWAACgK8tj6eI3JfnFDOafbKyqo4ftG1prdyVJVb09yXdba2cMz89M8rkk30hySJJXJLlPkj9bbPgzSVYAAGDf9sLh10/Oan9ekrcN/3zvzFxnLDk0yVuSHJ3k1iQXJnlsa+3flzIwyQoAAHRluiU14srK9Pz6a63tcXHl1trjZ52/NMlL59XRApizAgAA9JJkBQAA6CXDwAAAoCvLY4J9b6msAAAAvaSyAgAAnRlDZSUqKwAAAJ2SrAAAAL1kGBgAAHTFBPtFUVkBAAB6SWUFAAC6Mt0y8gnv89zBvs9UVgAAgF5SWQEAgK606cEx6j4nhMoKAADQS5IVAACglwwDAwCArli6eFFUVgAAgF5SWQEAgK5YunhRVFYAAIBekqwAAAC9ZBgYAAB0xQT7RVFZAQAAekllBQAAutIyhsrKaLvrksoKAADQSyorAADQFXNWFkVlBQAA6CXJCgAA0EuGgQEAQFemp5NMj6HPyaCyAgAA9JLKCgAAdMUE+0VRWQEAAHpJsgIAAPSSYWAAANAVw8AWRWUFAADoJZUVAADoynRLMuJKx7TKCgAAQKdUVgAAoCOtTae10W7SOOr+uqSyAgAA9JJkBQAA6CXDwAAAoCutjX7Cu6WLAQAAuqWyAgAAXWljWLpYZQUAAKBbkhUAAKCXDAMDAICuTE8nNeJ9T+yzAgAA0C2VFQAA6IoJ9ouisgIAAPSSygoAAHSkTU+njXjOSjNnBQAAoFuSFQAAoJcMAwMAgK6YYL8oKisAAEAvqawAAEBXpltSKisLpbICAAD0kmQFAADoJcPAAACgK60lGfG+J4aBAQAAdEtlBQAAOtKmW9qIJ9g3lRUAAIBuSVYAAIBeMgwMAAC60qYz+gn2I+6vQyorAABAL0lWAACgI226jeVYiKp6UVVdVVWbq+qCqnrkHu5/ZlVdOrz/q1X15AV1vBuSFQAA2MdV1c8nOTvJq5M8PMmXk5xfVUfOcf9jk7wzyZ8neViS9yd5f1WdvJRxSVYAAKArbXo8x/y9LMlbWmtvba39e5IXJNmU5FfmuP/FST7cWvvfrbVLWmu/neRLSX59IZ3PRbICAAD7sKpaneQRST66o621Nj08f8wcjz1m5v1D5+/m/gWZyNXAtmdbMjl74QDQM1ObNo87BFg2pu/aMu4Qxmocv5duz7Ydf1xXVTMvbWmt7eofyBFJVia5flb79UkeOEc3R89x/9HzCnYPJi1ZWZckn8mHxh0HAJPs2X8/7ghgOVqX5PZxBzFCW5Nc95l8aEl/eZ+HO5JcPavt1UleNfpQFm7SkpVrkhyXZOO4A2En6zL4wPjnA3vHZwbmx2em39Zl8HvaPqO1trmqjk+yetyxzDBXmeumJFNJjprVflSS6+Z45rp53r8gE5WstNZaku+OOw52NqMEubG1ti/9rQosiM8MzI/PTO/tk/9MWmubk/R+3GhrbWtVXZjktAxW9UpVrRienzPHY58dXn/jjLbTh+1LZqKSFQAAYEHOTnJuVX0xyeeTvCTJQUnemiRV9fYk322tnTG8/w+S/HNVvTzJPyb5hSSnJHn+UgYlWQEAgH1ca+1vq+oeSc7KYJL8RUme1FrbMYn+3kmmZ9z/r1X1i0l+N8lrk1ye5Gmtta8tZVw1GDkF3aqqNUnOSPK6OVahAGbwmYH58ZmBySRZAQAAesmmkAAAQC9JVgAAgF6SrAAAAL0kWQEAAHpJskKnqmpNVf2vqrqmqu6qqguq6vRxxwV9VVVrq+rVVfXhqrqlqlpVPXfccUEfVdUPVtU5VXVxVd1ZVd+uqndV1QPGHRuwNCQrdO1tSV6W5K+SvDjJVJIPVdWp4wwKeuyIJGcm+Q9JvjzmWKDv/meSZyT5WAb/j3lzkscl+VJVnTzOwIClYeliOlNVj0xyQZJXtNbeMGzbP8nXktzQWnvsOOODPhruFXFoa+26qjolyReSPK+19rbxRgb9U1WPTfLF1trWGW33T/LVJO9prT1rbMEBS0JlhS79bAaVlDfvaGitbU7y50keU1X3Gldg0FettS2ttevGHQcsB621f52ZqAzbLk9ycQbVSWCZk6zQpYcl+Xpr7fZZ7Z8ffn3oaMMBYNJVVSU5KslN444FWDzJCl06Jsm1u2jf0XbsCGMBYN/wS0numeRvxx0IsHiSFbp0QJItu2jfPOM6ACyJqnpgkjcl+WySc8ccDrAEJCt06a4ka3bRvv+M6wCwaFV1dJJ/TLIhyc+21qbGHBKwBPYbdwBMtGszKMXPdszw6zUjjAWACVVV65Ocl+SQJD/cWvP/F5gQKit06aIkD6iqg2e1P2rGdQBYsOGS+B9M8oAkT2mt/fuYQwKWkGSFLr0nycokz9/RMNxD4nlJLmitfWdcgQGw/FXVygwm0j8myTNba58dc0jAEjMMjM601i6oqncneV1VHZnkG0mek+S+SX51nLFBn1XVr2cwnGXHink/VVXHDf/8R621DWMJDPrn/yT56QwqK4dV1d02gWytvWMsUQFLxg72dGpYnn9NkmclOTTJV5L8dmvt/LEGBj1WVVcluc8cl49vrV01umigv6rqk0l+ZK7rrbUaXTRAFyQrAABAL5mzAgAA9JJkBQAA6CXJCgAA0EuSFQAAoJckKwAAQC9JVgAAgF6SrAAAAL0kWQEAAHpJsgKwl6rqqqp624zzx1dVq6rHjy2oWWbHuJv7WlW9agHvf+7w2VMWEt8c73xVVdmhGICdSFaAZWHGL8k7js1V9fWqOqeqjhp3fPNRVU9eSKIAAPua/cYdAMA8nZnkyiT7Jzk1yQuTPLmqTm6tbRpxLJ9KckCSrfN87slJXpTkVUsdEABMEskKsNyc11r74vDPf1ZVNyd5WZKnJnnnrh6oqoNaa3cudSCttekkm5f6vQDAgGFgwHL38eHX45Okqt5WVXdU1YlV9aGq2pjkr4bXVlTVS6rq4uEwsuur6k+r6tCZL6yBV1bV1VW1qao+UVUPnt3xXHNWqupRw75vrao7q+orVfXiHfFlUFXZMW+kzZyvsdQx7q2quk9V/b+quqyq7qqqm6vq3VV13zkeOXAY181VdXtVvX12jMP3/kRVfXr4c9hYVf+4mDgB2LeorADL3YnDrzfPaNsvyflJPpPkvyfZMTzsT5M8N8lbk/xhBgnOryd5WFX9UGtt2/C+s5K8MsmHhsfDk3wkyeo9BVNVpyf5hyTXJvmDJNcl+Q9JnjI8/9MkxyY5Pckv7+IVncc4hx9M8tgkf5Pk6iT3zWCI3Ser6kG7GGJ3TpLbMhjKdtLw3vtU1eNba234s/jlJOdm8M/ifyY5cHjfZ6rqYa21qxYYKwD7CMkKsNysr6ojMpiz8kMZzGG5K4MEYYc1Sd7dWjtjR0NVnZrkPyf5pdbaX89o/0SSDyd5ZpK/rqp7JPkfSf4xyU/N+MX795L81u4Cq6qVGSQb1yZ5aGvtthnXKklaa5+tqq8nOb219o5Zz3ce4278Y2vtPbPi+WCSzyZ5RpK/nHX/1iSn7UiequpbSV6f5KeSfKCq1maQbP1Za+35M955bpLLhnE+PwCwG4aBAcvNR5PcmOQ7GVQB7kjy9Nbad2fd98ezzp+ZZEOSf6qqI3YcSS4cvuMJw/t+LIPqxB/tSAKG3rgXsT0sg0rIG2cmKkky611zGUWMu9Rau2vHn6tqVVUdnuQbGVRPHr6LR948o8qTDH7e2zNYPCAZVI4OSfLOWd/LVJILZnwvADAnlRVguXlRkq9n8Ivx9UkuG050n2l7BkOZZrp/kvVJbpjjvUcOv95n+PXymRdbazdW1a17iG3HkLSv7eG+uYwixl2qqgOSnJHkeUnumaRmXF6/i0dm931HVV2bwfCxZPC9JN+fUzTb7QuJE4B9i2QFWG4+P2M1sLls2UUCsyKDJOCX5njmxkVHtnjjjPGPMkhU3pjB0K8NSVoG1auFVOF3PPPLGczbmW37At4JwD5GsgLsK76ZwfCpf5k55GkXvjX8ev8kV+xoHM4T2Wm1q130kSQnZzBcbS5zDQkbRYxz+dkk57bWXj7jfftnMJRrV+6f5BMz7l2b5JgMJvsn3/9Z3NBa293PAgDmZM4KsK94V5KVSX579oWq2q+qDhmefjTJtiS/sWNS/NBL9qKPL2WwYeVLZrxvRx8z33XnsO1u94woxrlM5e5Dv5LkN4bx7Mrzq2rVjPMXZvAXYOcNz8/PYKjXb826L8n3EisA2C2VFWCf0Fr756r60yRnVNVDM1jmd1sGFYJnJnlxkvcM5328IYP5G/9QVR/KYOL8TyS5aQ99TFfVC5N8MMlFVfXWDFYGe2CSByf58eGtFw6//mFVnZ9kqrX2N6OIcTf+IckvV9WGJP+e5DEZVHlunuP+1Uk+VlXvymDp4v+awVLRHxj+LG4f/iz+MsmXqupvMhjGdu8kP5nkXzJYkhkA5iRZAfYZrbUXVNWFSX4tyWszmDdxVZJ3ZPDL8w6vzGBn+hdksGrVBUmemMFSwXvq4/yqekKS30ny8gwq2N9M8pYZt703gzkiv5DkWRlUNP5mVDHO4cUZVFd+KYNlof8lg2Tl/Dnu//XhvWclWZXknUn+28zVyVprf11V1yT5zSSvyGBJ6e8m+XQG+8gAwG7V3q2mCQAAMFrmrAAAAL0kWQEAAHpJsgIAAPSSZAUAAOglyQoAANBLkhUAAKCXJCsAAEAvSVYAAIBekqwAAAC9JFkBAAB6SbICAAD0kmQFAADoJckKAADQS/8/OA47EBRXanAAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -410,7 +410,7 @@ { "data": { "text/plain": [ - "0.943730275125624" + "0.9633110554163186" ] }, "execution_count": 13, @@ -524,7 +524,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -571,8 +571,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Average influence of corrupted points: -1.0535696\n", - "Average influence of other points: 0.1073237\n" + "Average influence of corrupted points: -1.076019\n", + "Average influence of other points: 0.10683939\n" ] } ], @@ -638,7 +638,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -742,7 +742,7 @@ }, "outputs": [], "source": [ - "from pydvl.influence.torch.pre_conditioner import NystroemPreConditioner\n", + "from pydvl.influence.torch.preconditioner import NystroemPreconditioner\n", "\n", "nn_model.to(\"cpu\")\n", "cg_influence_model = CgInfluence(\n", @@ -751,7 +751,7 @@ " regularization=0.1,\n", " progress=True,\n", " use_block_cg=True,\n", - " preconditioner=NystroemPreConditioner(rank=5),\n", + " preconditioner=NystroemPreconditioner(rank=5),\n", ")\n", "cg_influence_model = cg_influence_model.fit(training_data_loader)\n", "cg_train_influences = cg_influence_model.influences(\n", @@ -792,7 +792,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of Cg over direct method:441.115665435791 %\n" + "Percentage error of Cg over direct method:30.799928307533264 %\n" ] } ], @@ -818,7 +818,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -862,8 +862,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation Cg vs direct 0.9976865200148308\n", - "Spearman Correlation Cg vs direct 0.9938836687910925\n" + "Pearson Correlation Cg vs direct 0.9975120139679169\n", + "Spearman Correlation Cg vs direct 0.9968058039650353\n" ] } ], @@ -918,9 +918,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "Lissa iteration: 100%|██████████| 1000/1000 [00:02<00:00, 422.55it/s]\n", + "Lissa iteration: 100%|██████████| 1000/1000 [00:02<00:00, 414.49it/s]\n", "Reached max number of iterations 1000 without achieving the desired tolerance 0.0001.\n", - " Achieved max residual 8248.55 % and 9.40670 % mean residual\n" + " Achieved max residual 125303.41 % and 17.06509 % mean residual\n" ] } ], @@ -956,7 +956,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of Lissa over direct method:639.6753311157227 %\n" + "Percentage error of Lissa over direct method:43.32989752292633 %\n" ] } ], @@ -982,7 +982,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABS4AAALGCAYAAABLZg+zAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAByOElEQVR4nOzdeZhkV1k/8O87M9mXCSEkGSYJE/btJ1tkk0AQUSCyCAEUEYLKoiiJKBJADItiRBEiuCACAdkJkYAJIFsgrJF93xnIZF8ngewz5/fHvR0qle6Z6ppeqqc/n+epp+bee+69b1VXVU99+5x7qrUWAAAAAIBJsmKxCwAAAAAAGCa4BAAAAAAmjuASAAAAAJg4gksAAAAAYOIILgEAAACAiSO4BAAAAAAmjuASAAAAAJg4gksAAAAAYOIILgEAAACAiSO4BIARVNWeVfXPVbW+qq6rqlZVd62qw/p/v2ixa9zeVNWvV9VnqurS/jl+72LXNKyqTquqNgfHeVH/GA/b9qqWjqpa1z/uExa7lkmwXF8Hc6mqTuifw3UD67zOFsgk/E7sz3/aYp0fgLkluARgu9V/ednmUKn38iR/muTrSf4uyYuTnDtHx2ZIHzqcnOTgJG9I93y/Yyv7HNn/zI+c9wKZOP0fFdYvdh3DBsLIFy12LUyOpfp5JQQGYKGtWuwCAGCJ+M0k32utPXxwZVXdfpHq2d79WpKdk/x5a+1ti13MFjwpya5zcJzXpAtmfzoHx1pKzkpyhyQbF7uQCbFcXwfzzesMAJYowSUAjObmST652EUsIzfv789e1Cq2orU2JwFTa+3CJBfOxbGWktbatUm+s9h1TIrl+jqYb15nALB0GSoOwLIyOMyt//c7qurCqrqqqr5QVb851H7qGoaV5AFTw8+3dv2sLQ1b3dJ17Krq9n1tZ1bVNVV1XlW9rapuN03b66/lVlVPr6qv94/jvKr6j6paPcP5D+iv1/n9qrqyqi6uqjOq6oUztH1NVf2oqq6uqouq6n1V9ctbevwznPdxVfXJqtrYn/frVfW8qtppoM1h/fP94n7Vxwee8xs9XwP7nZbkjf3iGwf2uf5ad4PPe1U9oao+X1U/G/w59cM339M/3iur6rKq+nRVPXGm8w5fjmDwGm/VXQf1lOqu03lFVX2iqu47zXGmfU1Mvdaqap/+Z3pO/3P4ZlU9ZYaaduqPN/Uz+3FV/U2/fuRrvw29V25fVe/tXys/r6pPVdWvb+H8x/Q/3yv65/D0qnrcls4xtH7k1/bAa+YWSW4x9LM/YaDdoVX1/qra0D8v51bV56rq2FGej4WwhdfBSLVX1X5V9Y9V9d3+53Rp/+8TquqWA+12rKo/qapTq+on/TEvrqqPVNVDZ1Hvv/f1PnKG7ffqt5842xpHOPev9a+rn/e1v7dm6AE/wuvsllX1p1X1tere96cNtNm7qv6uqr7db9tYVR+d6fXf7/P4vs3F/et2fVW9vaoO6beflq18Xm3h2IPvy1tV1YnVfS5fXlX/W1V37tvdrH7xmXFVVf1fVT1whmOuqqo/7l9Tl/Xv2y/3r5EVA+1elOTH/eKTh+o+cprjjvT517dd3T/P3+3rvaSqPlRVvzZD+x2r6oVV9cMa+pzb0vMHwNKjxyUAy9UtkpyR5EdJ/ivJ3kken+Tkqvq11trH+3YnJDktybFJftIvJ8n6uS6oqh6S5KQkOyR5f5IfJDkgyaOTHF5VD2ytfWmaXV+e5Df6ff43yQOTPDXJrZP86tA5DknyoXSP95P9+XZNcsckL0ry0oG2d++Pt3e/z0lJ9knyqCSfqqrfaq2dOuJje1mS56XrTfa2JD9L8tAkL0vyG1X16621a9I9ry9OcliSByR5U37xXK/PzE5IcmmSR6a7NuZXBrZdOtT2z5M8ON3z9fEkgwHvvyX5Zrrn5pwkN03ysCT/VVW3a63dKNzdgkOS/GWSzyb5zyQHJXlMko9W1V1ba98d8Th7Jfl0kmuSnJhkpySPTfKGqtrcWnvTVMOqqiTvSXJ4ku+nG3q8Q5Ijk9xpFrUPOrh/DF9P8toka9K9Vz5QVU9orb1z4Pw7pnutPCBdD7d/Sff6OiLJO/vH/fxZnHuU1/b6dK+Zo/vlVw3s/5W+rockOSXJZUnel27o8N7phg//cX4RlE+cUWuvql3TvU5uleTD6Z6zSvdZ98h0r50f9YfdO8nxST7Tt70g3c/14UlOraqnttb+c4Ty3pTk6ekumXDyNNuf3N+fMEaNM6qqI5K8M9174p3p3qv3S/c6/doIdQ87Psmh6Z7nU5Ns6s9zi3Sf/+uSnJ7kg0l2S3fpkA9W1dNba68bqKvSBZJPTvdZd1K65/aAdK/d7yb5Qmb3eTWTdUk+n+Tb/fHWJfmtJKdV1X36Wi9L9/zsneS3071nbzvYU7yqpn7f/EZf39uSXNXX++ok90rye33z09J9Hh2V5KtJ3jtQz+BjSGbx+VdVe6V7Xdwxyf+lew/vk+RxSf63qv6otfbagfaV5F3pnr8fpvuc2zHJ7yf5f1t53gBYalprbm5ubm5u2+UtSet+1d1g3bqp9UmOHdr2G/36U2c41mnTrD+s3/aiofXrk6yfoa4X9fscNrDuJkkuSfdl945D7e+cLuj70tD6E/rj/DTJQQPrV6UL3lqSew6s3zFdb5mW5AnT1HXA0DF+kO4L7AOG2t08XXhyTpKdRvg53Gegzv2HzvH+ftvzt/YcjXCeI/t9jtzK8/7zJHeboc2tplm3Y5KPJrk2ydqhbadN8xqbek3cqJZ0IU9L8q+jPN6B4/xnkpUD6++Y5Lok3xpq/3t9+08m2XFg/V7pgsRpX8czPBfrBs7/D0PbDumfj0uS7Dmw/nl9+1OTrBpYv2+690RLct9pznHCtry2R3jPvaff5y7TbNtn1NfYOLeBn+2LZtF28LNhpNrThY4tyStneA3vMbC8Uwbe7wPrVyf5RpKLk+wy4uP7bpKrk+w9tH6n/jjnTb0WZlPjFs63e5KL+tffIUPbXjnwml03i9fZWUkOnuZcpyXZnOS3h9bvlS6ouzLJfgPrn9Yf74wkq4f2WZlkzcDykdnC59UWHv/UY2lJXjC07YX9+ouT/HuSFQPbpj4bXjm0z9Rr7tW54WfMyiSv77c9cmvP5cD2wwbqO3Jo20yff6/t1782SQ2sv02665JePfTzfELf/rNJdh5Yv3e6IHPkzzk3Nzc3t8m/GSoOwHL1kyR/M7iitfahdEHJPRehniel+zJ8bGvtW0N1fSPJ65LcraruOM2+L2kDPWhaa9flF8MQBx/Lw9N96Xxfm2bCm9bahoHFw9P1inp1a+0TQ+3OTtcTbv8kDxrhsf1+f/83rbXrZ2Lv6/zzdMHAH45wnLnyH621L0+3obX2w2nWXZOu5+CqjPZ4p3y6tXbC0Lo3pAscZ/MauyLJs1trmwZq+la6Hkp3qKrdB9o+ub//q77uqfaXZqA37SxtTPKSwRWttS8keWu61+xvDWz6/XShwbP7n+9U+/MHzj+bn/Wor+1RXTm8onXXlVwKRq19unbXtNYuH1i+euj9PrV+Y7rX6E2SjHo5iDelCx1/Z2j9w/vjvHXwtTBqjVvwyHQB1dv61+GgF2W8CXhe3lr78eCKqrpLup7D72mtvWOo1kvT9cLfOV0vwil/2t8/vX8uB/fZ1Fo7Z4zaZrI+yXFD66Z6X++U5Dmttc0D296W7rPnrlMr+mHgf5rk3CR/NvQZsynd53NL8rtj1DfS51/fS/uJ6f4497zWWhuo4ftJ/jnd6+tJA8eZukzG81trVw20vzjjf84BMKEMFQdgufrK4Je0AWem6yG40KbOeZf+OmLDbtvf3yHJt4a2DX95T7rHkXTBwZR79/cfmEU9t5ihntsM1LO14eJ37+8/Nryhtfa9qtqQ5OCqWj38ZX+enDHThqo6KMlz0wWUByXZZajJ2lmc50Y/l9batVV1Xm74c9ma77fWLptm/eDP+Gf9v++WLgj+zDTtPzWLcw760gyB0mnpgtK7JXlTVe2Rbgj3Wa216SZCmfr5320W5x71tb01b013yYXPV9U7010i4NPThXfT6YeyHj3Nplf1IdZ8GrX2T6TrOXhMf5mHU9OF29N+1lXVnZI8J8n90w0T33moyaiv9TenC4uenC7gnzIVop8wbo0zmPo8+cTwhtbaxqr6SrrAcTam+0yY+gxcPcNn4M36+zskSVXtlq53/Hkz/WFkjk33nE1NZva94fdsa21T/9lzwMDq26YLgb+f5K+6Edg3cmX6xzhLo37+3S7d5SQ+3QePwz6W5K9yw8+Nu6f7nJvuM+20MWoFYIIJLgFYri6dYf11WZzJ627a3z91K+12n2bdpdOsm+rhtHJg3V79/VmzqOexY9QzbHV/P1Nvo3PShYR7ZbzeUrN17nQrq5sY5Ix0X6pPT3dNxY3prne3Ll0QM5uJHy6dYf11ueHPZVuOk6FjrU5y8TQ93JJuyO44Ztpv6nlcPXS/pZ9z8ovX4SgunWbddI97i1prJ1U38dafp+sV+vQkqaovpuvl9eGtHGKvdD3shp0wQ41zZtTaW2uXVdW9013z8hHpLn2RJBdW1b+m6/F8bb/vvdMFQqvSXQbhfemuh7g5XY+8R2bE13prbUNVfTTJg6vqDq21b1fVvkkeki5c+9pA25Fr3IKp19nWXpezMd0+U5+BD+5vM5n6DNyrvx/l83Uu3OizsrV2XR8+zvQ5el26a95OmXqMt8n0r+8po3zOD7t0CzUMf2Yls/vcmPqcm+61Ms7PH4AJJrgEgPmxOd3wtunsNc26qS+adxn8oj/HLu3vR+lJNVXPI1tr79vG804da/901x8btmao3XxrM6x/drov8k8ZHuJYVb+TX/Qgm2SXJdm7qlZNE17uN+YxZ9pv//5+49D9/tO0TRb+53wDrbVTkpzS94y7V7oJVv4oyf9U1d2GL9EwtO/6dJPILIpRa+97Yf5BP3nJHdNNYPTMJH+d7g8yU5NL/VW63sQPbK2dNniuqnpeuuByNt6ULtx7cpJj0g0tXpVfDF0efCyj1jiTqdfP1l6XszHdZ8LUeY5qrf3zCMe4tL+fTa/sxTb1GP+7tfboRa5hNp8bG9N9zu0wTXg5zs8fgAnmGpcAMD8uSbJfP2PrsEOmWfe5/v7Q+Svp+nM8dBZt56KeqWGThw1vqKpbpxu6+OM5GHI7NWxyNr0ZB926v3/PNNtmO/R0sXw53f/v7jvNtvuNecy798PAhx02cM70Q1N/mGRtVd1mmvYP7O+/NGYdW7MpI/zsW2s/b619rLX27HSz2u+Y0d4Ti27U2lvnm621V+cXvQUfNdDk1ul6rJ02zWnGea2flC40f2J/3cQnp+tZd6Nr6c6ixplMvX5uVGdVrc7ANRy30aw+A1trP083sdF+VTXK5RC29fNqLnwnXeB67xl+V01nruv+brrr+N6lvyTDsOk+N76U7nNuus+0w+aoLgAmhOASAObHGel6HD1lcGVVHZnkV6Zp/8Z0XyCPraobTTpSVSuq6rBtrOn96SZ0eETfg3D4HIPXPjs5XQj1zKp62HQHq6r7VNWuI5z3Df39X1XV1HXhUlUrk/xjuv+PvH6kR7BlF/X3B425//r+/rDBlVX1G1nYyYO2xZv7+7/pJ71Icn2gs7WebDNZna433PWq6pB0veo2JvnvgU1vSNcz8R/6n+9U+30Gzv+GzI+LktysqoavS5qqun9VTTfSaKrX3hXzVNM2G7X2qrpTVU3XC3G6x7g+XY+1Xxo61x/kF8O3R9ZauzLJu9L1NvyzJHdJcmo/KdPg8WdT40xOTveHoSf0r8NBL8ovhh5vk37in9OTPLqqfn+6NlX1//ph8VOmema+tn/PDbZdUVVrBlZt6+fVNut7Zb86Xa/Gf57hvbNmaFK4S9L1UJ2TuvtJxN6aZI8MTaxTVbdK8qx0M8j/18CmqQm6/raqdh5ov3e63sQAbEcMFQeA+fHqdKHlv1XVg9JNKHLXdBM+/E+6oZ7Xa61dVFVHpAuBPtdfM+6b6b4gHtjvd9PceAKNkbXWrqmqx6a7duPbqurp6XoV7Zxu8oUHpf+/QT+JwqOTfCjdENXPJPlKumDhwHQzDt8y3RfeLYYNrbXPVNXLk/xlkm9U1YlJfp6up9id002w8A/jPq4Bn+1rObqqbppfXOvs1SNO+vOv6X5m7+5rPLuv7yHpQpnHz0GN8+3NSX47Xc3fqKr3pbum3WOS/F+6iTA2z7z7tD6Z5A+r6l7pJlJZk+65WJFu9uTBiYP+Md3P9ZFJvlpVp6abeOOxSfZNN3vzuJMEbc1H070uP1hVn0xydZKvttbeny5QWltVn04X2l2T5B7phin/JMk7pj3i3HpUVa2bYdv/ttZm6p04au0PThcYfzbJ95Kcn6438yPT/cwH32OvShdQfqqq3pUugD4kXQ+2E5McMfuHlzelC/j/bmB52GxqnFZr7WdV9bQk70xyej9h0Tl97XdO93q9/xj1T+cJ6a4F+vqqelaSz6f7A9MBSX6pP999+seRJP+Zrofm7yX5flWdnOSCJDdP9/N6Q7pwNdn2z6u58tJ0QfMzkjy8qj6W7jqd+6a79uWvJHlB+knh+uf/80kOraq3pvs5bkryvm24zMkx6Z63P6mqX043AdU+SR6XLtD8k6FZ39+e7jPoEek+505O9zl3RLrPuVuNWQcAE0hwCQDzoLX2rar6tXTDOR+ebtjk6em+5D46Q8Flv89H+x5Qf5EuVDg0XUhxdrovz9MNYZ5tXV+oqrum+6L40HRDii9P8oMM9aprrX2tqu6S7tqPv5ku1NucLiT4crrJHC4c8bzPraovJ/mTJE9K9yXzh+l6x7yi73WzrY/tkqp6TF/XkUl26ze9JSNcV7F/vA9M8jdJDk/3/6Svpvt5XZolEFy21lpV/VaS56cLT/403c/rTemC2UelG9I7Gz9OF2oc19/vlG6o5ktaax8aOv81VfXgdK+ZJ/Tnvy7d83h0a+3t4z2ykfxNuuvHPjxd2LIy3eN+f7r34W+lC+d+Ld3r+Kf9+le11i6Zx7qm3KW/TefSzDysetTaP5SuF9z90wWBe6b72X84yT+11q6fab619sGqeni699/j0wVPZ6QblnvLjBFcttY+VVU/SD8MPd0faIaNXONWznViVT0k3Xv9celC6k+m+3w9JnMUXPYTD90j3ev4Mel6Ga9MFzJ+K90fqL4+0L4leVJVfSjJ0/raduof4+npJkGaartNn1dzpf8j1aOSPLGv4zfTTcZzQbr3/gvT9Ygc9HtJXpnuDyS/k66X9YYkYwWXrbWLq+o+SZ6X7vP22elmMz8jyT+01v53qH3r/wh3TF/zn6R7jt+Y5CVJrhqnDgAmU3W/XwEA2J71geL/Jjmutfa8EdqvSxdcvKm1duT8VgcAADfmGpcAANuRqrr5NOtumq7HZHLDa1ICAMDEMlQcAGD78k/9EP/PpBvueUC6ywLsneS1rbUzFrM4AAAYleASAGD7clK6WZofnu6aj1elm+jp9Zmb2dsBAGBBuMYlAAAAADBxXOMSAAAAAJg4gksAAAAAYOK4xuUsVVUluXmSyxe7FgAAAABYovZIcnbbwnUsBZezd/MkGxa7CAAAAABY4g5IctZMGwWXszfV0/KA6HUJAAAAALO1R7qOgVvM1gSX47u8tXbZYhcBAAAAAEtJdyXGrVvSk/NU1f2r6v1VdXZVtap61Aj7HFZVX6qqq6vqB1V15PxXCgAAAADMxpIOLpPsluSrSZ45SuOqOjjJKUk+nuSuSV6V5D+r6jfmqT4AAAAAYAxLeqh4a+0DST6QjNzF9BlJftxa+/N++dtVdb8kf5bkQ/NSJAAAAAAwa0u9x+Vs3SfJR4bWfahfP62q2qmq9py6pbt4KAAAAAAwj5ZbcLl/kvOG1p2XZM+q2mWGfZ6XZOPAbcP8lQcAAAAAJMsvuBzH3yVZPXA7YHHLAQAAAIDt35K+xuUYzk2y39C6/ZJc1lq7crodWmtXJ7l6annU6doBAAAAgPEttx6Xn03yoKF1D+7XAwAAAAATYkkHl1W1e1Xdtaru2q86uF8+qN/+d1X15oFd/j3JLavq5VV1+6r64ySPS/LKha0cAAAAANiSJR1cJjkkyZf7W5L8U//vl/TLa5IcNNW4tfbjJIen62X51SR/nuQPW2sfWqiCAQAAAICtq9baYtewpFTVnulmF1/dWrtssesBAAAAgKVk1Hxtqfe4BAAAAAC2Q4JLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOKsWuwAAAAAAoLPumFNWJjk0yZok5yQ5ff1xh29a3KoWhx6XAAAAADAB1h1zyqOTrE/y8SRv6+/X9+uXHcElAAAAACyyPpw8McnaoU1rk5y4HMNLwSUAAAAALKJ+ePjx/WINbZ5aflXfbtkQXAIAAADA4jo0yQG5cWg5pZIc2LdbNgSXAAAAALC41sxxu+2C4BIAAAAAFtc5c9xuuyC4BAAAAIDFdXqSDUnaDNtbkjP7dsuG4BIAAAAAFtH64w7flOSofnE4vJxaPrpvt2wILgEAAABgka0/7vCTkhyR5KyhTRuSHNFvX1aqtZl6oDKdqtozycYkq1trly12PQAAAABsP9Ydc8rKdLOHr0l3TcvTt7eelqPma4LLWRJcAgAAAMD4Rs3XDBUHAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJs2qxCwAAAACASbPumFNWJjk0yZok5yQ5ff1xh29a3KqWFz0uAQAAAGDAumNOeXSS9Uk+nuRt/f36fj0LRHAJAAAAAL0+nDwxydqhTWuTnCi8XDiCSwAAAADI9cPDj+8Xa2jz1PKr+nbMM8ElAAAAAHQOTXJAbhxaTqkkB/btmGeCSwAAAADorJnjdmwDwSUAAAAAdM6Z43ZsA8ElAAAAAHROT7IhSZthe0tyZt+OeSa4BAAAAIAk6487fFOSo/rF4fByavnovh3zTHAJAAAAAL31xx1+UpIjkpw1tGlDkiP67SyAam2mnq9Mp6r2TLIxyerW2mWLXQ8AAAAAc2/dMaesTDd7+Jp017Q8XU/LuTFqvia4nCXBJQAAAACMb9R8zVBxAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDirFrsAgAAAACYPOuOOWVlkkOTrElyTpLT1x93+KbFrYrlRI9LAAAAAG5g3TGnPDrJ+iQfT/K2/n59vx4WhOASAAAAgOv14eSJSdYObVqb5EThJQtFcAkAAABAkuuHhx/fL9bQ5qnlV/XtYF4JLgEAAACYcmiSA3Lj0HJKJTmwbwfzSnAJAAAAwJQ1c9wOxia4BAAAAGDKOXPcDsYmuAQAAABgyulJNiRpM2xvSc7s28G8ElwCAAAAkCRZf9zhm5Ic1S8Oh5dTy0f37WBeCS4BAAAAuN764w4/KckRSc4a2rQhyRH9dph31dpMPX+ZTlXtmWRjktWttcsWux4AAACA+bDumFNWpps9fE26a1qerqclc2HUfE1wOUuCSwAAAAAY36j5mqHiAAAAAMDEEVwCAAAAABNHcAkAAAAATBzBJQAAAAAwcQSXAAAAAMDEEVwCAAAAABNHcAkAAAAATBzBJQAAAAAwcQSXAAAAAMDEEVwCAAAAABNHcAkAAAAATBzBJQAAAAAwcQSXAAAAAMDEEVwCAAAAABNHcAkAAAAATBzBJQAAAAAwcQSXAAAAAMDEEVwCAAAAABNHcAkAAAAATBzBJQAAAAAwcQSXAAAAAMDEEVwCAAAAABNHcAkAAAAATBzBJQAAAAAwcQSXAAAAAMDEEVwCAAAAABNHcAkAAAAATBzBJQAAAAAwcQSXAAAAAMDEEVwCAAAAABNHcAkAAAAATBzBJQAAAAAwcQSXAAAAAMDEEVwCAAAAABNHcAkAAAAATBzBJQAAAAAwcQSXAAAAAMDEEVwCAAAAABNHcAkAAAAATBzBJQAAAAAwcQSXAAAAAMDEEVwCAAAAABNHcAkAAAAATBzBJQAAAAAwcQSXAAAAAMDEWfLBZVU9s6rWV9VVVfX5qrrnFtoeWVVt6HbVQtYLAAAAAGzdkg4uq+rxSf4pyYuT3D3JV5N8qKr23cJulyVZM3C7xXzXCQAAAADMzpIOLpM8O8nrWmtvbK19K8kzklyR5Pe3sE9rrZ07cDtvQSoFAAAAAEa2ZIPLqtoxyT2SfGRqXWttc798ny3suntV/aSqzqyqk6vqTls5z05VtefULckec1E/AAAAADCzJRtcJtknycokwz0mz0uy/wz7fDddb8xHJnliusf/mao6YAvneV6SjQO3DdtQMwAAAAAwgqUcXM5aa+2zrbU3t9a+0lr7RJJHJ7kgydO3sNvfJVk9cNtSyAkAAAAAzIFVi13ANrgwyaYk+w2t3y/JuaMcoLV2bVV9Ocmtt9Dm6iRXTy1X1ewrBQAAAABmZcn2uGytXZPki0keNLWuqlb0y58d5RhVtTLJ/0tyznzUCAAAAACMZyn3uEySf0rypqr6QpIzkhydZLckb0ySqnpzkrNaa8/rl/86yeeS/CDJXkmek+QWSf5zoQsHAAAAAGa2pIPL1to7q+pmSV6SbkKeryR5SGttasKeg5JsHtjlJkle17e9JF2Pzfu21r61YEUDAAAAAFtVrbXFrmFJqao9080uvrq1dtli1wMAAABLybpjTlmZ5NAka9Jduu309ccdvmlxqwIW0qj52pK9xiUAAACwtKw75pRHJ1mf5ONJ3tbfr+/XA9yA4BIAAACYd304eWKStUOb1iY5UXgJDBNcAgAAAPOqHx5+fL9YQ5unll/VtwNIssQn5wEAAAAW3hjXqTw0yQFb2F5JDuzbnTZHZQJLnB6XAAAAwMjGvE7lmhEPP2o7YBkQXAIAAAAj2YbrVJ4z4ilGbQcsA4JLAAAAYKu28TqVpyfZkKTNcPiW5My+HUASwSUAAAAwmqnrVA6HllMGr1N5A/31L4/qF4fDy6nlo7dynUxgmRFcAgAAAKPYputUrj/u8JOSHJHkrKFNG5Ic0W8HuJ7gEgAAABjFNl+nsg8n1yV5YJIn9PcHCy2B6axa7AIAAACAJWHqOpVrM/1w8dZv3+J1Kvvh4KfNdXHA9kePSwAAAGCrXKcSWGiCSwAAAGAkrlMJLKRqbfiPJGxJVe2ZZGOS1a21yxa7HgAAAFho6445ZWW62cPXpLum5el6WgKjGjVfE1zOkuASAAAAAMY3ar5mqDgAAAAAMHEElwAAAADAxBFcAgAAAAATZ9ViFwAAAAB0JnXSm0mtC9i+6XEJAAAAE2DdMac8Osn6JB9P8rb+fn2/Xl3AsmNW8VkyqzgAAABzrQ8BT+wXa2DT1Jf2I9Yfd/hJ83TuGXtTLmZdwPZr1HxNcDlLgksAAADmUh8crk+yNjcMB6e0JBuSHDzXw7P7YPL4JAcMrN6Q5KgkJy9WXcD2bdR8zVBxAAAAWFyHpgsOpwsH068/sG83ZwZ6U64d2rS2X//8xagLYIrgEgAAABbXmjlut1V9L8/j+8XhYHJq+agRDzdndQEMMqs4AAAALK5z5rjdKKZ6ec6kktx0xGPNZV0A19PjEgAAABbX6emuFTnTJBQtyZl9u7kyai/Ji7OwdQFcT3AJAAAAi6if2GZqWPZwSDi1fPQcT4Azai/JVw3VkaHlua4L4HqCSwAAAFhk6487/KQkRyQ5a2jThiRH9Nvn0qi9PF+2wHUBXK9am+kziumMOl07AAAAzFY/ac6h6YZyn5Pk9C31aJxt+6F9p2YVT244Qc9UUHB9MLkt5wEYNmq+JricJcElAAAAk6APHo/PDSfZ2ZDkqFF7Qs5wjDPTDQHXmxKYF4LLeSK4BAAAYLHNprfkCMfSmxJYUILLeSK4BAAAYDoLFQD251mfZG1uGFpOael6Xh4sgAQm0aj5msl5AAAAYBv1PSDXJ/l4krf19+v79XPt+emGdk8XWqZff2C6EBVgyRJcAgAAwDYYGLa9dmjT2iQnzmV42R/rJSM2XzNX5wVYDIJLAAAAGFM/bPv4fnG4B+TU8qv6dnN5rlGcs63nBFhMgksAAAAY36FZuGHbU+fampZuZvDT5+CcAItGcAkAAADjG3U49lwM257NMY42MQ+w1K1a7AIAAABgCRt1OPa07WY5E/mo5zp2/XGHnzRiW4CJpcclAAAAjO/0JBvSDc+ezozDtseYiXzUc71sxNoBJprgEgAAAMbU9448ql8cDhSnlm80bHucmcjHPRfAUiW4BAAAgG3QD8s+IslZQ5s2JDlieNj2tsxEPttzASxlgksAAADYRn1guC7JA5M8ob8/eIYgcZtmIp/luQCWLJPzAAAAwBzoh2ifNkLTbZ6JfBbnAliy9LgEAACAhbVNM5EDLBeCSwAAAFhYY89EDrCcVGszfU4ynaraM8nGJKtba5ctdj0AAADMXj/xzaHphmOfk+T0hZyNe2BW8eSG17qc+pJuoh1guzVqvqbHJQAAAMtKHxquT/LxJG/r79f36xeE2cEBtk6Py1nS4xIAAGDp2kpPx0ryyiTvywL1wFzsnp8Ai2HUfE1wOUuCSwAAgKWpDwnXJ1mbG4aW09mQ5Cg9HwHmnqHiAAAAcEOHJjkgWw8tky7cPHEhh48DcEOCSwAAAJaLNbNoOxVuvqrvqQnAAhNcAgAAsFycM8v2leTAdD01AVhggksAAACWi9PTXbtytpM9zKanJgBzRHAJAADAstDP1n1Uvzib8HK2PTUBmAOCSwAAAJaF/lqVlyY5McnlI+zSkpyZrqcmAAts1WIXAAAAANuqDyUPTTes+5wkp/c9LKe2PzrJfyS56dCuVybZJV1IOTjb+FSPzKMHjwPAwqnWZntpj+WtqvZMsjHJ6tbaZYtdDwAAwHLXh5LHJzlgYPWGdEHlD5LcOslLtnCIluTi3DDUPDNdaHnS3FYLwKj5mh6XAAAALBnT9KzcJ8m7pml6QLYcVg6qJFckeVyS/TJNj00AFp7gEgAAgCVhhp6Vm3LDId7jOjDJ5vXHHf72OTgWAHNAcAkAAMDE60PLE6fZtHIOT7NmDo8FwDYSXAIAALDotjS5Tr/t+L7pXPSunMk583hsAGZJcAkAAMCimmEI+AXrjjnlLUnel2TF0Lb5cGaS0+f5HADMglnFZ8ms4gAAAHNnaAj4TL0pL06y9zyW0ZIcYQZxgIVhVnEAAAAm2iyGgN9kHsu4MMnTZwottzSEHYD5JbgEAABgsRya0YaAz+V1Ld+YZEP/79OSfGKmIHKGIewb1h1zylF6ZwLMP8ElAAAAi2WhZ/G+MMlTR+kxuYVZzNcmOXHdMacYWg4wz1YsdgEAAAAsW/M1i/fwZA6tvz19xNByS0PYp5Zf1bcDYJ7ocQkAAMCM5usaj/1xV6SbeOcmGX04eJuhbUs3BPzZSV6ZoeHdSY6eRQ/JrQ1hryQH9u1OG/GYAMySHpcAAABMqx8uvT7Jx5O8rb9f36+fi+N+NN1s4aOEli3dUO+pfw9vS7pw8sQk65I8MMkT+vuDZzmse9Qh7As91B1gWdHjEgAAgBsZ4RqPxyb5QZLz+vX7ZYQemVs47pZMBZNP7+9vNGFOBnpU9uc/bZbnGDTqEPb5GuoOQASXAAAADBnxGo8vmWH3G8y6PTTU/LwtHHdLbhBMrjvmlJMzD8PXB5zen3PtDHVODUs/fQ7PCcCQam24hz1bUlV7JtmYZHVr7bLFrgcAAGCurTvmlMPSDQsfx9SXzMcluUOSo9MNBx/HS5N8LHMfTG7VUM/QwfBy6vGZVRxgTKPma3pcAgAAMGxbrt1Y6cK9d2bb51X49vrjDj9tG48xlvXHHX7SumNOOSJbGZYOwPwxOQ8AAADDtvXajZW5+b65qNeQ7MPJddm2iX4AGJMelwAAAAzb2jUe59vEXENyDib6AWBMelwCAABwA31Yd1S/uNATI0yd7+iFvq4lAJNFcAkAAMCN9MOhj0hy1gKfekNMfANADBUHAABgyLpjTlmZ5NAkOyV5XZIX9Zvmatj41FDwI5Psn2TfJOcnOTuLMIM4AJNJcAkAAMD11h1zyqNz45m0Z2NTutF9Wws5j15/3OEfG/McACwDhooDAACQ5PrQ8sR0k/KM41+S/Hb/75mujXlhDAUHYASCSwAAAKaGhx/fL447JPzJSTZn+mtjXpTkr5PsL7QEYBSGigMAACwjA9evXJPknPzimpKHZvzh4VN2S9dj84gk62Y4DwCMpFqbqfc+06mqPZNsTLK6tXbZYtcDAAAwqhmuX7khyVFJdknyljk4zdTEOwcLKgGYzqj5mh6XAAAA25npelUmeWS63pDDw8DX9uuvmKPTV5ID+/OfNkfHBGAZElwCAABsR7bQq3J1pr925dS63ea4lDVzfDwAlhnBJQAAwHZiYFbwYWsz/oQ74zpngc8HwHZGcAkAALAd2Mqs4HMZWp7ZH2+mMHTqGpenz+E5AViGBJcAAABL1NC1LB+cbZ8VfGtakqP7f5/YL9fQ9iQ52sQ8AGwrwSUAAMASNMO1LOfThUmevv64w0/qz3/ENOffkC60PGmBagJgO1atta234nqjTtcOAAAwH/peli9I8uIFOuVlSR6T5OPDvSinm71cT0sAtmbUfE1wOUuCSwAAYLGsO+aUxyV5Q+Z+BvDpTH1ZPEIPSgDm0qj5mqHiAAAAE2ygV+PLk/zyPJ2mJbk4yU0H1hn2DcCiElwCAABMmD6sfGC6IeH3SrLLPJ7u8iRHJjk5hn0DMEEElwAAABOkn3TnhCR7LNApH7X+uMM/1v/7tAU6JwBs1ZwEl1W1OsnPWmv+GgcAADCmPrR8zwKdrqUbDv6JBTofAMzKinF3rKpDquqDVXVFkouSPKBfv09VnVxVh81NiQAAANu/fnj48Qt0uqmJd442HByASTVWj8uqum+SjyU5K8lbkvzh1LbW2oV9D8ynxzADAACAGQ1MvLMmyX5JDligU5t4B4CJN+5Q8Zcl+XaSe6e77sofDm3/eJInb0NdAAAA260+sHx+kqOT7D2Hh35nksen61FZA+uneli+Ksn7YuIdAJaAcYPLX07yvNba1VW1+zTbz0qy//hlAQAAbF8Gelc+MslTk+w2x6d4+frjDn/uumNOeVe6IeeDvTf1sARgyRn3GpfXbmXftUl+NuaxAQAAtiv9pDvr041OOzpzG1peneSx6487/LlJ0oeT65I8MMkT+vuDhZYALDXVWtt6q+Gdqj6YZPfW2v2q6qZJLkjya621j1XVbkm+meT/WmuPndtyF19V7ZlkY5LVrbXLFrseAABgsvWh5Ym54dDtufDzJP+Y5KWGfQOwlIyar407VPzYJJ+oqlOSvL1fd5equmWSv0hysyQvHfPYAAAA24V5min8VUlOjutUArCdGyu4bK19vqoeluTfkry5X/2K/v6HSR7WWvvaHNQHAACwlB2auZsp/KIkTzPkG4DlYtbBZVVVupnEP9Nau11V3TXJbdJd8/KHSb7Yxhl/PqaqemaS56SbDOirSf60tXbGFto/Nl1v0HVJvp/kua21UxegVAAAYDvT96j81XTfSX4p3fUmT003Ec7VSdbM4eket/64wz82h8cDgIk2zuQ8Oya5OMmzkqS19pXW2rtba+9srX1hgUPLxyf5pyQvTnL3dMHlh6pq3xna3zfd0PbXJ7lbkvcmeW9V3XlBCgYAALYb64455bFJrkzyv0kenGS/JAcleUaSq9Ydc8p/JzlnDk7VkpyZ5BNzcCwAWDLGnZxnQ5J/aK3N9bVaZlvH59NNAvQn/fKKdL/QX91aO26a9u9Msltr7TcH1n0uyVdaa88Y8Zwm5wEAgGWs72V5WpL7jdD85CT3SLI2403OM/WF7QhDxAHYXoyar43T4zJJTkjypKraccz9t1l/7nsk+cjUutba5n75PjPsdp/B9r0PbaF9qmqnqtpz6pZumDwAALDMrDvmlJXrjjnl2CRXZbTQMkkemW4C0+QXIeRMTk+yYWjdhggtAVimxp1V/OtJHpXkm1V1QpL16YZI3EBrbT5/ue6TZGWS84bWn5fk9jPss/8M7fffwnmel24WdQAAYCmqWpVk9yQ/T2vXjrpb37Py0HTXqbx1uutYjtOR4dAkR6SbXXy6iXrOT/LM9ccdfuLQOc+JmcMBWMbGDS7fPvDvl87QpqULFpe6v0t3Hc0pe+TGfwUFAAAmTdUDkvxJuk4Xq5JsStX/JHlNko9mC9fNWnfMKY/OzEHjbN16/XGH/8m6Y045OV0oefMk+6YLLM/OQDjZ3582B+cEgCVv3ODygXNaxXguTLIp3QWwB+2X5NwZ9jl3lu3TWrs63cyASZJuUnUAAGBidf9p/7skz03y7etqxfM+dNv77rbDpmtvdd+ffu1Xdr/myg8neXWqjpouvOxDyxMz3jUpp7NXIpQEgNkaa3KeSdFPznNGa+1P++UVSX6a5DVbmJxn19bawwfWfSbJ10zOAwAA24mqo5O8Msmzb/mck3+yecXKX/ScbC1P+eL7Ljn2o6+7SZK/Smt/O7hrP1T7vCQ3ncOKLkqynyHfANCZ78l5Bk90x6p6aH+747Yeb5b+KclTq+rJVXWHJP+WZLckb+xre3NV/d1A++OTPKSq/ryqbl9VL0pySLqhIgAAwFJXtXOSFyT593XP/Z+fbF6x8sR0M3pPbc8bD3nkXq/75Ufl2hUrn5+q3YeO8PzMbWiZ/niHzvExAWC7N3ZwWVWPrKofppuo53/629er6gdV9Yi5KnBLWmvvTDdD30uSfCXJXZM8pLU2NQHPQekuaj3V/jNJnpDkaUm+mu4C2Y9qrX1jIeoFAADm3aOT7HPZTrv9c7qOC8mNh3zXCfd4RFvRNu967YqVvzO1su9tefQ81bVm600AgEFjXeOyqh6W5D1JfpLuL5Lf7jfdIV0oeFJV/WZr7YNzUuUWtNZekxl6TLbWDptm3buTvHueywIAABbHnZP85JeOfud+2cLEOmet3rd+uPeBWX+TNc982jGn/FKSHyb5RpK956muc+bpuACw3Rp3cp4XJvlakkNbaz8fWP++qnpNkk8lOTbJvAeXAAAA0xiph+OG1fvdJcld+sXN81BHS7IhyenzcGwA2K6NO1T8l5K8aSi0TJL0607o2wAAACykbyS5xe996X+22Elj7cbzc6uLN+S7N7vF4Opxvh9dneTj6QLK4ZlPp5aPNjEPAMzeuMHlVdnyEIq9+zYAAAAL6aQkF774w6+9X7qejsNhYpLkyC++Lz/fYee8/w73H+ccU8c8Nslu6487/FfTXT//rKF2G5Icsf64w08a5yQAsNyNG1x+LMlRVXWf4Q1Vda8kz0rykW0pDAAAYNZauyrJ365Ie9oJ7/rrj6a1ZDC8bC1P/PKpeer/vTevvddjcsWOu8x4pC2c5YIkr0zyyakVfTi5LskD000I+sAkBwstAWB81dqWfh/PsFPVwUk+m+RmSc5I8t1+0+2S3DPJ+Unu01pbPzdlTo6q2jPJxiSrW2uXLXY9AADAkKpK8rIkx1y+465n/ce9Hr37j29y89X7XX5RHvv1j+T2F/4kb7zHw/PiBz0tqeEJx6/3syS7Dyyfn+TzSe6d7nvQlA1JjhJQAsDoRs3Xxgou+xPsm+R5SR6aZOrCMD9JcmqS41pr54914AknuAQAgMm07phTViY5NMnNk+z7x599195P/PKp99v/8osOXZG26rpakY/c5l55890Oz2ducZcthZZJ8uwkX043yc85SfZJ8q5+2+COU1+oDAkHgBHNe3C5XAkuAQBg8qw75pRHJzk+yQHD21Zs3nTxbtdetfcVO+ycTStWjnK4TUl2WX/c4df2x16ZZH2StblhaDllaubwg03CAwBbN2q+NtY1LqtqVX+CGU9eVVucxQ8AAGAu9KHliemCxRvZvGLl3pfvtNuooWWSvGIqtOwdmi4QnamLZiU5sG8HAMyRcSfn+eckn9nC9k8necWYxwYAABhJ3xvy+H5xi2O/R7ApycvXH3f4c4fWrxlx/1HbAQAjGDe4fEi6v2jO5MQkDxvz2AAAAKPaWm/IYcPXymr97Q3phocPh5ZJd43LUYzaDgAYwbjDuW+e5KwtbD87MwzTAAAAmEOz7eV4SZK9B5Y3JDl6KxPrnN6329o1Lk+fZS0AwBaM2+PyoiS328L2OyQxcQ0AADDfZtvL8bFJHpjkCf39wVubDbyfcOeofnG6HptJF36amAcA5tC4PS4/mOTpVfXW1tqXBzdU1d2TPC3Ju7e1OAAAgK3YWm/IKVO9Ij8xTsC4/rjDT1p3zClH5MYzl4/SYxMAGEO1NvwHwxF2qrp5kv9Lsm+S9yX5Zr/pzkkenuT8JPdqrW2YozonxqjTtQMAAAtjYFbxZOah3ElyxLYGjP1kQIemG6J+TpLT9bQEgNkZNV8bK7jsT7AmyXFJHplkz371ZUnem+T5rbWzxzrwhBNcAgDAwphNSNiHl8O9IaecGb0iAWBizHtwOXCiSnKzfvGCtq0HnHCCSwAAmH8zBJEbkhw1UwA5EHTePN3osPPTTRyqVyQATJAFCy4HTrgiyT7ZzsNLwSUAAMyvLQz9nrMh3wDA4pnz4LKqbpvk3kne31q7ZGD96iSvTvK4JDskuSTJi1prrxm//MkluAQAgPFtbfh3v319Zp5sZ2qSnYP1ogSApWnUfG3FLI7550lemuTSofWvTfLEJD9JclKSq5McX1WPmsWxAQCA7Vzfk3J9ko8neVt/v75fP+XQdMPDZ5ohvJIc2LcDALZjswkufyXJ/wwOA6+qA9P1tPxskju11h6b5E5JfpTkmXNZKAAAsHQNDP9eO7RpbZITB8LLNSMectR2AMASNZvgcm2S7wyt+810QzWOb61dlySttUuTvDnJ3eaiQAAAYGnrh38f3y8O96ScWn5V3+6cEQ87ajsAYImaTXC5Ism1Q+vu199/Ymj9hiR7jFsUAACwXZnN8O/T032fmOli/C3JmX07AGA7Npvg8ofpJudJklTVyiS/muQ7rbXzhtruneSCbS8PAABYyvpelL86YvM1/YQ7R/XLw+Hl1PLRJuYBgO3fbILLNyV5QlU9t6oOTfIvSfZN8pZp2h6a5HtzUB8AALBEDUzG88IRdzknSdYfd/hJSY5IctbQ9g1Jjui3AwDbuRqYa2fLDat2SDdr+OHp/tJZ6YaI/3pr7dqBdgcm+UGSv2qt/cOcV7zIRp2uHQAAlrOByXiSmYeIT2npQsmDB3tS9r01D003Ec85SU7X0xIAlr5R87WRg8uBAx+S5FZJftJa+9w022+d5C5JPtla2+6GiwsuAQBgy/rAcX26CT5HCS0TPSkBYNkYNV9bNdsDt9a+kOQLW9j+g3Q9LgEAgOVpajKeUWxId81KoSUAcAOzucYlAADAKNaM2O6l6YaHCy0BgBsRXAIAAHPtnBHbfcw1KwGAmQguAQCAuXZ6uiHgM11QvyU5s28HADAtwSUAADCn+l6UR/WLw+Hl1PLRelsCAFsiuAQAAOZcf93KI5KcNbRpQ8wgDgCMoFqbafTGCDtX7ZTk7kn2TfLp1tqFc1XYpBp1unYAACBZd8wpK9PNMr4m3bUvT9fTEgCWt1HztbGDy6p6VpIXJVndr3pwa+1jVbVPku8k+cvW2hvGOvgEE1wCAAAAwPhGzdfGGipeVU9J8qokH0zyB0lqalvf6/JjSX57nGMDAAAAAIx7jcs/T3Jya+0JSd4/zfYvJrnT2FUBAAAAAMvauMHlrZN8YAvbL05y0zGPDQAAAAAsc+MGl5cm2WcL2++Y5Nwxjw0AAAAALHOrxtzv1CRPq6p/Hd5QVXdK8tQk293EPAAAsFSYzRsAWOrGmlW8qm6e5PPpJuV5f5KnJXlLkpVJHpPuP0b37Cfq2a6YVRwAgEm37phTHp3k+CQHDKzekOSo9ccdftLiVAUA0Bk1XxsruOxPsG+SlyV5dJK9+tWXJ3lPkmNaa+ePdeAJJ7gEAGCS9aHlif1iDWya+o//EcJLAGAxzXtwOXSym6W7XuYFrbXN23zACSa4BABgUvXDw9cnWZsbhpZTWrqelwcbNg4ALJZR87VxJ+e5gdbaBa2187b30BIAACbcoemGh08XWqZff2DfDgBgoo0VXFbV31TVV7aw/ctVdezYVQEAAONYM8ftAAAWzbg9Lo9I8oEtbD81yePHPDYAADCec+a4HQDAohk3uDwoyQ+3sP3HSW4x5rEBAIDxnJ7uGpYzXci+JTmzbwcAMNHGDS5/li0HkwcnuWrMYwMAAGPoJ9w5ql8cDi+nlo82MQ8AsBSMG1yeluTpVbV2eENVHZjkaUk+vg11AQAAY1h/3OEnpbu001lDmzYkOaLfDgAw8aq1mUaRbGGnqtslOSPdX21fn+Sb/aY7J/n9dLMV3ru19u05qnNijDpdOwAALKZ1x5yyMt3s4WvSXdPydD0tAYBJMGq+NlZw2Z/gl5K8Ot1/hgZ9MsmzWmtfG+vAE05wCQAAAADjGzVfWzXuCfpg8gFVtU+SW/arf9Rau3DcYwIAAAAAJNsQXE7pg0phJQAAAAAwZ8YOLqtqZZLfSNfb8ibprms5qLXWXroNtQEAAAAAy9RYwWVVHZLkPUkOyI0DyyktieASAAAAAJi1FWPu969JdknyqCR7t9ZWTHNbOWdVAgAAAADLyrhDxX8pyQtaa++fy2IAAAAAAJLxe1xuyMxDxAEAAAAAtsm4weXfJ3lqVe05l8UAAAAAACTjDxXfI8nPkvygqt6R5Mwkm4batNbaK7elOAAAAABgearW2ux3qto8QrO2PU7Q0/cy3ZhkdWvtssWuBwAAAACWklHztXF7XB485n4AAAAAAFs1VnDZWvvJXBcCAAAAADBl3B6XSZKqWpvk/kn2TfKe1tqGqlqZZHWSja214eteAgAAAABs1Vizilfnn5L8OMlbk/xTktv2m3dPsj7Jn85FgQAAAADA8jNWcJnkOUmOSvKPSR6cpKY2tNY2JjkpyWO2uToAAAAAYFkaN7h8apI3t9aen+Qr02z/Wn7RAxMAAAAAYFbGDS4PTPKZLWz/eZI9xzw2AAAAALDMjRtcnp8uvJzJPZL8dMxjAwAAAADL3LjB5UlJnlFVtxxY15Kkqn49yZFJ3r1tpQEAAAAAy1W11ma/U9XqJJ9McnCS05M8JMmH080ofp8kX05y/9baFXNX6mSoqj2TbEyyurV22WLXAwAAAABLyaj52lg9LvuZw++d5OVJ1ia5KskDkuyV5MVJDt0eQ0sAAAAAYGGM1eNyOdPjEgAAAADGN689LgEAAAAA5tOqcXaqqjeM0Ky11v5gnOMDAAAAAMvbWMFlkl9NP4v4gJVJ1vT3FyT5+TbUBQAAAAAsY2MFl621ddOtr6odkjw9ydFJHjx2VQAAAADAsjan17hsrV3bWntNkv9N8pq5PDYAAAAAsHzM1+Q8X01y/3k6NgAAAACwnZuv4PLBSa6Yp2MDAAAAANu5cWcV/+sZNu2Vrqfl3ZMcN2ZNAAAAAMAyN+6s4i+aYf0lSX6Y5BlJXjfmsQEAAACAZW7cWcXna4g5AAAAAMC8XeMSAAAAAGBsI/W4rKqDxjl4a+2n4+wHAAAAACxvow4VX5+kjXH8lWPsAwAAAAAsc6MGl0+Z1yoAAAAAAAaMGlxekuQLrbWz57MYAAAAAIBk9Ml5/jvJYVMLVfWjqnrEvFQEAAAAACx7owaXlyfZa2B5XZLd57oYAAAAAIBk9KHiZyR5QVXtl2Rjv+5hVbX/FvZprbVXblN1AAAAAMCyVK1tfbLwqrp1kjcnuXe/qiWprezWWmvb3aziVbVnuvB2dWvtssWuBwAAAACWklHztZF6XLbWfpDkvlW1c5J9k6xPcnSSk7e5UgAAAACAIaMOFU+StNauSvLTqnpxko+11n4yP2UBAAAAAMvZrILLKa21F891IQAAAAAAU8YKLpOkqu6Q5ClJbpnkJrnxNS9ba+1B21AbAAAAALBMjRVcVtXvJXljkmuTfDfJJdM124a6AAAAAIBlbNwely9K8uUkD22tXTh35QAAAAAAJCvG3O/mSd4gtAQAAAAA5sO4weXX0oWXAAAAAABzbtzg8tlJ/qCq7juXxQAAAAAAJONf4/K5STYmOb2qvpXkp0k2DbVprbVHbktxAAAAAMDyNG5w+UtJWrrAcvckd5ymTRu3KAAAAABgeRsruGytrZvjOgAAAAAArjfuNS4XXVXtXVVvrarLqurSqnp9Ve2+lX1Oq6o2dPv3haoZAAAAABjNuEPFJ8Fbk6xJ8uAkOyR5Y5L/SPKErez3uiR/PbB8xbxUBwAAAACMbeTgsqouz+yuW9laa6tnX9JItdwhyUOS/HJr7Qv9uj9NcmpV/UVr7ewt7H5Fa+3c+agLAAAAAJgbs+lx+Z5MzoQ790ly6VRo2ftIks1J7pXkv7ew7+9W1ROTnJvk/Ule2lqbsddlVe2UZKeBVXuMXTUAAAAAMJKRg8vW2pHzWMds7Z/k/MEVrbXrqurifttM3pbkJ0nOTjcz+t8nuV2SR29hn+clOXabqgUAAAAAZmWirnFZVcclee5Wmt1h3OO31v5jYPHrVXVOko9W1a1aaz+cYbe/S/JPA8t7JNkwbg0AAAAAwNZNVHCZ5BVJTthKmx+lG+a97+DKqlqVZO9+26g+39/fOsm0wWVr7eokVw+cZxaHBwAAAADGMVHBZWvtgiQXbK1dVX02yV5VdY/W2hf71b+aZEV+EUaO4q79/TmzqRMAAAAAmF8rFruAcbTWvp3kg0leV1X3rKpfSfKaJO+YmlG8qtZW1Xeq6p798q2q6oVVdY+qWldVj0jy5iSfbK19bbEeCwAAAABwY0syuOz9bpLvJPloklOTfCrJ0wa275Bu4p1d++Vrkvxakv/t93tFupnSH75A9QIAAAAAI6rW2mLXsKRU1Z5JNiZZ3Vq7bLHrAQAAAIClZNR8bSn3uAQAAAAAtlNjB5dV9dCq+nBVXVRV11XVpuHbXBYKAAAAACwfYwWXVfWYJP+TZL8k7+iP8/b+31cm+VqSl8xRjQAAAADAMjNuj8vnJTkjyd2SHNuve0Nr7XeT3DnJmiQ/3vbyAAAAAIDlaNzg8o5J3tFa25Tkun7dDknSWluf5F+TPHebqwMAAAAAlqVxg8srklyTJK21S5Ncna6X5ZTzkhy8TZUBAAAAAMvWuMHld9P1upzylSS/V1WrqmrnJE9I8tNtrA0AAAAAWKbGDS7/O8kjq2qnfvlvkxyW5NIkFyQ5NMlx21ocAAAAALA8VWttbg5UdWiSx6S75uUprbWPz8mBJ0xV7ZlkY5LVrbXLFrseAAAAAFhKRs3XVs3VCVtrpyc5fa6OBwAAAAAsX3MWXFbVrkl+O8lOSU5trf1kro4NAAAAACwvYwWXVfX6JPdqrd25X94xyeeS3LlvsrGqfrW19uW5KRMAAAAAWE7GnZzngUlOGlh+QrrQ8nf7+3OTHLttpQEAAAAAy9W4weX+SdYPLD8qyRdaa29vrX0ryeuS3GvbSgMAAAAAlqtxg8ufJ9krSapqVZLDknxoYPvlSVZvS2EAAAAAwPI17uQ8X0ry1Kr6eJJHJNkjyfsHtt8qyXnbWBsAAAAAsEyNG1y+IF0Pyy8kqSQnttbOGNj+W0k+vY21AQAAAADL1FjBZWvtC1V1+yT3TXJpa+0TU9uqaq8k/5rkEzPsDgAAAACwRdVaW+walpSq2jPJxiSrW2uXLXY9AAAAALCUjJqvjTU5T1UdVFX3G1p3l6p6c1W9s6oeNc5xAQAAAACS8a9x+c9Jdk/ya0lSVfsl+XiSHdPNKH5EVT22tXbSnFQJAGwfqu6S5A+S3DLJdUk+l+T1ae2CRa0LAACYOGP1uExyzyQfHlh+UpJdktwlydokH03yF9tWGgCw3ajaO1UfSPKVljzmvN323uusPW928KaqF7dkQ6pelKpa7DIBAIDJMW6Py72TnD+w/JtJPtFa+2GSVNVJSV62jbUBANuDqt2S/G+Sde/8pQe/4gW//szHX7dy1a8kyV5XXpY//ty7L3vaGf99bJKdkxyzmKUCAACTY9welxckuUVy/Szi907yoYHtqzJ+KAoAbF+OSnLnFz74GS977kOPevZ1K1etndpw6S575mUP/IM9XnbYU1qS56bqTotXJgAAMEnGDS4/kuRZVfXsJG/uj/Pege13THLmtpUGACx5VSuTPH1z6u3/dfff/LOptcOt3njII3LRLqs3b6764wWuEAAAmFDjBpfHJPl2kn9M8utJ/qK19uMkqaqdkjwu3XUuAYDl7fZJDvqvux/+1SQH5MahZZLk2pU71PvueP8VV6/c8VELWRwAADC5xhrO3Vo7L8mvVNXqJFe21q4Z2LwiyYOixyUAkOyeJN/a9+Cdttbwkl32TNJ2nfeKAACAJWHcHpdJktbaxqHQMq21K1trX22tXbxtpQEA24Fzk+T+P/7SLltreKuLNuS6FSsvmv+SAACApWCkHpdV9aT+n//VWmsDy1vUWnvz2JUBAEtfaz9J1acf9t1P3z/JhiRrM81w8b2v2Nge+t1P14q2+bULXiMAADCRqrW29UZVm5O0JLu01q7pl7emtdZWbmuBk6aq9kyyMcnq1tpli10PAEy8qscmedf/3uber3vao//qD6fWTm3eYdO17d/e+3d12I++eNWqzZsOSGt6XQIAwHZs1Hxt1ODyFknSWvvJ4PLWTLXfngguAWCWqirJK5Mc9cO9137iuQ951h2+eMAd9t1h06b8+vc/mz/+3Luvuf0F61esaO3hae2Di10uAAAwv+Y0uBzj5Lv1Jz57zg++yASXADCGLrx8RpK/TLKuJa36Xpct+UQlz09rn1nUGgEAgAWx2MHlC5K8xFBxAOAGqlYmeWCSWyW5Nsnn09o3F7coAABgIY2ar400OQ8AwJxobVOSj/Q3AACAGa1Y7AIAAAAAAIYJLgEAAACAiSO4BAAAAAAmzsjXuKyqu8/iuDcfoxYAAAAAgCSzm5znC0lGnYK8ZtEWAAAAAOAGZhNcPmXeqgAAAAAAGDBycNlae9N8FgIAAAAAMMXkPAAAAADAxBFcAgAAAAATR3AJAAAAAEwcwSUAAAAAMHEElwAAAADAxBFcAgAAAAATR3AJAAAAAEwcwSUAAAAAMHEElwAAAADAxBFcAgAAAAATR3AJAPxC1Z6pemaqvpqqq1N1Zao+k6rfS9VOi10eAACwfAguAYBO1R2SfD3J8ZtT3//MQf/v3//31vd694W7rt4hyZuTfD5Vaxa3SAAAYLlYtdgFAAAToGrfJB9OcslTH/1XL/vwbe79V0kOmNp8l7O/d9473n7Mgbtcd82pqbpPWrtq0WoFAACWBT0uAYAkeWaS1U94/N++6sO3ufe/JVk7uPGrN7/tvkc88R9ukuSuSR67CPUBAADLjOASAJa7qpVJnro59ZbPrLvLi6bWDrf65n63yucOvPNVLfnjhS0QAABYjgSXAMD+Sda8586/+pN0w8OHQ8sp9cHb3nfnlrrHwpUGAAAsV4JLAGBlklyw201Wb63hdStWJsmKVM0UbgIAAMwJwSUAcG6SjYf9+IsHbq3hvX/69Vyx484/TWttAeoCAACWMcElACx3rV2T5E13OP/Hv77b1VeclWTaUPLmG89vD/n+Z7PztVe/akHrAwAAliXBJQCQJP9cyc4f+c8/unDXa65MhsLLm/3skvb697ykrl2x6qJVbfObFqdEAABgOSkjvWanqvZMsjHJ6tbaZYtdDwDMmaoHJjn56pU7bH7z3Q9f8cmD777Hys2b8sAffSFHfP2jbUXbfMku111z/7T2zcUuFQAAWLpGzdcEl7MkuARgu1Z1qyTPasmRleyZJNesXHXJys2b/nVla69Ja+cucoUAAMASJ7icJ4JLAJaFqp2S7J9kc5Jz09q1i1wRAACwnRg1X1u1cCUBAEtGa1cn+clilwEAACxfJucBAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4izZ4LKqXlBVn6mqK6rq0hH3qap6SVWdU1VXVtVHquo281wqwNJXtUOqfitVL0jV81N1eKpWLnZZAAAAbL+WbHCZZMck707yb7PY5y+TPCvJM5LcK8nPk3yoqnae+/IAtgNVlapnJlmf5KQkRyd5dpL/SfLDVD1p8YoDAABge7ZqsQsYV2vt2CSpqiNHaV9Vle4L99+01k7u1z0pyXlJHpXkHTPst1OSnQZW7TFuzQBL0N8meV6SE3624y7H3/nP3r1XkjXPPv0te/7JZ975oBVpb0rVvmntHxe3TAAAALY31Vpb7Bq2SR9cvqq1ttdW2t0yyQ+T3K219pWB9Z9I8pXW2lEz7PeiJMdOs2l1a+2y8aoGWAKqHpjkY0mes+65//OjJMcnOeD67a1tOPGtf/n5Q8769mOS3D2tfXlxCgUAAGApqao9k2zMVvK1pTxUfLb27+/PG1p/3sC26fxdktUDtwO20BZge/KnSb5xy+ec/KMkJyZZe4OtVWsf/4TjHn3Fqp0uTPLMRagPAACA7dhEBZdVdVxVta3cbr+QNbXWrm6tXTZ1S3L5Qp4fYFFU7ZLkEdfVitdvXrHy+Km1w602rViZE+7x8B1b8vh0l+QAAACAOTFp17h8RZITttLmR2Me+9z+fr8k5wys3y/JV8Y8JsD2anWSle+74wN2zZZ7mtcPb3rgnn1iuWOSq+e/NAAAAJaDiQouW2sXJLlgng7/43Th5YPSB5X9ePp7ZXYzkwMsB5cnyarNm9ZtreHNfn5JNlVdt7K1a+a9KgAAAJaNiRoqPhtVdVBV3TXJQUlWVtVd+9vuA22+U1W/lSStm4XoVUn+qqoeUVX/L8mbk5yd5L0LXT/ARGvt50k+ev8ff+k+W2mXx3zjozlv95t+Kkt9tjcAAAAmypINLpO8JMmXk7w4ye79v7+c5JCBNrdLN9xxysuTvDrJfyT5v36/h7TWrlqIggGWmH/d66qf3fm3vvGxi5JMG0o+4SsfbLe56MzsfeVlL13g2gAAANjOlQ4yszPqdO0AS17ViiRv3pz8zivv97v1lrs9LJfsurqS5GY/uzhP+eL78ozPvSff2XfdB+94/o8fpsclAAAAoxg1XxNczpLgEpaJqj3SXQN3t3QTen0hrW1e3KIWQdWqJH+/qepPr1uxaodv7XvLVDbnTuf9KNetWNm+vv9t3n3PDd/8nWX53AAAADAWweU8EVzCdq5q3yTHJnlSustJTPl+kuOT/NuyDOmq9rmuVhx51up9H3jFDjvvcukue3x9v8svevEtLz7r4sUuDQAAgKVFcDlPBJewHas6KMlpSfbcVCv+7UW/9rTvfW3/2+z6yG99Yucjv/j++6xIe1yStyQ5clmGlwAAADAHBJfzRHAJ26mqSnJGkn3+4DEvPO6jt77XXyU5YKDFhn849VXveuzXP/JnSZ6T1l6xKHUCAADAEjdqvraUZxUHmEuHJjnk3+71mDd99Nb3+rcka4e2r33Ow47+s+/uc9DHkhzdX/sRAAAAmCeCS4DOkS35/t8/4Mg/6JdraHslyXMfetSd0vXE/NWFLA4AAACWG8ElQOeAc/e46dmpOiA3Di2n1Nf2v/X+/b8PXKC6AAAAYFkSXAJ0rtpcK26ytUa7X3Pl9e3ntxwAAABY3gSXAJ1PrLnswjvc9OeXbrHR4d/5VFqyOcnpC1IVAAAALFOCS4DOGytt05996q0/S9Kma7D71Ve0P/rcide15P1p7acLXB8AAAAsK4JLgCRp7eJKnv/Er3xg9+d//PW151U/u0F4eesLf9r+650vrDWXX3DNiuR5i1UmAAAALBfV2rQdi5hBVe2ZZGOS1a21yxa7HmAOVVWSZ29O/f3Vq3ZY8ZFb36s27rx7bnPRmbnXmd/Ilat2vGiX6675jbT2xcUuFQAAAJaqUfM1weUsCS5hGahas6lWPO3ynXY9YnOt2H1TrThvr6su/+cdNm96T1q7erHLAwAAgKVMcDlPBJcAAAAAML5R8zXXuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOKsWuwBgDFU7JnlkkkPSvY+/n+TtaW3jotYFAAAAMEcEl7DUVD0lycuS7H/lqh3Pvnblqux+9RX7VfKKqvqXJM9Pa9ctcpUAAAAA20RwCUtJ1Z8l+acf7r32k896+F/WN/e/1c2T5GY/uzh/8IWTr3va50969oq0W6Tqd9La5kWuFgAAAGBs1Vpb7BqWlKraM8nGJKtba5ctdj0sI1W3TfKdL6+57cm/9XuveGSqkqQGWrTf+N5n8tr/flkleXJae/Oi1AkAAACwBaPmaybngaXjj1py0eOfcNwh04SWSVIfuu1985mDfumqljxzEeoDAAAAmDOCS1g6HvODmx74iWtW7XhAbhxaTqm33O1hO1dyz1QdsJDFAQAAAMwlwSUsHXv9ZK81V26t0bl73HTqnzeZ33IAAAAA5o/gEpaOS29x6Tm7bK3R/pdfNPXPS+a3HAAAAID5I7iEpeM9t77ozAfsdO3VG5LMNKtWe+KXT72qJWektQ0LWRwAAADAXBJcwtLxb5Xc9J1vf94X01py4/CyPeS7n8l9f/q1nSv5l0WoDwAAAGDOCC5hqWjte0mefddzvvfIj73uGZ+607k/PH9q076XX5TnffwNl//re1/WkrwzyVsWrU4AAACAOVCtzTTilOlU1Z5JNiZZ3Vq7bLHrYRmqOjLJy5KsuWrVjudes2JV2/2aK/at5Kq+p+UL0tp1i1skAAAAwPRGzdcEl7MkuGQiVO2Q5JFJDkmyKsn3k7wjrW1c1LoAAAAAtkJwOU8ElwAAAAAwvlHzNde4BAAAAAAmjuASAAAAAJg4gksAAAAAYOIILgEAAACAiSO4ZHmqqlQ9IFXvSNX3UvWDVP1Pqh6RqpWLXR4AAADAcie4ZPmp2iPJqUlOa8ldvrfPQV/+wto7fHvjTrvdMsnJSb6QqrWLWyQAAADA8lattcWuYUkZdbp2JlTVqiQfTPLLb7r7b/7rsb/29Cem6oCpzff86TfOf9O7j125y3VXn5/kPmlt46LVCgAAALAdGjVf0+OS5ebhSR70L/d+7D8d++BnPHe4Z+UZB935Zocfefzem6puneRpi1MiAAAAAIJLlps/bsln/+EBT/7DfrmGttePbnpAPnC7X7mmJX+UKu8RAAAAgEUglGG5+ZUvrr3DV5MckBuHllPq5DsetlslByfZf+FKAwAAAGCK4JLlZsfzd997p601umrVjte3n99yAAAAAJiO4JLl5sd3PvcHa7bW6P+d+4NsqromyfkLUBMAAAAAQwSXLDdvOHDjeYfd9OeXnp2kTddg1abr2u996ZRN1fLWtHbFAtcHAAAAQASXLD+vr+SqU9/4pxfvdvUVyVB4uWrTde0fPnB87fezi9uKtFctSoUAAAAApFqbttMZM6iqPZNsTLK6tXbZYtfDGKoOTXLKFTvsdNW/3+sxO37wtvddvWnFytz7p1/P73/h5GsPvvjsFSvSnpjW3rHYpQIAAABsb0bN1wSXsyS4nCNVt0zy20n2S/KzJB9M8qks1Auy6vZJjmnJb1eyU5K0ZHNL3rci+fu09rkFqQMAAABgmRFczhPB5Taq2jfJ65I8vCU/+/kOO1+0sm3ea5frrtmrJd+o5Glp7bMLWM/eSW6fZGWSH6S1cxbs3AAAAADLkOBynggut0HVPkk+lWSv/7n9/d7znIce/cgrd9x5bbXNue9Pvpa//MSbrrnzeT/Myrb5QWntU4tdLgAAAABzT3A5TwSX26DqDUke8cxHPPevT7nDoa+ZWju1eafrrmlvetdf1y+d8/0Ld73u6jVp7brFKRQAAACA+TJqvmZWcRZG1U2T/M6mWvGKU+5w6POm1g42uXrVjvXSBz217Xrd1ftcs2LVIxa+SAAAAAAmheCShfKQJDsf+dgXfTvJARkKLad8c79b1Tf2u1XO333vZyxodQAAAABMFMElC2WvJNeefvDdd9law3P2uGk2dz00AQAAAFimBJcslEuS7PDAH/7f1VtrePPLLkylXbgANQEAAAAwoQSXLJQPJLnyP9/z0jsk2ZBk2lmh7nzu99udzv9R9vvZxf++oNUBAAAAMFEElyyM1i5J8raVbfOzH/Gt046bWjvYZKdrr25//dH/rCt22OmCHTdd9/6FLxIAAACASVGtTdvxjRmMOl0706jaO8mnkuzzgdve96S/eNjRv/nznXZdW21z7v/jL+cvP/Gma25/wfqsbJsfmNY+s9jlAgAAADD3Rs3XBJezJLjcRlX7JHltkke15Mord9jp4hWbN6/eedO1e7bkK5U8Pa2dsdhlAgAAADA/Rs3XVi1cSZCktQuTPCZVt6jk8btee/V+SX6e5NRKPh9JOgAAAADR43LW9LgEAAAAgPGNmq+ZnAcAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACbOkg0uq+oFVfWZqrqiqi4dcZ8TqqoN3T44z6UCAAAAALO0arEL2AY7Jnl3ks8m+YNZ7PfBJE8ZWL56LosCAAAAALbdkg0uW2vHJklVHTnLXa9urZ079xUBAAAAAHNlyQ4V3waHVdX5VfXdqvq3qrrplhpX1U5VtefULckeC1QnAAAAACxbyy24/GCSJyV5UJLnJnlAkg9U1cot7PO8JBsHbhvmu0gAAAAAWO4mKrisquOmmTxn+Hb7cY/fWntHa+19rbWvt9bem+Q3k/xyksO2sNvfJVk9cDtg3PMDAAAAAKOZtGtcviLJCVtp86O5Ollr7UdVdWGSWyf56Axtrs7ABD5VNVen375U7ZDkUUkem2TvdL1TT07yrrR21SJWBgAAAMASNFHBZWvtgiQXLNT5quqAJDdNcs5CnXOiVe2T5L5Jdk5yZpLPp7XNI+z3K0nemWRtS844Z499fr5q86Y77fvzSx7dkldU1ZPS2gfmtXYAAAAAtisTFVzORlUdlK5n30FJVlbVXftNP2it/axv850kz2ut/XdV7Z7k2CTvSXJuklsleXmSHyT50AKXP1mq1iV5aZLHJdlxYMv3U/XKJP+e1toM+/5ykg8n+b/n/caf/OPb7/qQP08/nH7dxWflJR/+993vt/4r719R9dC09uH5fBgAAAAAbD9qpjxq0lXVCUmePM2mB7bWTuvbtCRPaa2dUFW7JHlvkrsl2SvJ2Un+N8kLW2vnzeK8e6YbBr26tXbZNjyEyVB1xyQfT3LNdbXi1Uc9/Dk//va+B+/xu1/5wO5P+cL7fmVF2uOSvC7J06cNL6vOSLLinn/8pn88f4+bvm1q7dTmlZs3tRPedWzd/ezvnLfbtVfdfKQenAAAAABst0bN15ZscLlYtqvgsmpVku8kueIRT/qnV3xtzW3/JjecfGjDP7/v5e99xLc/+SdJnpHWXju0/yFJ/u+alaseddu/eO9rkqzNQGg55W5nfaf991v+oq5eucPDd7rumv+Zt8cDAAAAwMQbNV+bqFnFWXAPT3KrY3/t6W/62prbvjFd8Dho7bMe8ZfPXL/Xms8k+bNpZib6jSSX3vVZb788XeA57cxFX7757eone+2fn+61/3Q9ZAEAAADgRgSXy9uTWvL5N93j4Uf3y8PBYyXJC3/9j26d5HZJ7jm0fdckl12x4y77bfEsVdm48+65ZuUON9n2kgEAAABYDgSXy9van+y15oJsobdkkvr6/rfet//3AUPbzkmy/yEbvvWzLZ1kp+uuyUGXnpvNVRu2rVwAAAAAlgvB5fJ21aYVK/bZWqPdr75i6p9XDm16V5J6x9uOuV2SDUmmvWDqw77zqbbXVT/LQZeee9y2FAsAAADA8iG4XN4+tu6Sc+46EExO6xHf/mQ2VV2T5HM32NDa+UneuqptfuGTv/j+V02tHWyy7uKz2vNPe0OdtcfNvrT6qp99Z+5KBwAAAGB7Jrhc3l63om3e4ahPv/3yzNBbcp+fX9Ke8oX3baqWt6W1i6dp8qwk33vxR177opP+6y/+++CLNpy7YvOmrLnsgjzr02/PyW9+dtv52mvOWnv5BQ+d10cCAAAAwHalWps2r2IGo07XvmRUvSDJ3/zLvR+b197rMe2ynXe//lqXdzn7u+0fT31VHbjxvEt2vu6au6S1M2c4xu5JXprkKUlWT63eVHVVtfzXirTnpbWL5vmRAAAAALAEjJqvCS5naTsMLivJ8zanXnL1qh1WfPyWh9TPdto1dzj/x/l/5/0wl++461l7XHPFr6a1741wrN2SPDjJTdM9Rx9Oaxvn9wEAAAAAsJQILufJdhdcTqlas6lWPG3jzrs/alOt2O26lSvP3vuKja/YadN1p6a1TYtdHgAAAADbB8HlPNlug0sAAAAAWACj5msm5wEAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgIkjuAQAAAAAJo7gEgAAAACYOIJLAAAAAGDiCC4BAAAAgImzarELWML2qKrFrgEAAAAAlpo9RmkkuJy9qSd2w6JWAQAAAABL2x5JLptpY7XWFrCWpa+6bpY3T3L5YteyAPZIF9AekOXxeGF74v0LS5f3Lyxt3sOwdHn/wsLaI8nZbQvhpB6Xs9Q/mWctdh0LYWAo/OWttRnTb2DyeP/C0uX9C0ub9zAsXd6/sOC2+j4zOQ8AAAAAMHEElwAAAADAxBFcsiVXJ3lxfw8sLd6/sHR5/8LS5j0MS5f3L0wYk/MAAAAAABNHj0sAAAAAYOIILgEAAACAiSO4BAAAAAAmjuASAAAAAJg4gkuSJFW1pqqOq6qPV9XlVdWq6rBZ7P+ifp/h21XzVzUwZVvfw/0x1lbVu6rq0qq6rKpOrqpbzk/FwKCq2quq/qOqLqiqn/fv5buPuO8JM/wO/s581w3LSVXtVFV/X1VnV9WVVfX5qnrwiPv6HQuLaNz3r++5sPhWLXYBTIzbJXluku8n+XqS+4x5nD9K8rOB5U3bWBcwmm16D1fV7kk+nmR1kpcluTbJnyX5RFXdtbV20dyWC0ypqhVJTklylyT/kOTCJH+c5LSqukdr7fsjHObqJH84tG7jnBYKnJDkiCSvSvf79sgkp1bVA1trn5ppJ79jYSKckDHevwN8z4VFIrhkyheT3LS1dnFVHZHk3WMe58TW2oVzWBcwmm19D/9xktskuWdr7f+SpKo+kOQbSf48yfPnsljgBo5Ict8kj22tnZgkVfWuJN9L8uIkTxjhGNe11t4yfyXC8lZV90zy20me01r7x37dm9P9nnx5uvfwTPyOhUW0je/fKb7nwiIxVJwkSWvt8tbaxXNwqKqqPauq5uBYwIjm4D18RJL/m/pC1R/zO0k+muRx21ofsEVHJDkvyUlTK1prFyR5V5JHVtVOoxykqlZW1Z7zUyIse0ek62H1H1MrWmtXJXl9kvtU1YFb2dfvWFg82/L+neJ7LiwSwSVz7UfphqZdXlVvqar9FrsgYMv6Yaq/lOQL02w+I8mtqmqPha0KlpW7JflSa23z0Pozkuya5LYjHGPXJJcl2VhVF1fVv/TDU4G5cbck32utXTa0/oz+/q7T7eR3LEyEsd6/Q3zPhUViqDhz5ZIkr0ny2XTX2To0yTOT3LOqDpnmlwQwOfZOslOSc6bZNrXu5km+u2AVwfKyJsknp1k/+P77+hb2PyfdULcvpfuj9EPSDU29S1Ud1lq7bg5rheVqTbb+e3I6fsfC4hv3/Zv4nguLTnC5Her/srvjiM2vbq21bT1na+34oVXvqaozkrw13Zen47b1HLBcLMJ7eJepY02z7aqhNsAWjPn+3SXb8P5rrT1vaNU7qup7Sf423fC4d4xYDzCzcd+nfsfC4hv796zvubD4DBXfPt0/yZUj3m43X0W01t6W5NwkvzZf54Dt1EK/h6/s76e7jt7OQ22ALRvn/Xtl5v7998okm+N3MMyVcd+nfsfC4pvT37O+58LC0uNy+/SdJE8Zse10Xebn0pnphsgAo1vo9/DF6f4KvWaabVPrzp6D88ByMM7795zM8fuvtXZlVV0Uv4NhrpyTZO0067f2PvU7FhbfuO/fLfE9FxaI4HI71Fo7N8kJi11HP+PauiRfXuRSYElZ6Pdwa21zVX09ySHTbL5Xkh+11i5fqHpgKRvz/fuVJIdW1YqhCXruleSKJN+bbR39ZB/7JLlgtvsC0/pKkgdW1Z5D17S718D2G/E7FibCVzLG+3cmvufCwjJUnFmrqoOq6vZD6242TdM/SnKzJB9ckMKAkUz3Hk5yYpJfrqpDBtrdLsmvJnn3QtYHy9CJSfZL8uipFVW1T5LHJnl/a+3qgfW3qqpbDSzvPMOMxC9MUvE7GObKiUlWJnna1Iqq2ildD+vPt9bO7Nf5HQuTZ+z3r++5sPhqDuZlYTtRVX/V//NOSX47yRuS/DhJWmt/M9DutCQPaK3VwLorkrwz3aynVyW5X3+Mryb5ldbaFQvwEGBZ28b38B7p/mq8R5J/THJtkmen+0/eXVtrem3BPKmqlUk+leTOSf4hyYXpLvh/UJJfbq19d6Dt+iRpra3rl9ele+++Pd0w9ST5jSQPS/eF6vChXpzAmKrqXUl+K901ZH+Q5MlJ7pnkQa21T/ZtTovfsTBxtuH963suLDLBJderqhlfDEMf3qflxh/or0ty3yQHprvI8U+SvCfJ3xr+AgtjW97D/foD0v1n7tfT9cg/LcmftdZ+MB/1Ar9QVTdJF1o+Kt3spv+X5C9aa18Yarc+uUFwuVeSVye5d5KbpwtCfpButtN/bK1duxD1w3JQVTsneWmSJya5SZKvJXlha+1DA21Oi9+xMHHGff/6nguLT3AJAAAAAEwc17gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAAAAAmDiCSwAAAABg4gguAQAAAICJI7gEAAAAACaO4BIAYIJV1Yuqqi12HfOtqlZV1cur6syq2lxV7+3Xt6p60eJWBwDAYhBcAgAskKo6sg/ipm5XVdXZVfWhqnpWVe2x2DVOqapd+9D0sBHbH9Y/piPGPOXvJ3lOkhOTPDnJK8c8zpJXVferqg9U1Vn9a+SnVfX+qnrCYtcGALCQVi12AQAAy9BfJ/lxkh2S7J/ksCSvSvLsqnpEa+1rA23/JslxC11gkl2THNv/+7QFON+vJjmrtfZnC3CuiVVVj03yziRfSXJ8kkuSHJzk/kmemuRti1YcAMACE1wCACy8D/z/9u4+2KqqjOP493dRc9Ti4utoNVDIaKVW1pg19gJYiE02RuRMKGNBvk0jSC9ESpBNIBrWGGNSIAg0EqP4EpWkExLiVEKmAil4BYMxBHlL4kXBpz/WOrBnc8+9517uhTPT7zNzZ9+999prrb3O+ePMM2utJyKWFM7HS+oDzAMelvS+iNgJEBF7gD0tVSapATgqInZ1Wo8738nA1sPdiTowFlgBnB8RbxRvSDr5UHVCkoCjK99DMzMzs8PBS8XNzMzM6kBE/An4EdAduLxyvbk9LvOS7EmSBklaDuwGLsr33inpbkmvStotabmkr5fbk3R0rntlXo78b0lzJfWU1APYmIuOKSxtH9uWd6r0XdLpkqZL2ippm6Rpko7JZXrk9+sNfKDQ1meq1Dld0ppqbTVz/XJJSyXtlLRZ0mxJ7y6VeVzSMknvl7RA0o68TPu7bRm3QpkGScPz2O/Kn8VkSd1qGLaewFPloCVARGwo9aVB0jBJz+V2Nkp6RNJHC2WOkDRaUlP+PqyRNE7S20p1rZE0T1I/SUuAncDV+V6jpJ/l/Ud3S3pR0sgcMDczMzPrNP6xYWZmZlY/Zubj52oo24e0D+RvgGHAGkmnAH8BLgQm5esvAlMlDa88KKkLaXbnGGAp8C3SsuSuwFmkoOW1ufgDwBX5b24732sO8HZgVP7/SvYvQ9+Y634eWFdo65/tbGsfSTcCM4BVwAjScvy+wJ8lNZaKdwMeAZ4hjcfzwARJ/Qv1tTZuFZOB24DFpM9gGjAImC/pyFa6/TLQV9K7anjFqfmd1gIjSVsK7ALOL5SZAtwM/B24AVhI+hxmN1PfGcC9wKO53//IAeaFpGD6DOD6/F7jgdtr6KOZmZlZu3mpuJmZmVmdiIh1kraRZt215gzg7IhYUbkgaQrQJV/flC/fJeleYKykyXnp72BSAG9ERBST4NwiSRERku4DfgE8GxGzDvLVno6IIYV+ngAMAUZGxH+BWZKGAns7oK1KG92BHwI3RcS4wvW5wNPAdcC4wiOnAYMjYmYuN5UURBwC/CGXaXHc8nMXAEOBQRGxbz9KSQtIgdGBtLxP5QRSQLJJ0mLgCeCPwJMR8Vahvt6kAPAdETGs8PzEQl8+SEp0NCUivpHv3ylpA/BtSb0jYkHh2dOBiyJifqGdm0jfxw9HxKp8ebKkV4DvSJoYEWtbeB8zMzOzdvOMSzMzM7P6sp00O7E1C0tBSwEDgN/m0xMrf8B80qzAc3PxAcBrwM/LlUbEAcutO8BdpfNFwAmS3tEJbVV8ifRbd05pLNaTZmD2LpXfDuwLmual2n8D3lsoU8u4DQS2AY+W2l2a2yi3W67nbtKy/8eBC4DRpPFaJekTpb4EKThbrS8X52N5ZuTEfPx86frqYtCy8D6LgC2l93mMFCT/VEvvY2ZmZnYwPOPSzMzMrL4cB2xotVTKSl50EtAIXJX/mlNJ7tITeCEn/jkU/lU635KP3YD/dFKbvQCRgpTNebN0vq6ZoO0W4JzCeS3j1osUJK72GbaaYCcHD+fnZdofAS4DrgHmSToz73XZE3glIja3UFV34C3SdgHF+tdL2prvF5W/U5De5xz273ladsgSBpmZmdn/HwcuzczMzOpE3tewK6VAUxXlbM+VlTSzgHuqPPNsO7t2sPZWua521FVtRmiX0nlDLtu/SvvbS+cd1ccGUtByUJX71QKAB4iIHaTZjoskvUbaW7M/1T/fqlXVWK65DOINpD0vb63yzMo29sXMzMysZg5cmpmZmdWPK/KxvFy3FhuB14EuEfFYK2WbgI9JOjIiyjMPKzpjyXhH2EKaWVpWnj3YRAo6ro6Ijgqu1TJuTaTkSIvzfqIdZUk+nlpop5+k41uYdfkyKfDYi0Kyo5zEqTHfb00TcFwN3ykzMzOzDuc9Ls3MzMzqgKQ+pP0MVwO/buvzEbEXuB8YIOms8n1JJxVO7wdOBL7ZTLnKDMMd+djY1r50siagq6R9S7glnQpcWio3lzSLckzhnSrllRMEtVUt4zaHNPtzdDNljmgmm3m5TN8qtyr7Vb5Q6IvYn529ub78Ph+Hl4qMyMfftdSXbA7wcUn9mmmnUZInQpiZmVmn8Q8NMzMzs0Ovv6QzSb/FTgH6AJ8lzYC7JCJ2tbPe75GSv/xV0q+AFcDxpKQ8F+b/AWaQMmTfLuk80nLkY3OZO4GHImKnpBXAZZJWApuBZRGxrJ196yizSZm3H5B0B3AMcC1pyXIl+RAR0ZQzYo8Hekh6kDQj9T2kIOcvgZ+0se1axm2hpMnAKEkfImUEf5M063EgMAy4r4U2HpK0mpRkqalQ/xeAp/J1ImKBpJnA9ZJ6kTKWNwCfBBYAkyLiGUn3AFflgOlC4DxSpvEHSxnFq7kNuIS0v+Z0UpKhY4GzgS8DPUgJi8zMzMw6nAOXZmZmZofezfn4Bikg+BxpVty0iHi9vZVGxKs5oPYDUlbt64BNwHJgZKHcXkkXAzcCXyVlqN4EPJH7UjGUlEH7p8BRpAzWhzVwGRGbJF1KypR9K2mG6ihSYPDcUtlbctD1BvbPTFxLCiY+3I62axq3iLhG0lLgamAcsAdYQ9p/dHErzQwFvgh8BTiNNKvyJeDHwIRSYqCvkfYtHUIKMG4jLSl/slTfS8CVpIDtelIw94Bs5FXeeYekTwPfJwVeB5MSKq0kjem2WuoxMzMzaw8dmDzRzMzMzMzMzMzM7PDyHpdmZmZmZmZmZmZWdxy4NDMzMzMzMzMzs7rjwKWZmZmZmZmZmZnVHQcuzczMzMzMzMzMrO44cGlmZmZmZmZmZmZ1x4FLMzMzMzMzMzMzqzsOXJqZmZmZmZmZmVndceDSzMzMzMzMzMzM6o4Dl2ZmZmZmZmZmZlZ3HLg0MzMzMzMzMzOzuuPApZmZmZmZmZmZmdUdBy7NzMzMzMzMzMys7vwPEoOFZzNIPFMAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -1026,8 +1026,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation Lissa vs direct 0.9981059078064134\n", - "Spearman Correlation Lissa vs direct 0.9948812252815075\n" + "Pearson Correlation Lissa vs direct 0.9940533986762107\n", + "Spearman Correlation Lissa vs direct 0.9942061112930448\n" ] } ], @@ -1108,7 +1108,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of Arnoldi over direct method:416.15233421325684 %\n" + "Percentage error of Arnoldi over direct method:44.838228821754456 %\n" ] } ], @@ -1134,7 +1134,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABS4AAALGCAYAAABLZg+zAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABz0ElEQVR4nOzdd5xlZX0/8M93dynSFpAO6iJ2jb1HFOwJ9mBM1Fh/1hSIRsVEY4mJGxMVY6KJUYMmsSKxZG1RQTH2gjEq9iUsTRBhkc7u8/vjnMHhMjN75067s/N+v173dfee85xzv3PL3L2feUq11gIAAAAAME5WLXUBAAAAAACDBJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcArFhVtUdV/V1Vbayqa6qqVdUdq+qI/t8vX+oatzdV9eCq+kJVXdQ/xh9c6poGVdUpVdXm4Twv73/GI+Ze1fJRVev6n/uEpa6F6+ufm1Nm0X7K34fz9T5ZKlM9Div1PbsUquqE/rFet0T3/5T+/p+yFPcPwPAElwAsK/0Xjfn6svyaJH+Y5NtJXp3kFUnOnadzM6D/gvqhJIcmeXu6x/s92zjGl8sVrP+jwsalrmMmVbXLpCD+XUtdD9uX5RoQC4EBmC9rlroAAFhCD0vyg9bawydvrKpbLVE927sHJtk5yfNba+Mc8DwpyS7zcJ6/TxfM/t88nGs5OSvJrZNcvNSFLJLHJVmbpCV5TFXdsLX28yWuaTHM1/tknKzU9ywAjC09LgFYyQ5Kcs5SF7GCHNRfn72kVWxDa+3/Wmunz8N5Lmitnd5au2w+6louWmtX9z/3SnlvPTPJ1iR/k2SnJE9e2nIWx3y9T8bJSn3PAsA4E1wCsOxNnlOv//d7quqCqrqiqr5WVQ8baD8x9K6S3G9i+Pm25n2badjqTMPiqupWfW1nVtVVVXVeVb2rqm45Rdtr5/2qqmdV1bf7n+O8qnpLVa2d5v4P6efr/GFVXV5VF1bVV6rqpdO0/fuq+klVXVlVP6+qD1fV3Wb6+ae539+uqs9V1cX9/X67ql5cVTtNanNE/3i/ot908qTH/HqP16TjTknyL/3Nf5l0zLXzok1+3Kvq8VX15ar65eTnqR9u/oH+5728qjZX1X9X1ROnu9/BoZmT5/mrbh7UDf3w4Muq6rNVde8pzjPla2LitVZV+/TP6Tn98/CdqnrqNDXt1J9v4jn7aVW9qt8+9JyFA++VW1XVB/vXyqVV9fmqevAM939c//xe1j+Gp1bVb890HwPbh35tT3rN3CTJTQae+xMmtTu8qj5SVZv6x+XcqvpSVb1smMdjrqrqdknumeTTSf46yVVJ/t8M7See+wOq6q1VdVZVbal+KoQRXxurqurZVfXV/rV/af/v51TV0P/Xr6r9q+pt/fNxeVWdVlXThrBTvU+mabdz/175WVVNOdqrqt7c/+wPm7Rtzs9tVe1YVS+tqh8Pvm+mab+t9+yUz1vf5h5VdWJf51XV/b7/p6o6KFOoqr2r6i+r6n/799TFVfWtqlpfVbtOvI+S3G9SDUN9Vg3+LFX1u1X19f5+zq6q1008BlV1//5n21xVv6iqf62qG05zzqE+O6r7/TvxPE3+fT/l66Vm91l3l+p+n/+sr+GMqnpTVR04TfubVdX7+5/t0urmWD5qW48fAOPDUHEAtic3SfKVJD9J8q9J9k43jPNDVfXA1trJfbsTkpyS7ovVGf3tJNk43wVV1UOTnJRkhyQfSfKjJIckeUySo6rqyNbaN6Y49DVJHtIf88kkRyZ5RpKbJbn/wH3cNckn0v28n+vvb5ckt0ny8iR/Mantnfvz7d0fc1KSfZI8Ksnnq+rRrbWPDvmz/VWSFye5IMm7kvwyyW8k+askD6mqB7fWrkr3uL4iyRHpvoS/I796rDdmeickuSjJI9PNjXnapH0XDbR9fpIHpXu8Tk43dHfCm5N8J91jc06SGyb5zST/WlW3bK1dL9ydwV2TvDDJF5O8NcmNk/xWkk9X1R1ba98f8jx7JvnvdEHXiel66j02yduramtr7R0TDauqknwgyVFJfphuOOsOSZ6S5LazqH2yQ/uf4dtJ/inJgeneKx+rqse31t476f53TPdauV+S05P8Q7rX19FJ3tv/3H86i/se5rW9Md1r5tj+9vGTjj+tr+uhSTYk2Zzkw+mGqO+dbpj6c/OroHwhPbO/PqG1dmFVfSTJb1XV4a21U6c5Zu8kX0r3fjkpXW/N8ybt3zNDvjZ6/5rk8UnOTPeabEkeneRNSe6T5Anb+iGqap8kX0hy0ySf7y8HJvnHdM/RyFprV1TVe9M9Vr+R7nmffN87pXvtnZfk4/22OT+3/fvmfel+f/w43ftmxyRPS/JrI/wo0z5vVfW0JG9JcmVf75lJbp4uxH54Vd2ztXbt8POqOjTd76mbJPl6ut9Rq5LcIskfp3vcL+p/zqf07Sb/zBtnUfcfpnvcP5juc+/B/X3sXVUfSjc0fkNf/72TPDHdZ8JvTD7JLD87ju+3D/6+n8psPuselu53YaV7b5yR5C5JnpPkkVV1n9baTye1v3m633M3TPKxdL87btY/Fh+boSYAxklrzcXFxcXFZdlc0n0pbwPb1k1sT/KygX0P6bd/dJpznTLF9iP6fS8f2L4xycZp6np5f8wRk7btleQX6YK92wy0v126L8DfGNh+Qn+e/0ty40nb16QL3lqSu0/avmOSn/bbHz9FXYcMnONHSa5Icr+BdgelCwfOSbLTEM/DvSbVecDAfXyk3/en23qMhrifp/THPGUbj/ulSe40TZvDpti2Y7peclcnOXhg3ylTvMYmXhPXqyXJs/rtbxrm5510nrcmWT1p+22SXJPkuwPtf69v/7kkO07avme6IHHK1/E0j8W6Sff/NwP77to/Hr9Issek7S/u2380yZpJ2/dL955oSe49xX2cMJfX9hDvuQ/0x9xhin37DPsaG/WSbr7WC9MFTDfotz2sr+lfpzlm4rF/5+THcg6vjd/t238jyW6Ttu+a5GuZ4vfCVK+XdKFVS/L6aV4TU/0+PCUD75MZHquJ3xcnTrHvsf2+187nc5suzG3pgqudJ23fO12QOdXj8PLM/J693vOWLmy8Kt3v1sHfJQ9IsiXJfwxs/0J/vhdP9fMN1Dv04zzNz3JxkltP2r5Tuj/kbEny80z6LEgXnv5Xf9wdJ22f9WfHdI/lpP0nZHafdbv19W5JcvjAuV7Ut//kwPZP9tuPGdj+yEnP6VNm+9i6uLi4uCzuxVBxALYnZyR51eQNrbVPpPtidPclqOdJ6cKll7XWvjtQ1/8m+eckd6qq20xx7CvbpB46rbVr8qth05N/loenC4o+3KZY8Ka1tmnSzaOSHJbkja21zw60Oztdz5cD0n3Z3pan9devaq1duxJ7X+fz0/VGmnbI7AJ4S2vtm1PtaK39eIptV6XrObgmw/28E/67tXbCwLa3pwuVZvMauyzJ81prWybV9N10Pe1uXVW7TWr75P76JX3dE+0vyqTetLN0cZJXTt7QWvtakn9P95p99KRdT0v3Bf95/fM70f5nk+5/Ns/1sK/tYV0+uKG1dsEI55mtx6b748R7W2sTNXw8yblJjq6qvaY57qokfzL5sRwwm9fGxPvwuNbaLye1vzRdmJNs47mpqh3S9cq8JF3YdK1Jr4k5aa19MckP0vU+3Htg98Tre7AnaTK353ZiaP2fttaumHT8hRntfTPd8/acdD2gj2mtnTVQ66fT9cB8eFXtnnRDndMFuaelm14gA8dcMLneefB3rbXvTTr/lUnemy6k3DD5s6C1tjXJv/U37zDpHPP52TFo2N8Hj0wXOr+3Xb8382vT/ZHjQVV146Qb1p6uF/5P0/W2nVzzh5J8NgAsC4aKA7A9OW3yl/1Jzkz3RXGxTdznHarq5VPsv0V/fesk3x3Y97Up2p/ZX08ORO7ZXw8z7G2inptMU8/NJ9WzreHid+6vPzO4o7X2g6ralOTQqlrbWluM1aW/Mt2O/ovsi9J9qb5xkhsMNDl4FvdzveeltXZ1VZ2X6z4v2/LD1trmKbZPfo4ngqg7pQuCvzBF+8/P4j4n+0Zr7ZIptp+SLki6U5J39GHLzZKc1aZeiGXi+b/TLO572Nf2tvx7uikXvtwPRT45XbC8aebDOlW1Z341FH2y4/tQeFsmholPhCxprV1TVf+eLrz/vSR/N8VxG/vQdzqzeW3cOd1r45Qp2n82Xe+0bT03t0o39P/Uad6rp2R+Fhx6R5K/TPI76Yaxp6r2T9cr/puttf+Z1HZOz21v4rGZ6j1yyqyrn/55m/i9er/BuR57+yVZne73/dfzq9/Zn+iDwoU21fttYoG0r0+xbyJ8PWTStvn87Bimvql+H8z0mXNNVX0u3R/x7pTuj5UTr/vPT/P/glPSzx8KwHgTXAKwPblomu3XZGkWpJtY4OAZ22i32xTbLppi20RPn9WTtu3ZX5+VbZuo57Ej1DNobX893crR56QLCfdM17tvoZ071caqumm6UHOvJKemGzp4cbpAZ126QGbKhTqmcdE026/JdZ+XuZwnA+dam+TCaXronTfFtmFMd9zE47h24Hqm5zn51etwGBdNsW2qn3tGrbWT+jnvnp+u5+GzkqSqvp5uCO5/beMUe+ZXC4hMdsI0NV6rqm6dbv7I01trX5ri+Oene99PFVxO+VqdZLr7num1cdVg4z7MuSBdcDaTied4W6+JuXpnup6OT04fXKbr6bkmA70t5+G5TX712Fw9xb5Rfqbpjpn4vfqCbRw/8Xt1z/56mN/Z82Gq37/XDLFvh0nb5vOzY9BFM9Qw+FpPhv9dtFivawAWmOASAIa3Nd3ciFPZc4ptE18K7zDQm2g+XdRfD9NrcKKeR7bWPjzH+5041wHp5osbdOBAu4XWptn+vHRfup86OMS7qn4389OTbKFtTreQxpopwsv9RzzndMcd0F9fPHB9wBRtk8V/nq+jtbYhyYaq2jXJPdLNMfmcJP9ZVXcanKJh4NiN6Rb5GMVEb8tbTbdScpLbVdW9W2uDPWWnaz+Ki9O9NnYYDOiqW8F7n3Svn22dI9n2a2JOWmubquozSR5YVbfqe/A+Od0cmlNNczHyc9ub9rHJaD/TdM/bxOO3dpqesoMu6q9n09N7qc3nZ8dcaxj2d9GivK4BWHjmuASA4f0iyf79nHCD7jrFtomeWIcvXEnX3sdvzNjqum3no56J+SSPGNxRVTdLN8zwp0MOuZ3JxBC/2fRmnOxm/fUHpti3XIYJfjPd/9nuPcW++4x4zjtPzLk34IhJ95l+OPmPkxzcr9A76Mj++hsj1rEtWzLEc99au7S19pnW2vPSrWq/Y4Z7T8xavwr276X7Q8bbk7xtissn+ubb6m09VxOvjftOse++6R67bT03p6ebV/OOVbV2iv1HzKXAASf010+uqjsmuX2Sj7XWzp/ugDk8t99I99hM9R45YhY1b8tsf69OtH9IVQ3zXWxLklTVqL8D58Monx1z/d09aKbPnDX5VW3fGGh/n2keu+udB4DxJLgEgOF9Jd1ohadO3lhVT0ny61O0/5d0vWteVlXXW3SkqlZV1RFzrOkj6RYleETfg3DwPibPU/ahdCHU71fVb051sqq6V1XtMsT9vr2/fklV7Tvp+NVJ/jbd/zHeNtRPMLOf99c3HvH4jf31EZM3VtVDsriLB83FO/vrV1XVtT1++5DppSOec22SP5+8oarumm7o7sVJ/mPSrren65n4N5MDgKraZ9L9vz0L4+dJ9q2qwXlJU1X37QOLQRM9rC5boJp+K10v3k+01p7eWvt/g5ckv51upfvfniYMnC8Tj/urJ79v+3+v72/O+D7seyP+e5LdM7A4z6TXxHw5KV0P0CcmeUq/7YTBRvP03E7MPfqXVbXzpHPvneQlQ9Y7jL9P12v09VV1i8GdVbVjVV0b+LXWvp5uvto75lcLKE1uf8PJ9WbuvwPnwyifHfNd9weTXJjkd6vqngP7jk1yaJJPTSz008+H+l/99j8YqPWRWT5/uAJY8QwVB4DhvTFdaPnmqnpAugUE7phu4YL/TDeU8VqttZ9X1dHpQqAvVdWnk3wn3ZDDG/XH3TDJ5C+ps9Jau6qqHptu7sZ3VdWz0vWO2TndQgkPSP953y8i85h0vcE2VNUX0q1se1lfz92S3DTdkLsZg4HW2heq6jVJXpjkf6vqxHRBzW8kuV26BTH+ZtSfa5Iv9rUcW1U3zK/mJXvjkIv+vCndc/b+vsaz+/oemuR9SR43DzUutHemW9Dkoeke6w+nm3/ut5J8Nckt0/X+m43PJfl/VXWPdKtVH5jusViV5FkDQ17/Nt3z+sgk36qqj6ZbzOWx6eZPfE1rbdRFgrbl0+lelx/vF9+4Msm3WmsfSTd/5MFV9d/pAuqrktwlyf2TnJHkPQtU08Qw8bdO16C1trmq3p8unHtiuhXs511r7V19CPPbSb5TVR9M9/vlUekCm/e21oZZFfxP0/2uOLYPKz+fX70mPprkEfNU7+X94/L0JM9NF25tmKLpfDy3705X/yPSvW8+lO59c3S6981hc/pheq2106vqaelC5O9U1cfTraC+Q7rQ7vAk56dbBGnCE9MtDvNXVfVb/b8r3SI3D+7bbuzbfjrde+2k/r13eZIzWmv/Oh/1D2PEz46T0/1eenVV3S7diIW01l41Yg2/7B/n9yf5bP86+r90r4sHp/tseNbAYb+f7jPk+Kp6cJJvpeuF/+h0f/R7+Ci1ALC4BJcAMKTW2ner6oHphis+PN0CAqemCyAfk4Hgsj/m01V1+yR/km713MPTfQk/O93qqFMNYZ5tXV/rh10ely5guneSS5L8KAO96lpr/1NVd0g39+PD0oV6W9MtbPDNdIuVXDDk/b6oqr6ZrjfLk9J9Uf9xut5Mr51qwZARfrZf9F/sX5YuBNq13/VvGWJexf7nPTLJq5Icle7/Pt9K93xdlGUQXLbWWlU9Ol249HtJ/jDd8/WOdMHso7LteQwH/TTJs9P1ynt2ugWKvpHkla21T0xu2IfjD0r3mnl8f//XpHscj22tvXu0n2wor0o3f+zD0/VqXp3u5/5Iuvfho9NN0/DAdK/j/+u3H99a+8V8F9P3qLtfugU/PrKN5v+c7jX7jCxQcNn73XQriF+7iE2S7yV5bZI3D3OC1toFVfXr+dXvtrsm+X66OSU3Zp6Cy94J6YLLHZK8e5rfE3N+bvv3zWPT/V58SrrfU+ek64n5yiRXzPUHmXRf/1ZV30q3mNCR6YK0S9P9nj8xyXsH2v+0qu6c7g8/j+pruyLdY/3aJJNXL39rkpuk++PFC9P9DvtskkULLpPZf3a01r5XVU9O99n33PzqD3QjBZf9OT/Uv07/NN3n6dp0geU/JvmL1trZA+1/2PfOXJ/udXREkv9J95jvG8ElwLJQrc3n/OAAACyWPlD8ZJL1rbUXD9F+XbrQ8h2ttacsbHUAADA35rgEABhzVXXQFNtumF/NY/gfg/sBAGC5M1QcAGD8va4fpvmFdPPlHZJuWoC9k/xTa+0rS1kcAAAsBMElAMD4OyndisoPTzfn4xXpFnp6W+Zn9XYAABg75rgEAAAAAMaOOS4BAAAAgLEjuAQAAAAAxo45LmepqirJQUkuWepaAAAAAGCZ2j3J2W2GeSwFl7N3UJJNS10EAAAAACxzhyQ5a7qdgsvZm+hpeUj0ugQAAACA2do9XcfAGbM1weXoLmmtbV7qIgAAAABgOelmYtw2i/MAAAAAAGNHcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYEVwCAAAAAGNHcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYEVwCAAAAAGNHcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYEVwCAAAAAGNHcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYEVwCAAAAAGNHcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYWbPUBQAAAAAAnXXHbVid5PAkByY5J8mpG9cftWVpq1oaelwCAAAAwBhYd9yGxyTZmOTkJO/qrzf221ccwSUAAAAALLE+nDwxycEDuw5OcuJKDC8FlwAAAACwhPrh4W/ob9bA7onbx/ftVgzBJQAAAAAsrcOTHJLrh5YTKsmN+nYrhuASAAAAAJbWgfPcbrsguAQAAACApXXOPLfbLgguAQAAAGBpnZpkU5I2zf6W5My+3YohuAQAAACAJbRx/VFbkhzT3xwMLyduH9u3WzEElwAAAACwxDauP+qkJEcnOWtg16YkR/f7V5RqbboeqEylqvZIcnGSta21zUtdDwAAAADbj3XHbVidbvXwA9PNaXnq9tbTcth8TXA5S4JLAAAAABjdsPmaoeIAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNhZs9QFAAAAADB+1h23YXWSw5McmOScJKduXH/UlqWtipVEj0sAAAAArmPdcRsek2RjkpOTvKu/3thvh0UhuAQAAADgWn04eWKSgwd2HZzkROEli0VwCQAAAECSa4eHv6G/WQO7J24f37eDBSW4BAAAAGDC4UkOyfVDywmV5EZ9O1hQgksAAAAAJhw4z+1gZIJLAAAAACacM8/tYGSCSwAAAAAmnJpkU5I2zf6W5My+HSwowSUAAAAASZKN64/akuSY/uZgeDlx+9i+HSwowSUAAAAA19q4/qiTkhyd5KyBXZuSHN3vhwVXrU3X85epVNUeSS5Osra1tnmp6wEAAABYCOuO27A63erhB6ab0/JUPS2ZD8Pma4LLWRJcAgAAAMDohs3XDBUHAAAAAMaO4BIAAAAAGDuCSwAAAABg7AguAQAAAICxI7gEAAAAAMbOmqUuAAAAAADGzbrjNqxOcniSA5Ock+TUjeuP2rK0Va0selwCAAAAwCTrjtvwmCQbk5yc5F399cZ+O4tEcAkAAAAAvT6cPDHJwQO7Dk5yovBy8QguAQAAACDXDg9/Q3+zBnZP3D6+b8cCE1wCAAAAQOfwJIfk+qHlhEpyo74dC0xwCQAAAACdA+e5HXMguAQAAACAzjnz3I45EFwCAAAAQOfUJJuStGn2tyRn9u1YYIJLAAAAAEiycf1RW5Ic098cDC8nbh/bt2OBCS4BAAAAoLdx/VEnJTk6yVkDuzYlObrfzyKo1qbr+cpUqmqPJBcnWdta27zU9QAAAAAw/9Ydt2F1utXDD0w3p+WpelrOj2HzNcHlLAkuAQAAAGB0w+ZrhooDAAAAAGNHcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYEVwCAAAAAGNn2QeXVfX7VbWxqq6oqi9X1d1naPuUqmoDlysWs14AAAAAYNuWdXBZVY9L8rokr0hy5yTfSvKJqtpvhsM2Jzlw0uUmC10nAAAAADA7yzq4TPK8JP/cWvuX1tp3kzw7yWVJnjbDMa21du6ky3mLUikAAAAAMLRlG1xW1Y5J7pLkUxPbWmtb+9v3muHQ3arqjKo6s6o+VFW33cb97FRVe0xckuw+H/UDAAAAANNbtsFlkn2SrE4y2GPyvCQHTHPM99P1xnxkkiem+/m/UFWHzHA/L05y8aTLpjnUDAAAAAAMYTkHl7PWWvtia+2drbXTWmufTfKYJOcnedYMh706ydpJl5lCTgAAAABgHqxZ6gLm4IIkW5LsP7B9/yTnDnOC1trVVfXNJDeboc2VSa6cuF1Vs68UAAAAAJiVZdvjsrV2VZKvJ3nAxLaqWtXf/uIw56iq1Ul+Lck5C1EjAAAAADCa5dzjMklel+QdVfW1JF9JcmySXZP8S5JU1TuTnNVae3F/+8+TfCnJj5LsmeQFSW6S5K2LXTgAAAAAML1lHVy21t5bVfsmeWW6BXlOS/LQ1trEgj03TrJ10iF7Jfnnvu0v0vXYvHdr7buLVjQAAAAAsE3VWlvqGpaVqtoj3eria1trm5e6HgAAAABYTobN15btHJcAAAAAwPZLcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYWdarigMAAADLy7rjNqxOcniSA5Ock+TUjeuP2rK0VQHjSI9LAAAAYFGsO27DY5JsTHJyknf11xv77QDXIbgEAAAAFlwfTp6Y5OCBXQcnOVF4CQwSXAIAAAALqh8e/ob+Zg3snrh9fN8OIIngEgAAAFh4hyc5JNcPLSdUkhv17QCSCC4BAACAhXfgPLcDVgDBJQAAALDQzpnndsAKILgEAAAAFtqpSTYladPsb0nO7NsBJBFcAgAAAAts4/qjtiQ5pr85GF5O3D62bweQRHAJAAAALIKN6486KcnRSc4a2LUpydH9foBrVWvT9dJmKlW1R5KLk6xtrW1e6noAAABgOVl33IbV6VYPPzDdnJan6mkJK8uw+ZrgcpYElwAAAAAwumHztTWLVxIAAAAwE70RAX7FHJcAAAAwBtYdt+ExSTYmOTnJu/rrjf12gBVHcAkAAABLrA8nT0xy8MCug5OcKLwEViLBJQAAACyhfnj4G/qbNbB74vbxfTuAFUNwCQAAAEvr8CSH5Pqh5YRKcqO+HcCKIbgEAACApXXgPLcD2C5YVRwAAACW1jnz3G5WrGQOjCs9LgEAAGBpnZpkU5I2zf6W5My+3byykjkwzgSXAAAAsIT63o3H9DcHw8uJ28fOdy9IK5kD405wCQAAAEts4/qjTkpydJKzBnZtSnJ0v3/eWMkcWA4ElwAAADAG+nByXZIjkzy+vz50vkPLnpXMgbFncR4AAACYB/OxyE3f/pT5r+56rGQOjD3BJQAAAMxRPx/kG9L1Ypywad1xG45ZoB6TczWnlcytRA4sBkPFAQAAYA6W6SI3I69kbiVyYLEILgEAAGBEy3WRm1FXMl+mIS2wTAkuAQAAYHTLdpGb2a5kvlxDWmD5ElwCAADA6Jb1IjezXMl82Ya0wPJkcR4AAAAY3ZwWuRkHs1jJfFmHtMDyo8clAAAAjG7kRW6WoWUf0gLLi+ASAAAARjTqIjfL1EoKaYExILgEAACAOZjtIjfL1QoLaYExUK1N94cSplJVeyS5OMna1trmpa4HAACA8dCvpn14ujkez0ly6vYY4q07bsNj0q0ufsikzWemCy23i5AWWFjD5muCy1kSXAIAALDSrZSQFlgYgssFIrgEAAAAgNENm6+Z4xIAAAAAGDuCSwAAAABg7KxZ6gIAAACA2THHJLAS6HEJAAAAy0i/qvfGJCcneVd/vbHfDrDdEFwCAADAMtGHkycmOXhg18FJThReAtsTwSUAAAAsA/3w8Df0N2tg98Tt4/t2AMue4BIAAACWh8OTHJLrh5YTKsmN+nYAy57gEgAAAJaHA+e5HcBYs6o4AADAdsaK09utc+a5HcBYE1wCAABsR/rFWd6QbkjxhE3rjttwzMb1R520RGWNnWUa7p6aZFO6hXimGy6+Jck+i1YRwAIyVBwAAGA7YcXp4fSPw8YkJyd5V3+9cdwfnz5YPaa/2aZptirJ+8b9ZwEYRrU23e86plJVeyS5OMna1trmpa4HAAAgubYH4cZM3xuvpeutd+gy6Fm4YNYdt+HoJO+fYtfEl+Ojx71nav8zvCfJdKuHe66BsTZsvqbHJQAAwPbBitPbMCnwm8rE43Z8HwKPswsyfWiZeK6B7YQ5LgEAALYPK2LF6VHnpuyHTr8v0we7yXUDv1PmXOzCWRHPNYAelwAAANuH7X7F6VHnpuzDzjfM4q7uP+a9Lrf75xog0eMSAABge7GtFacn5j08dTGLmi+TFh4aNLHw0LVzU07RK3NVrrvK+ra8NMlTx3gl9kV/rpfpKuzAMmdxnlmyOA8AADCuBsK9yYHW2C88M1MwNpuFh5I8Ml3vyslB5YVJ9p5lSWP9mC3mc93f1+BjuinJuAa7wJizOA8AAMAK04dIRyc5a2DXpoxpAJcMNQR82IWH/jRdmHfwwP69RihrrBfrWaznelJAOviYTvR0nXGYPsBc6HE5S3pcAgAA4245Desdpudgkp3SBZrbcmG6kHKmBXhGceTG9UedMs/nnBcL+VzPpqfruL6+gPE0bL5mjksAAIDtTB8inbLUdWzLwKI5g8FYpQvGjk/ylCFPOcxw8DbFfW3Lgq3OPdfgcYGf64mertNZLquwA8uUoeIAAAAslWGHgCddz77phgy2JD8f8j5H6Y25IKtzj7pK+iIaNrBdsGAXWNkElwAAACyVYQOv/ZMc0/97MLycuP2GzF4buJ5q/5lZgJXYl8nckcMGtgsS7AIILgEAAFh0/RDp/Ydsfs62FqNJ8leZuVfmVCaGo09cTzZx+9j5nr9xiCHyyXgsCnRqtt3TdUGCXYBEcAkAAMAimzRE+vXbaHqdYKwPL9clOTLJ4/vrQyetoP2WzH4o+ET7Cwa2L+RK7MMOkT98Ae57aH1gu62ervMe7AJMsDgPAAAAi2ZgFfGZTBmMTbUYTX/ON2TmhWS25dgkZ2dgkZwFWrV72cwduXH9USetO27D0bn+47sp3XOzEMEuQBLBJQAAAItkG0OkBw0VjM0iCN2WszeuP+qUKc59vcBu3XEbjpljYLes5o7sw8sPZf4DXIAZCS4BAABYLBNDpLflj5O8cVvB2CyD0Om0dCHpdeZpnCEQnVg8Zy7DyCfmjjw4U9c9ZU1LaaqergALrVqbzbzFVNUeSS5Osra1tnmp6wEAAFgqsx1Gve64Db+b5F1DnPoJmWLY9hT3e/8kLx35B/jVcPTrhJD9+Tdm28HioaP2OhwIRiffx5Q1AWxPhs3XLM4DAADArE1aYOfkdGHkyUk29tsnt1u97rgNR/Sh5bCriB8/3XkH7ncuoWUy/QI8C754zrZWSRdaAuhxOWt6XAIAACtdv1jL+/qb0/YWnGaOyC3pOtHMNLS7TXPev0nyginudxgT53hZkh9lhh6is+gZ+viN64969yzrGLyvhVj8B2CsDZuvmeMSAACAofWh5XsydXBY6QLC49cdt2FVfhVuTrZqUruZejROdd7nT7N/GLNZBXvRFs8xdyTA9ASXAAAADNXzr+9B+f5tnGpiGPWbJt0e3D9TaDnTeVfPov1ED8vjk3w4s+vJuOwWzwHYHhkqPkuGigMAAMvNtkLJaYZ0n5/k39KHfv22jRluVfBxcGaG72F5PRbPAVg4w+ZrgstZElwCAADLwaSw8hFJnphk30m7NyU5ZtI8lFMFdBlo/5Ykr1ygcufTXyT5TOZhrshpAt05BaIACC4XjOASAABYDHNZtGWawG2yiS+Cv53k9Zl+SPRg+2GGd7d0vTX3G6LtbLQkWzP9wj4Tw7cPnc/FbSyeAzD/BJcLRHAJAAAstGmCx2t7SQ5x7LZ6UCYLGzBuKxDdVgg5Vftk+lXFDd8GWEaGzddWLV5JAAAAbMuk4PHggV0HJzmx3z/dsavTBZ7JtgPByvyHlklyYZK7JbnBNDVMhIyvHbg9uH+yTelCyRclOTrJWdPsF1oCbEcElwAAAGNiG8HjxO3j+3ZTOTxdL83Zrtg9n/ZO8sIkN5xm/8+z7RDysUmOTPL4/vrQiVCyv1433X4Ath9rlroAAAAArjURPE6nktyob3fKFPsPHOE+z0+yT+Yv7NzW8PTLk3wo6ULIdcdt+FBmOYdkv/+UeakWgLEluAQAABgfwwaPByZTLhxz3izua2Ixm+cleV9/e6F7al4veBVCAjAdQ8UBAADGxznDtuvnutyY5OQk7+qv3zfk8RPzSB67cf1RJ2bqIdsLaZSeoQCsMIJLAACA8XFqul6QUy1Qk377memGdk+1gM9080oOus5iNpPmjXz7LOsd1bABLQArmKHiAAAAi2CKYd3Xm8tx4/qjtqw7bsMx6ULJwaHbE2Hm85K8vv/3KEO7n5fkW0n2X3fchiMG6njwCOebjYnh6acu8P0AsB2o1qb7Qx5Tqao9klycZG1rbfNS1wMAAIy/flj3G3LdhXc2JTlmqtWwp2l/ZpJjk1yYblj4qC5Mt/L3deqYh/NOmAhcpwtej7YCOMDKNmy+Zqg4AADAAupDyKmGdR+c5MR+/3VMGrp9ZJLH99eH9tvnOj/k3gO3D0nygSSPmON5J2xK8ppcf87M6wxPB4Bt0eNylvS4BAAAhtUPD9+YLqScalj3xNDpQweHjc9wziMyPz0jB12cZO0Ix030rHx9kg+nH3o+zNB4AFamYfM1c1wCAAAsnMNz3eHegyrJjfp2pwx5zokFfKYLQ0e1Nsn56Rb+mS5k3Zzkklx/yPuxgz0p+5DylHmsD4AVRnAJAACwcIYd1n2ddn1vxSOT/F6S3ZJ8Psmbktyrb/uWJK/I9eeRnKtTkhw9xXknhuo9LcmHoiclAItAcAkAALBwzpltu37OyxOS7D5p/2OSvG7gmM1Jrk5ywznUN+j0dMHlVAsJTe5Veco83icATElwCQAAsHC2Nay7pRuefVA/d+U+Sd4/5Ln36K+/neR205x/tk7ZuP6oz6w7boNelQAsOYvzzJLFeQAAgNmYtKp4cv3h14Nh45YkqxejrilcnOSGAkoAFtqw+dqqxSsJAABg5emHVx+d5KyBXZVfzR05YalCyyR5u9ASgHEiuAQAAFhgfXi5Lt2CO09INzx8vhfWmasPL3UBADCZ4BIAAGARbFx/1JaN6486JcnZSfbN+ISWLcmZ6ebjBICxIbgEAABYXI9cwvseHJo+cftYw8QBGDeCSwAAgEWy7rgNf53k2CUs4RcDtzclObofyg4AY2XNUhcAAACwEqw7bsPRSV44RNPWXxaio8ljk2xNcmCSc5KcqqclAONKcAkAALDA1h23YXWSNw3ZvJK8IcmeSZ48adtctHS9Kz8rqARguRBcAgAALLzD0y3IM6xj++uf99c3HOKYzUl27/89Oeg0jyUAy5LgEgAAYA7WHbdhpySvT/Kb6QLDj6YLCa+c1OzAEU+/d3/950n2SvLH6YLIqYLJp/bXb0hyyKT9m/p6zGMJwLJSrQ0uKre8VNXvJ3lBkgOSfCvJH7bWvjJD+8cm+Ysk65L8MMmLWmsfncX97ZHk4iRrW2ub51A6AACwzPRDvg9PcnCSX0/y25m+N+QHN64/6tH9cUckOXnEu50Y5n1ouhXJB4PJMzMpmJxUo3ksARhLw+Zryzq4rKrHJXlnkmcn+XK64RSPTXLL1trPpmh/7ySfS/LiJP+Z5PFJXpTkzq21/x3yPgWXAACwAvWL67wpsxvy/cGN6496dB8mbkwXeI46X+WRG9cfdYpgEoDlbqUEl19O8tXW2h/0t1el+2vjG1tr66do/94ku7bWHjZp25eSnNZae/aQ9ym4BACAFWAgIHx4kt8d8VQ7b1x/1JXrjtvwmCQn9ttGCS8fv3H9Ue8esQYAGBvD5murFq+k+VVVOya5S5JPTWxrrW3tb99rmsPuNbl97xMztE9V7VRVe0xc8qvJrgEAgO1UHzJuTDe8+10ZPbRMktcmST+U++gkZw3s/8WQ5zlnDjUAwLKzbIPLJPskWZ3kvIHt56Wb73IqB8yyfdINK7940mXTrCsFAACWjUk9Iw/ZVtsh/frEP/rwcl2SI9NNXXVkkv3Tfc+YbjhcSzey7NR5qgcAloWRVxWvqhsn+dN0H7T7JnlUa+1zVbVPuhXv/qW19s35KXNJvTrJ6ybd3j3CSwAA2C71w8PfktHnoZzKLdcdt2H1xDyU/fUpA/d7TLqwdLoVw481jyUAK81IwWVV3SbdX/tWpVsU52YT52qtXVBV90mya5Knz1OdU7kgyZZ0f52cbP8k505zzLmzbJ/W2pVJrpy4XTWf/38BAACWylSL3KTrnDHdKuGjukF/P6dM12Dj+qNO6hf/GVwxfFMmrRgOACvJqEPFX5PkoiS3SPLEXP+vkRvSfTAvmNbaVUm+nuQBE9v6xXkekOSL0xz2xcntew+aoT0AALAdmmIOy5P72y9YoLs8cFsNphlGfqjQEoCVatSh4vdN8srW2vlVNdVfI/8vycGjlzW01yV5R1V9LclXkhybrqfnvyRJVb0zyVmttRf37d+Q5LNV9fx04ervJLlrkmcuQq0AAMACmqoH5VTDq/vQ8gNTnGK+5rScylAL60w1jBwAVqpRe1yuSnLZDPv3zaTh1QultfbeJH+S5JVJTktyxyQPba1NLMBz40z6y2Zr7Qvp/nL5zCTfSrei36Naa/+70LUCAAALZ7oelP32ye0m5rBcLBbWAYARVWvTLVw3w0FVn0tySWvtqL7H5flJHtha+0xVrUnyjSSbWmu/Ob/lLr2q2iPd6uJrW2ubl7oeAADYXs2yB+WJ/c2pFrY5emK49brjNtw/yacXrOjrut79AwDD52uj9rh8dZKHVtWbk9yu37Z/VT0wySeT3DrJ+hHPDQAArHCz7EH5hv7m4Nz7ldZyq5/99O8v32Gnw1N129VbtxyxgGVfNHB7U4SWADCykXpcJklV/V66/yCsTfcfhNZfb07ynNbau+eryHGixyUAACysWfagPCJdqHkdq7duye+e9vE8+Rv/mZv//Mxrt//8Bmt//vf3/u0b/uudjso1q2ec8n/i+81sPCHJ2dlGD1EAWOmGzddGDi77O9k13arcN0/Xe/PHST7RWrtk5JOOOcElAAAMb9jh3gPtN6Zb7HOq4LCl68l46Mb1R21Zd9yG303XI/Naa7Zckzd9aH0e8KOv5OO3uFfed/sH56w99s3dNn33A0847WM3veX5G+/0hZvcIc98zEty5Zodpyvl/HRz98/GkRvXH3XKLI8BgBVn2Hxt1quKV9Uu6SaXXt9a+5skHxy1SAAAYPvV95x8Q667WvemdcdtOGaG4dOHZ+bVvSvJjfp2p2SK1bpf9NkTcsSPv5an/9ZLc8phd7t2+4/2ufFvvfuOD829zvhW/uXEV+TPP/2W/NlD/mCq+7ggXXD66+kC1/OSvCPbDlMtwAMA82jWc1y21i5Lck2SS+e/HAAAYHswabj3wQO7Dk5y4uBclZMcOORdTLQ7NV1o2JJkjyt+mSec9rG86V6PvU5oOdkXb3KHvO4+T8jR3/5UbnjpRYO7W5JnbVx/1NUb1x91ysb1R7174/qjPpPkmEn7B9snybGGhQPA/Bp1cZ4PJDm6qmY75wsAALCd2+aCOZ3j+3aDrteDchrnJEkfFk6EinnY6admhy3X5N/v+BszHvy+2z8orVblUd89ZfLmMzPNYjr9tqOTnDWwywI8ALBARg0u35NkvyQnV9UTqurXq+rOg5d5rBMAAFg+JoZ7T9fRYfJw70HX6UE5hZYuYLx2WHYfGr4sSW500Xk5e499c/5ue89Y4EU32CM/3eug3OiicydvfspMAWS/b12SI5M8vr8+VGgJAAtj1nNc9k6Z9O+p/rMxscr4VH9BBQAAtm/DDve+/7rjNlxnsZ5+wZ1j0g0zH1zZe6Zh2X+V5JnXrFp9yE7XXJW0lmxjgNjO11yZq6+7svj+2yq4v99TttUOAJi7UXtcPnXS5WlTXCa2AwAAK8+ww71fmmTj4HyXowzLnhgy/o2Db9UO+OWFueM5P5jxjm/1s5/m0F+ck28cdKtR6gYAFkG1Nt0IDKYy7HLtAACwUvVzV27M9KtwTzbxheR6gWR/nsPT9eA8J8mp21oA55bPP+noz7z12e/57n6Hrn7mY16SVlP01Wgtb/zwa3L3Td/Jrz/77blm9ZqJVcEPtcAOACy8YfO1OQeXVbVbuvlpkuTM1tov53TCMSe4BACAbZu0qngyXHg5b8HhVat3OHrHrde8/79vfPv/ffaj/+y2l+y867U17HrlZXnh596RJ39jQ4592PPzwdseOW1wCgAsjAUPLqvqbklek+Q++dWQ863pJsl+YWvtayOdeMwJLgEAYDh9ePmGdAv1DOPIjeuPOmVe7rzqSUneek2t2vrRW91ny0/3OniXAy65IL/5/c/nBldfmT9/8HPyrm7l8TPTzZkptASARbKgwWVV3SPdhNRXJXlXku/1u26d5HeT7JjkiNbaV2Z98jEnuAQAgOH1w71flm4+y215/Mb1R7173u686qAk/68lR1+1eocDL99hpyvOXLv/KW++52P/86O3us+qDDn8HACYXwsdXH4qybok92mtnTuwb/8k/53kp621B8365GNOcAkAALOz7rgNRyQ5eYim89fjEgAYW8Pma6OuKn6PJP80GFomSWvtvCRvSXLPEc8NAABsX05NN4fldL0mWroh26cuWkUAwNgbNbjcmmTNDPtX920AAIAVrh+KfUx/czC8nLh9rCHbAMBkowaXX0jy+1V1k8EdVXXjJM9NN1wcAAAg/eI3Ryc5a2DXpljRGwCYwqhzXN4pyefS9br8jyQ/6HfdMskjk1yT5PDW2rfmqc6xYY5LAAAYXb9Yz+FJDozFcQBgRVrQxXn6O7hNkr9M8qAku/SbL0vyySQvaa19d6QTjznBJQAAAACMbth8baZ5KmfUB5OPrqpVSfbtN5/fWjO3JQAAAAAwJyMHlxP6oPK8eagFAAAAACDJiIvzVNWrquq0GfZ/s6peNnJVAAAAAMCKNuqq4kcn+dgM+z+a5HEjnhsAAAAAWOFGDS5vnOTHM+z/aZKbjHhuAAAAAGCFGzW4/GVmDiYPTXLFiOcGAAAAAFa4UYPLU5I8q6oOHtxRVTdK8swkJ8+hLgAAAABgBavW2uwPqrplkq8kaUneluQ7/a7bJXlakkpyz9ba9+apzrFRVXskuTjJ2tba5qWuBwAAprLuuA2rkxye5MAk5yQ5deP6o7YsbVUAAMPnayMFl/0d3D7JG9P9Z2iyzyX5o9ba/4x04jEnuAQAYNytO27DY5K8IckhkzZvSnLMxvVHnbQ0VQEAdBY8uJx0R/skuWl/8yettQvmdMIxJ7gEAGCc9aHlif3NmrRr4j/+RwsvAYCltGjB5UojuAQAYFz1w8M3Jjk41w0tJ7R0PS8PNWwcAFgqw+ZrQy/OU1UHVNV9q2q3ge07VNUrq+rHVXVZVX2jqh4xeukAAMCIDk83PHyq0DL99hvl+tM9AQCMndmsKn5ckvcnuWpg+2uTvCTJXukW6bllkg9U1X3npUIAAGBYB85zOwCAJTOb4PJ+ST7SWrs2uKyqfZM8N8l3k9y0tXa3JLdJcn6S589noQAAwDadM8/tAACWzGyCyxul61E52cP6c/xta+2iJGmtnZHkX5LcYz4KBAAAhnZqujksp5vIviU5s28HADDWZhNc7pzklwPbDk/3n59PD2z/cbqh4wAAwCLpF9w5pr85GF5O3D7WwjwAwHIwm+Dyp0nuOLDtyCRntNbOHNi+W5IL51AXAAAwgo3rjzopydFJzhrYtSnJ0f1+AICxN5vg8qQkT66qx1XVjarqz5LcJMn7pmh7zyQ/mY8CAQCA2enDyXXpOho8vr8+VGgJACwn1dp0098MNKzaNd1cOHdMN8ykknw/yd1ba5dManfDJGck+ZvW2ivmu+ClVlV7JLk4ydrW2ualrgcAAAAAlpNh87U1w56wtXZpVd09yaOT3DRdOPnB1toVA00PTvKyJCfOumoAAAAAgMyixyUdPS4BAAAAYHTD5muzmeMSAAAAAGBRCC4BAAAAgLEjuAQAAAAAxo7gEgAAAAAYO4JLAAAAAGDszDm4rKoDq+oOVbXrfBQEAAAAADBycFlVj6yq05NsSvKNJPfot+9TVd+sqkfNT4kAAAAAwEozUnBZVQ9PclKSC5K8IklN7GutXZDkrCRPnY8CAQAAAICVZ9Qel3+e5HOttfsk+Ycp9n8xyZ1GrgoAAAAAWNFGDS5vl+R9M+w/L8l+I54bAAAAAFjhRg0uL0sy02I8N03y8xHPDQAAAACscKMGlycneXJVrRncUVUHJHlGkk/OpTAAAAAAYOUaNbj8sySHJPlqkmclaUkeUlWvSvLtdIv1vGJeKgQAAAAAVpxqrY12YNVtk7whyZGZtKp4klOS/H5r7Xtzrm4MVdUeSS5Osra1tnmp6wEAAACA5WTYfO16Q72H1Vr7TpIHVtVeSW6WrvfmT1pr5496TgAAAACAZA7B5YTW2i/SDRkHAAAAAJgXI81xWVV/VFWfmGH/x6rqOaOXBQAAAACsZKMuzvP0JN+dYf93kzxzxHMDAAAAACvcqMHlYUlmWnzn9L4NAAAAAMCsjRpcXpXkgBn2H5hk64jnBgAAAABWuFGDyy8leUpV7T64o6rWJnlq3wYAAAAAYNZGXVX8FUk+m+S0qjo+yXf67bdLcmy6HpePn2txAAAAAMDKNFJw2Vr7clU9PMk/JXlDktbvqiQ/TfKI1toX56dEAAAAAGClGbXHZVpr/1VVN0typ/xqIZ4fJ/lGa61NfyQAAAAAwMxGDi6TpLW2NcnX+wsAAAAAwLyYU3BZVbdJctMke6UbJn4drbV3zuX8AAAAAMDKNFJwWVWHJfm3JHfPFIFlryURXAIAAAAAszZqj8t/SvJr6VYQPzXJL+arIAAAAACAUYPLX0/yV621N85nMQAAAAAASbJqxOMuSHLxfBYCAAAAADBh1ODyH5M8sapWz2cxAAAAAADJ6EPFf5BkdZJvVdXbk5yZZMtgo9baSXOoDQAAAABYoaq1NvuDqrYO0ay11ra7HplVtUe6YfJrW2ubl7oeAAAAAFhOhs3XRu1xeeSIxwEAAAAAbNNIwWVr7bPzXQgAAAAAwIRRe1wmSapqpyR3TrJfkv9urV0wL1UBAAAAACvaqKuKp6r+KMk5ST6f5KQkt++371NVF1TV0+anRAAAAABgpRkpuKyqpyY5PsnHkzw9SU3s63tdfibJ78xDfQAAAADACjRqj8vnJ/lQa+3xST4yxf6vJ7ntyFUBAAAAACvaqMHlzZJ8bIb9Fya54YjnBgAAAABWuFGDy4uS7DPD/tskOXfEcwMAAAAAK9yoweVHkzyzqvYc3FFVt03yjCQfnkNdAAAAAMAKVq212R9UdVCSL6dblOcjSZ6Z5N+SrE7yW+lWG797v1DPdqWq9khycZK1rbXNS10PAAAAACwnw+ZrI/W4bK2dneQu6VYVf1y6APP3kjw8ybuT3HN7DC0BAAAAgMUxUo/L652kat90Iej5rbWtcz7hGNPjEgAAAABGN2y+tmY+7qy1dv58nAcAAAAAIBkxuKyqPx+iWWut/cUo5wcAAAAAVrZRF+eZaTh4SzfnZWutrR61sHFlqDgAAAAAjG6hF+dZNXhJ13vzsCSvT/K1JPuNcm4AAAAAgJGCy6m01ra21n7aWvuTJD9M8sb5OjcAAAAAsLLMW3A54HNJfnOBzg0AAAAAbOcWKri8a5KZ5sEEAAAAAJjWqKuKP2maXXsmuW+SxyR564g1AQAAAAAr3EjBZZITZth3QZL1SV454rkBAAAAgBVu1ODy0Cm2tSS/aK1dMod6AAAAAABGCy5ba2fMdyEAAAAAABMWanEeAAAAAICRDdXjsqq2phsKPhuttTbqUHQAAAAAYAUbNlh8ZWYfXAIAAAAAjGTY4PKkJGe01i5eyGIAAAAAAJLh57j8ZpKjJm5U1Weq6gELU9Jwqmrvqvr3qtpcVRdV1duqardtHHNKVbWByz8uVs0AAAAAwHCGDS4vT7LLpNtHJNl/3quZnX9PctskD0rysCT3TfKWIY775yQHTrq8cKEKBAAAAABGM+xQ8W8leV5VbUkyMVz8blV1xUwHtdZOmktx06mqWyd5aJK7tda+1m/7wyQfrao/aa2dPcPhl7XWzl2IugAAAACA+VGtbXvNnaq6a5ITk9y439SS1DYOa6211XMrb9p6npbkta21vSZtW5PkiiSPba39xzTHnZKul2YlOTfJR5L8RWvtshnua6ckO03atHuSTUnWttY2z/FHAQAAAIAVpar2SNc5csZ8bagel621r1XVzZIclm6I+ClJ/jLJp+Ze6kgOSPKzyRtaa9dU1YX9vum8K8kZSc5Ocvskf53klkkeM8MxL07ysjlVCwAAAADMyrBDxdNauybJ95N8v6rekeQ/W2tfns9iqmp9khdto9mtRz1/a23yHJjfrqpzkny6qg5rrf14msNeneR1k25P9LgEAAAAABbI0MHlZK21p853Ib3XJjlhG21+km6Y936TN/ZDxffu9w1rIni9WZIpg8vW2pVJrpx0P7M4PQAAAAAwipGCyySpqr2S/G6SmybZK9ef87K11p4+m3O21s5Pcv4Q9/3FJHtW1V1aa1/vN98/3Srps+kFesf++pzZ1AkAAAAALKyRgsuqeki6xXp2TbI5yS+maLbtVX9G1Fr7XlV9PMk/V9Wzk+yQ5O+TvGdiRfGqOjjJp5M8qbX2lao6LMnjk3w0yc/TzXH5+iSfa639z0LVCgAAAADM3qg9Ll+bbkj2Y1pr357HembjCenCyk8n2ZrkA0n+aNL+HdItvLNLf/uqJA9Mcmy6wPXM/phXLU65AAAAAMCwqrXZd4ysqiuSvKC19sb5L2m8DbtcOwAAAABwfcPma6tGPP8P062uDQAAAAAw70YNLl+S5LlVtW4eawEAAAAASDL6HJcPSLf69/eq6r/SzRe5ZaBNa60dM5fiAAAAAICVadQ5LrcO0ay11lbPvqTxZo5LAAAAABjdsPnaSD0uW2ujDjEHAAAAANgmASQAAAAAMHYElwAAAADA2Bl6qHhV/c8sz91aa3eY5TEAAAAAALOa4/LCJLNfyQcAAAAAYJaGDi5ba0csYB0AAAAAANcyxyUAAAAAMHYElwAAAADA2BFcAgAAAABjR3AJAAAAAIwdwSUAAAAAMHYElwAAAADA2BFcAgAAAABjZ80wjarqp0m2JrlVa+3q/nbbxmGttXbYXAsEAAAAAFaeoYLLJJ9NF1RuHbgNAAAAADDvqjX542xU1R5JLk6ytrW2eanrAQAAAIDlZNh8zRyXAAAAAMDYGXaOy/uOcvLW2udGOQ4AAAAAWNmGnePylFx3TsvKcHNcrp5tQQAAAAAAwwaXRw7c3inJa5LskuQtSb7fb79VkmckuTTJC+ejQAAAAABg5RlpcZ6qel2S+yS5b2vtioF9u6RbdfxzrbXnz0uVY8TiPAAAAAAwuoVenOcJSf51MLRMktbaZUn+NckTRzw3AAAAALDCjRpc7prkwBn2H5huGDkAAAAAwKyNGlx+KskxVfWYwR1V9VtJjunbAAAAAADM2qhzXB6c5DNJbpbknCQ/6ncdluSgJD9Ocv/W2qZ5qnNsmOMSAAAAAEa3oHNcttbOSnKHJM9L8r9J9u8v30nyx0nusD2GlgAAAADA4hipx+VKpsclAAAAAIxuoVcVBwAAAABYMGuGaVRVnxnh3K219oARjgMAtmdVt0k3L/bVSb6R1n62xBUBAABjaNgel6uS1CwvenMCAL9S9ahUfTHdnNgfTvKxJJtS9a5U3WppiwMAAMbNUD0uW2tHLHAdAMD2rOpFSdYn+cxVq9Yc/ZxHv7htrVUHP+dLJ97ybpu+85uVfClVD01rX1rqUgEAgPFgcZ5ZsjgPAMxS1UOSfDzJq276gg99c+uq1W9IcsjE7t2v+OVZn/nnZ1+y72UX3TDJYWntkqUqFQAAWHjD5mtzCi6r6n5Jjkpyk37TGUk2tNY+O/JJx5zgElixqvZJcvMkLcn309ovlrgilouqTyTZ86Yv+NBfb121+sSJrZNatAM3n5//fvNT26rkD9Lam5egSgAAYJEs6KriVbVjVX0gyWeS/EmSB/WXP0nymao6sap2GOXcAIyZqjul6j1JzknyhSRfTHJOqt6RqlsvbXGMvaqDkjz46lWr/7HvaZlcN7RMkjpnj33z2Zve9cqWPHWRKwQAAMbUqAvovCzJo5O8NsmBrbW9W2t7Jzkgyd8meUySP5+fEgFYMlUPTxdU3vmaWvWCVx/x1Ke98Df+6LivH3SrE1pyvyRfSdURS1oj4+6QJDn+1x+/uv/3YGg5ob550C1vcPXqNYctWmUAAMBYG2pxnik8Psk7WmsvnLyxtfazJC+qqv2T/F6Sl86xPgCWStUtkrwvyYY7/+G/v/fCXda+Nn0I9b7bPzi7XHX5WZ/+52f/+MBf/vxDqbp1Wjt7SetlXF2RJFtWrTpkWw13veryXL1qzZYdF74mAABgGRi1x+WBSb48w/4vp+t9CcDy9YdJNt/9ue94/4W7rH1PkoMn77xsxxsc9JCn/8Ptr1m1esckz1qSClkOTk/ys6O//enbz9Ro1dYtOer0z+fnu6z9xiLVBQAAjLlRg8tNSY6YYf/9+jYALEdVa5I8aUvV2362+w3/ZmLrYKvNO++Wk2575DUtefoiV8hy0dpVSd562IWbHrjuwrPOSbe40/Uc/b+fbods/ln2ueyily1ugQAAwLgaNbh8R5Lfrqp/rKpbVtXqqlrV//vNSR6b5IR5qxKAxbZ3kj0+fOv7XZptzEv41UNuu1slB8eibEzvdZWc99ET/mjNXc/8TtLateHljtdcnd/7xob2l5/4h/rBDW/0mV2uumKmER0AAMAKMuocl3+V5LAkz0zyjCRb++2r0n25fUffBoDl6eokuXyHnfbfVsOdtlydlrRKtix8WSxLrf08Vfff5eorP3ziu1607/f3ufHVXzvkNjvseM01OfInX80+l11cp+97k0/e6vwzHrbUpQIAAONjpOCytbYlyVOq6nVJfjPJTfpdZyT5aGvtf+apPgCWxkVJTj/iJ1+/3bYaPuT7X8jFO+/23T0vv2TrttqygrV2ZqrukuTBN7/gzKcftPmCO1y5ZodVF91g99N23HL1n9/qZxu/u9QlAgAA42XUHpdJkj6gFFICbG9aa6l684GXXPDaW5/3k3O/t/9N988Uw8XvdNbp7fAzTqurV63+6yWokuWmta1JPr4q+fjuSXZPss8SlwQAAIyvmjTN1GgnqNotyV6Z4gtta+3/5nTyMVRVeyS5OMna1trmpa4HYMF0v9+/cPmaHQ9+4uNetdfXD7lNMvG7vrXcZ+Np7e8+8praWqu+v89lF9++X4QFAAAAZjRsvjZScFlVOyd5WbpVZG84XbvW2upZn3zMCS6BFaXqgCT/meQu/7v/YVd99tA777iqtRzxk6/l1udvzM923eu7+136i8PT2oVLXSoAAADLw0IHl29P8uQkH0xyapJfTNWutfaOWZ98zAkugRWnanWSo7Ymz7xqzY53uWbV6lW/3PEGP9jr8kv+cqctV3+yH/4LAAAAQ1no4PKiJO9trT1r5AqXKcElAAAAAIxu2Hxt1Yjnb0m+MeKxAAAAAAAzGjW4/FCSB85nIQAAAAAAE0YNLv8iyU2r6i1VdZeq2req9h68zGehAAAAAMDKMeocl5MXYpj2BFYVBwAAAAAmGzZfWzPi+V+ZGQJLAAAAAIC5mHVwWVU7JDkpyYWttU3zXxIAsOSqKskNkmxJa1cudTkAAMDKM8ocl1uTfD3JY+a5FgBgqVXtl6qXJNmY5NIkV6Tqu6n6o3TDOQAAABbFrHtctta2VNUZSXZagHoAgKVSdZckH0uy29bUuz51s7uft3nnXfe69xn/c+sDL7ngtZX8QaoenNY2LnGlAADACjDq4jzHJPmDJPdorV0471WNMYvzALBdqjo4yWlJfvKYJ/zNm79xyK3/IskhE7sPu+DMcz/8zj+uXa++4uIkd0prly1RpQAAwDK30IvzrE5yZZIfV9WJ6YaTXT7QprXWXj/i+QGAxfWHSXZ42JNf/w//e8DNTxjc+eN9brT/I578+nzqrc/Zr5LHJ3nrolcIAACsKKP2uNw6RLPWWls9+5LGmx6XAGx3uoX3zt5S9e+HvfAjv5Xk4CQ1Rcv2zve+9IrDN37zu9XaXRe3SAAAYHux0D0uDx3xOABg/OyfZJ8Tb/fAszNpePgU6lM3u/sN7rPxtNtXVWWUv34CAAAMaaTgsrV2xrbaVNVeo5wbAFh0lSQX7rLH3kO2X7WAtQAAACSZ5y8eVbVTVT22qj6Y5Jz5PDcAsGDOTfLzB/z4q9scUXH4xtNy6Y43+InelgAAwEKbc3BZnQdW1b8kOS/Je5PcK8m75npuAGARtHZ1krff/IL/e/Cel28+K8mUoeShF57V7v/jr+QG11z52sUtEAAAWIlGDi6r6i5V9bokZyX5ZJInJdmQ5NeTHNBae9r8lAgALII3VrLlU299ziV7Xr45GQgvb3TRue1tJ76iLt9h53PWbN3yb0tTIgAAsJLMalXxqrppkif0l5unCy3fm+Qr/fXRrbWTFqDOsWFVcQC2W1V3T/LRa1at3vWk2x655bOH3mXX1W1L7v/jr+ao0z+fq1bvcN6uV1/x62ntx0tdKgAAsHwNm68NHVxW1ReT3D3JBUlOTPLu1trn+32HJflhBJcAsLxVHZjkWS15ZiUHJslla3Y6a8ctV79+Tdv6trR20dIWCAAALHfD5muzWVX8Hkl+muR5STa01q6ZW4kAwNhp7ZwkL6+qVyTZPcnWXa658lKL8QAAAIttNnNc/kG6lcL/I8m5VfVPVXVkVdXClAYALJnWWlrbnNZ+KbQEAACWwtDBZWvtTa21+yQ5LMnxSQ5P8ul081y+Mt0k/r7YAAAAAABzNqvFea53cNVd0i3U87h082Cdl+QjST6c5FOttSvmo8hxYo5LAAAAABjdvC/Os407W5Xk/kmemOTR6ebEuqy1ttucTz5mBJcAAAAAMLph87XZzHE5rdba1tbap1prT0myf5LfTTeMHAAAAABg1ualx+VKosclAAAAAIxuUXtcAgAAAADMJ8ElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMHcElAAAAADB2BJcAAAAAwNgRXAIAAAAAY0dwCQAAAACMnWUbXFbVn1XVF6rqsqq6aMhjqqpeWVXnVNXlVfWpqrr5ApcKC6Pq11L1tFQ9M1VHpmrZvp8BAAAABi3noGPHJO9P8uZZHPPCJH+U5NlJ7pHk0iSfqKqd5788WCBV90vV55P8T5K3JfnHJJ9J8v1UPW1JawMAAACYJ2uWuoBRtdZeliRV9ZRh2ldVJTk2yataax/qtz0pyXlJHpXkPQtRJ8yrqkelC+y/dtWqNb99r+ee8IuLd95tvxd99oQbPv2rHzp8VdrbUnXTtPaSJa4UAAAAYE6qtbbUNcxJH1we31rbcxvtbprkx0nu1Fo7bdL2zyY5rbV2zDTH7ZRkp0mbdk+yKcna1trmORUPs1F1UJIfJdnwa8e+932X7LTr65IcMqnFpne+96Wfue/Gbz4pyVFp7aNLUicAAADADKpqjyQXZxv52nIeKj5bB/TX5w1sP2/Svqm8ON0DOXHZNP+lwVCekWTrA5/+pg9dstOu701y8MD+g5/0uL/4vZ/fYI8fJJkyiAcAAABYLsYquKyq9VXVtnG51SKX9eokayddDpm5OSyYJ2xNvedH+9z41f3tGthfSfK6w5+4T5IHp2q/Ra0OAAAAYB6N2xyXr01ywjba/GTEc5/bX++f5JxJ2/dPctp0B7XWrkxy5cTtbqpMWBIHfP3gW1+VmcPz+t5+h+7d/3u/JD9b+LIAAAAA5t9YBZettfOTnL9Ap/9puvDyAemDyn48/T0yu5XJYalc2rp5Lme05+WXXNt+YcsBAAAAWDhjNVR8NqrqxlV1xyQ3TrK6qu7YX3ab1Ob0qnp0krRuFaLjk7ykqh5RVb+W5J1Jzk7ywcWuH0bwiduf+8N7rtq6ZcZGj/7Oyblsh53OTHLG4pQFAAAAMP+WbXCZ5JVJvpnkFUl26//9zSR3ndTmlunmpZzwmiRvTPKWJF/tj3toa+2KxSgY5uhNO19z1f5P+9qHL0rSpmpwh7O/3x76gy9kx2uufn1a27q45QEAAADMn+o6IjKsYZdrhwVR9caW/P7r7vOEvOMuD8/mnXerJNlhy9U56vTPt1f+1z/WVavXnL7PZRffKQJ5AAAAYAwNm68JLmdJcMmSqlqV5K+2pv7kyjU7rPryjX6trl69Jnc85/vZ99KLcuYe+331Rpt/9sB4bQIAAABjSnC5QASXjIWqA7bUqmdcsOueD7lq9Q67XLFmxx8fcMkFr9z9ysu+vdSlAQAAAMxEcLlABJcAAAAAMLph87XlvDgPAAAAALCdElwCAAAAAGNHcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYEVwCAAAAAGNHcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYEVwCAAAAAGNHcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYEVwCAAAAAGNHcAkAAAAAjB3BJQAAAAAwdtYsdQEAY6lqhyS3TbJrknPS2k+WuCIAAABYUfS4BJisao9UvSLJGUm+meTzSX6cqi+m6nGpqqUtEAAAAFYGPS4BJlTtm+TTSQ7bmnrnW+/+qO98d7+b7vyAH31ll4edfurhlbwnyT1T9by01pa4WgAAANiule/es1NVeyS5OMna1trmpa4HmEdVJye59Qt+45i/ev/tH/SCJIdM2rvpLSe96mMP/uGXnpHk2Wntn5amSAAAAFjehs3XDBUHSJKquyU54h13fti/vP/2Dzo+ycEDLQ5+5mNe8v9+stdBpyZ5Qar8/gQAAIAF5Is3QOfpLTnjFQ94xhP724NzWVaSvPihf3iLJIclud9iFgcAAAArjeASoHPoubvd8Iytq1YfkuuHlhPqa4fcZv+J9otUFwAAAKxIgkuAztXXrFq9x7Ya7XTNVRP/vGqmdgAAAMDcCC4BOl886JLzb73HFb+csdFDf/CFiX9+ecErAgAAgBVMcAnQeduq1lY990vv35ykTdVgp6uvbM/+0olXb00+mdZ+uMj1AQAAwIoiuARIktbOreTVz/7yB/Z49pfenx2vufo64eV+v7yw/fNJr6rDLjyrrUr+bKnKBAAAgJWiWpuyYxHTqKo9klycZG1rbfNS1wPMo6pK8uokL7rwBrtv/cit77vq4p12y81/fmYe9KMvp6Uu3WHrNY9Ia59Z6lIBAABguRo2XxNczpLgElaAqltvrXruFWt2fGSSXa5eteb8Xa+6/M1r2tZ3pLWLl7o8AAAAWM4ElwtEcAkAAAAAoxs2XzPHJQAAAAAwdgSXAAAAAMDYEVwCAAAAAGNHcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYWbPUBbBCVd0mye8mOSDJL5N8LMmn0trWJa0LAAAAgLEguGRxVR2U5B1JHtiSn1+y064XrGpb99rtqsuPbcmPquoZae2UJa4SAAAAgCUmuGTxVO2f5PNJdnz/7R7w+j99yB889uo1O9wyreXOZ52ePz3l7Te681mn/9eqqoemtU8vdbkAAAAALJ1qrS11DctKVe2R5OIka1trm5e6nmWl6p1JHvL033rpn3/6Zvd488TWid07bLm6vf3EV9TdNn33Fztfc9X+ae3qpSkUAAAAgIUybL5mcR4WR9W+SR53Ta3620/f7B4vmdg6ucnVq3eoVx35/9rO11y111Wr1jx68YsEAAAAYFwILlksD0my4xMf96ofJDkkA6HlhO/vt66+dcDN87Pd9n7GolYHAAAAwFgRXLJY1ia5+ks3uf0u22r4s932ytaqvRehJgAAAADGlOCSxXJhkh0e9IMvXjVjq9ZyyMU/S5LzF6MoAAAAAMaT4JLF8rEkl/3jB1992ySbkky5KtQdzvlBu/X5G7P/L3/+D4taHQAAAABjRXDJ4mjtoiTvXN22Pu93vvWJv53YOrnJLldd3l7+qbfUpTvsfN5OW6756KLXCAAAAMDYqNam7PjGNIZdrp0pVK1N8tkkN/7MTe/6wec97HkPvugGexy8euuWPPCHX87zP/9vV9/0wrO2rNm65fC09rWlLhcAAACA+Tdsvia4nCXB5RxV7ZnkjUl+pyVbr1y9w0Wr29bdd9i65QYt+WIlz01rpy1tkQAAAAAsFMHlAhFczpOqA5IcnWT/JJcm+bjAEgAAAGD7J7hcIIJLAAAAABjdsPmaxXkAAAAAgLEjuAQAAAAAxs6apS6A7UjVwUkelWTvdN19P5LWfrqkNQEAAACwLOlxydxV7Zeq9yU5I8nrk/x+ktck+XGqPpKqmyxpfVOpWpWqB6XqA6n6aarOSNUnU3V0qnZY6vIAAAAAVjrBJXNTtX+S/05y3yTH/GCfG++37kX/+Tv3eO47nnXyTe/yNy25XZIvpurQpS10kqq1ST6Z5JMtufn39l33xS8fcttv/GLn3Q9I8v4k30jVjZa2SAAAAICVzaris2RV8QFVH0hy7yT3Xvei/7xTkjckOWRi936//PnZn3nLs1btdvUVP0xr912qMq9VtSbJp5Lc4a13fdTfv+r+T39Kqq6t905nnX7ev7/3z1btcvWVv0hyj7R20VKVCgAAALA9sqo4C6/qxunmtHx5H1qemOTgyU1+ttsND/yTo563f5LDU3WHxS/yeh6Z5H5/d+/fed2rHvD//qyfl/Na3zz4Vvv9xlPfuM+Wrofos5amRAAAAAAEl8zFbyW58n/3u+m70/W0TJIaaFP/dfN75MIb7LF1S9XvLG55U3puS/77dYc/8Zn97evVe8ZeB2XDrQ6/qiXPSZX3CAAAAMASEMowF/skOf9hT/27O6cbHj4YAiZJtqxaXWeu3X/VmWsPuN2iVje1e331kNt8KzPUm6Q+fOv77VrJTZIcsHilAQAAADBBcMlcbE6y9x5X/PKQGVu1ln0uvSg/32XtdEHhYtrhgl33usG2Gl255tqFxXdc2HIAAAAAmIrgkrn4SJLd/vpjf3eLmRrd+4xv5eBLzs9pB93yk4tU10x++mvn/uigbTW6wzk/yJaqK5Octwg1AQAAADBAcMnoWvtuklMe+oMv/Pael28+K8n1lqjf+eor8qLPviM/2vuQq//r5vf4h8Uv8nredsjF5x2x7y8vPDtT1JskO2y5uv3eNz+6pVr+La1dvsj1AQAAABDBJXP37Er2/dw/PWPr/X7y9VTb2oWBreUe//ftvOfdf5qb//z/8u47PvTP3vOuF29Z4lqT5G2VXPrRf/mji3e/4tJkILzcYcvV7bUbXl/7XvqLtirt+CWpEAAAAIBUa1N2OmMaVbVHkouTrG2tbV7qesZC1a2T/HuSO527295bzlx7wOr9Lr0wN7no3Px0rwOv+fc7/uafveQzb33NUpd5rap7JfnY5Wt2vOatd3v0Dh+/xb322LJqde5x5v/mqV/78DU3vujcrEr7nbT2gaUuFQAAAGB7M2y+JricJcHlNKoqyT23VD3u7D32vfWFN1jbvnXgLT7x0Vv9+t+NSU/L66q6WZIXteQJldwgSbYmW5L6j1Vpf53WvrbEFQIAAABslwSXC0RwuZ2pWpvkFklWJ/lJWvvZElcEAAAAsF0bNl9bs3glwRhq7eIkX13qMgAAAAC4LovzAAAAAABjR3AJAAAAAIwdwSUAAAAAMHYElwAAAADA2BFcAgAAAABjR3AJAAAAAIwdwSUAAAAAMHYElwAAAADA2BFcAgAAAABjR3AJAAAAAIwdwSUAAAAAMHYElwAAAADA2BFcAgAAAABjR3AJAAAAAIwdwSUAAAAAMHYElwAAAADA2BFcAgAAAABjR3AJAAAAAIwdwSUAAAAAMHYElwAAAADA2BFcAgAAAABjR3AJAAAAAIwdwSUAAAAAMHYElwAAAADA2BFcAgAAAABjR3AJAAAAAIwdwSUAAAAAMHYElwAAAADA2BFcAgAAAABjR3AJAAAAAIydZRtcVtWfVdUXquqyqrpoyGNOqKo2cPn4ApcKAAAAAMzSmqUuYA52TPL+JF9M8vRZHPfxJE+ddPvK+SwKAAAAAJi7ZRtcttZeliRV9ZRZHnpla+3c+a8IAAAAAJgvy3ao+BwcUVU/q6rvV9Wbq+qGMzWuqp2qao+JS5LdF6lOAAAAAFixVlpw+fEkT0rygCQvSnK/JB+rqtUzHPPiJBdPumxa6CIBAAAAYKUbq+CyqtZPsXjO4OVWo56/tfae1tqHW2vfbq19MMnDktwtyREzHPbqJGsnXQ4Z9f4BAAAAgOGM2xyXr01ywjba/GS+7qy19pOquiDJzZJ8epo2V2bSAj5VNV93DwAAAABMY6yCy9ba+UnOX6z7q6pDktwwyTmLdZ8AAAAAwLaN1VDx2aiqG1fVHZPcOMnqqrpjf9ltUpvTq+rR/b93q6q/qap7VtW6qnpAkg8l+VGSTyzFzwAAAAAATG2selzO0iuTPHnS7W/210cmOaX/9y3TzUuZJFuS3L4/Zs8kZyf5ZJKX9sPBAQAAAIAxUa21pa5hWamqPdKtLr62tbZ5qesBAAAAgOVk2Hxt2Q4VBwAAAAC2X4JLAAAAAGDsCC4BAAAAgLEjuAQAAAAAxo7gEgAAAAAYO4JLAAAAAGDsCC4BAAAAgLEjuAQAAAAAxo7gEgAAAAAYO4JLAAAAAGDsCC4BAAAAgLEjuAQAAAAAxo7gEgAAAAAYO4JLAAAAAGDsCC4BAAAAgLEjuAQAAAAAxo7gEgAAAAAYO4JLAAAAAGDsCC4BAAAAgLEjuAQAAAAAxo7gEgAAAAAYO4JLAAAAAGDsCC4BAAAAgLEjuAQAAAAAxo7gEgAAAAAYO4JLAAAAAGDsCC4BAAAAgLEjuAQAAAAAxs6apS6AMVK1T5J7J9k5yZlJvpzWti5tUQAAAACsRIJLkqp1Sf4iyW8n2XHSnh+m6vVJ/jGttaUoDQAAAICVSXC50lXdJsnJSa66pla99JiHv+Cn39vv0N2fcNrHdnvq1z7866vS3pTkTql6lvASAAAAgMVSsqjZqao9klycZG1rbfNS1zMnVWuSnJ7kskc86XWv/Z8Db/GqJIdMarHp7z78mg8+4nuf+4Mkz05r/7QkdQIAAACw3Rg2X7M4z8r28CSHveyBz3rH/xx4i39JcvDA/oP/6BEv/P2Nex74hSR/nKpa/BIBAAAAWIkElyvbk1ry5Xfc5eHH9rcHg8lKkpc++Dk3S3LLJHdfxNoAAAAAWMEElyvbwWfseeD56YaHT9ebsr59wM326/99yDRtAAAAAGBeCS5Xtiu2rFq1z7Ya7XblZRP/vHxhywEAAACAjuByZfvMul+cc8dJweSUHvG9z2VL1VVJvrQ4ZQEAAACw0gkuV7Z/XtW27nDMf7/7kiRTLi+/z6W/aE/92oe3VMu70tqFi1wfAAAAACuU4HIla+2sSl72jK/+x+4v+Ow7ao8rfnmd8PIOZ3+/vfvdf1q7X3XZ5lVpf75UZQIAAACw8lRrU3a0YxpVtUeSi5Osba1tXup65qyqkrx4a+qVV67ZYdXJN71r/XKnXXLrn/00v3bej3PJjructftVl90/rf1gqUsFAAAAYPkbNl8TXM7SdhdcTqg6cEuteubFO+/2qC21atdrVq8+e+/LLn7tTluu+Wha27LU5QEAAACwfRBcLpDtNrgEAAAAgEUwbL5mjksAAAAAYOwILgEAAACAsSO4BAAAAADGjuASAAAAABg7gksAAAAAYOwILgEAAACAsSO4BAAAAADGjuASAAAAABg7gksAAAAAYOwILgEAAACAsSO4BAAAAADGjuASAAAAABg7gksAAAAAYOwILgEAAACAsSO4BAAAAADGjuASAAAAABg7gksAAAAAYOwILgEAAACAsSO4BAAAAADGjuASAAAAABg7a5a6gGVs96pa6hoAAAAAYLnZfZhGgsvZm3hgNy1pFQAAAACwvO2eZPN0O6u1toi1LH/VdbM8KMklS13LItg9XUB7SFbGzwvbE+9fWL68f2F58x6G5cv7FxbX7knObjOEk3pczlL/YJ611HUshklD4S9prU2bfgPjx/sXli/vX1jevIdh+fL+hUW3zfeZxXkAAAAAgLEjuAQAAAAAxo7gkplcmeQV/TWwvHj/wvLl/QvLm/cwLF/evzBmLM4DAAAAAIwdPS4BAAAAgLEjuAQAAAAAxo7gEgAAAAAYO4JLAAAAAGDsCC5JklTVgVW1vqpOrqpLqqpV1RGzOP7l/TGDlysWrmpgwlzfw/05Dq6q91XVRVW1uao+VFU3XZiKgcmqas+qektVnV9Vl/bv5TsPeewJ03wGn77QdcNKUlU7VdVfV9XZVXV5VX25qh405LE+Y2EJjfr+9T0Xlt6apS6AsXHLJC9K8sMk305yrxHP85wkv5x0e8sc6wKGM6f3cFXtluTkJGuT/FWSq5P8cZLPVtUdW2s/n99ygQlVtSrJhiR3SPI3SS5I8twkp1TVXVprPxziNFcm+X8D2y6e10KBE5IcneT4dJ+3T0ny0ao6srX2+ekO8hkLY+GEjPD+ncT3XFgigksmfD3JDVtrF1bV0UneP+J5TmytXTCPdQHDmet7+LlJbp7k7q21ryZJVX0syf8meX6SP53PYoHrODrJvZM8trV2YpJU1fuS/CDJK5I8fohzXNNa+7eFKxFWtqq6e5LfSfKC1trf9tveme5z8jXp3sPT8RkLS2iO798JvufCEjFUnCRJa+2S1tqF83Cqqqo9qqrm4VzAkObhPXx0kq9OfKHqz3l6kk8n+e251gfM6Ogk5yU5aWJDa+38JO9L8siq2mmYk1TV6qraY2FKhBXv6HQ9rN4ysaG1dkWStyW5V1XdaBvH+oyFpTOX9+8E33NhiQgumW8/STc07ZKq+req2n+pCwJm1g9TvX2Sr02x+ytJDquq3Re3KlhR7pTkG621rQPbv5JklyS3GOIcuyTZnOTiqrqwqv6hH54KzI87JflBa23zwPav9Nd3nOogn7EwFkZ6/w7wPReWiKHizJdfJPn7JF9MN8/W4Ul+P8ndq+quU3xIAONj7yQ7JTlnin0T2w5K8v1FqwhWlgOTfG6K7ZPff9+e4fhz0g11+0a6P0o/NN3Q1DtU1RGttWvmsVZYqQ7Mtj8np+IzFpbeqO/fxPdcWHKCy+1Q/5fdHYdsfmVrrc31PltrbxjY9IGq+kqSf0/35Wn9XO8DVooleA/fYOJcU+y7YqANMIMR3783yBzef621Fw9sek9V/SDJX6YbHveeIesBpjfq+9RnLCy9kT9nfc+FpWeo+PbpvkkuH/Jyy4UqorX2riTnJnngQt0HbKcW+z18eX891Tx6Ow+0AWY2yvv38sz/++/1SbbGZzDMl1Hfpz5jYenN6+es77mwuPS43D6dnuSpQ7adqsv8fDoz3RAZYHiL/R6+MN1foQ+cYt/EtrPn4X5gJRjl/XtO5vn911q7vKp+Hp/BMF/OSXLwFNu39T71GQtLb9T370x8z4VFIrjcDrXWzk1ywlLX0a+4ti7JN5e4FFhWFvs93FrbWlXfTnLXKXbfI8lPWmuXLFY9sJyN+P49LcnhVbVqYIGeeyS5LMkPZltHv9jHPknOn+2xwJROS3JkVe0xMKfdPSbtvx6fsTAWTssI79/p+J4Li8tQcWatqm5cVbca2LbvFE2fk2TfJB9flMKAoUz1Hk5yYpK7VdVdJ7W7ZZL7J3n/YtYHK9CJSfZP8piJDVW1T5LHJvlIa+3KSdsPq6rDJt3eeZoViV+apOIzGObLiUlWJ3nmxIaq2ildD+svt9bO7Lf5jIXxM/L71/dcWHo1D+uysJ2oqpf0/7xtkt9J8vYkP02S1tqrJrU7Jcn9Wms1adtlSd6bbtXTK5Lcpz/Ht5L8emvtskX4EWBFm+N7ePd0fzXePcnfJrk6yfPS/Sfvjq01vbZggVTV6iSfT3K7JH+T5IJ0E/7fOMndWmvfn9R2Y5K01tb1t9ele+++O90w9SR5SJLfTPeF6qiBXpzAiKrqfUkenW4O2R8leXKSuyd5QGvtc32bU+IzFsbOHN6/vufCEhNccq2qmvbFMPDL+5Rc/xf6Pye5d5IbpZvk+IwkH0jyl4a/wOKYy3u4335Iuv/MPThdj/xTkvxxa+1HC1Ev8CtVtVe60PJR6VY3/WqSP2mtfW2g3cbkOsHlnknemOSeSQ5KF4T8KN1qp3/bWrt6MeqHlaCqdk7yF0memGSvJP+T5KWttU9ManNKfMbC2Bn1/et7Liw9wSUAAAAAMHbMcQkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYEVwCAAAAAGNHcAkAAAAAjB3BJQAAAAAwdgSXAAAAAMDYEVwCAAAAAGNHcAkAAAAAjB3BJQDAGKuql1dVW+o6FlpVramq11TVmVW1tao+2G9vVfXypa0OAIClILgEAFgkVfWUPoibuFxRVWdX1Seq6o+qavelrnFCVe3Sh6ZHDNn+iP5nOnrEu3xakhckOTHJk5O8fsTzLHtVdZ+q+lhVndW/Rv6vqj5SVY9f6toAABbTmqUuAABgBfrzJD9NskOSA5IckeT4JM+rqke01v5nUttXJVm/2AUm2SXJy/p/n7II93f/JGe11v54Ee5rbFXVY5O8N8lpSd6Q5BdJDk1y3yTPSPKuJSsOAGCRCS4BABbfx1prX5t0+9VVdf8k/5nkw1V169ba5UnSWrsmyTUznayqViXZsbV2xYJVvPD2S3LRUhcxBl6e5LtJ7tlau2ryjqrab7GKqKpKsvPE6xAA/n97dx6rV1HGcfz7a0ENoJQtBNSAAoEooKLBJbiwKIsRg4gksgQF2WIo4IIICGJkFTVIkCo7GLCBAopKhVgqS1RAZJXt0iIE2aGCBcQy/jFzy5vDfXtvL7flTfx+kptzzzlzZubM+/7x5snMPNLrwaXikiRJA6CU8gfge8BawK7D10fa47ItyT4lyS5J7gBeBLZp996a5MwkjyZ5MckdSb7cbS/Jm1rd97TlyP9MMiPJOknWBh5vRY/sWdp+1OK803Dfk6yb5OwkzySZl+SsJMu1Mmu399sceHdPW5/oU+fZSeb2a2uE67smuSnJ80meSnJhkrd3ylyd5PYk70oyK8n8tkz7m4szbj1lJiU5sI39C+2zmJZkpTEM2zrADd2gJUAp5bFOXyYlmZrkttbO40muSPKBnjLLJDkiyVD7PsxNckySN3bqmpvk8iRbJ7kReB7Yp92bkuTHbf/RF5Pcl+SQFjCXJElaYvyxIUmSNDjOa8dPjaHsFtR9IH8JTAXmJlkd+BOwFXBKu34fcEaSA4cfTDKZOrvzSOAm4GvUZckrAhtSg5b7teKXALu1vxnjfK/pwJuBQ9v/e/DKMvTHW913AQ/1tPX3cba1UJLDgHOBe4GDqcvxtwT+mGRKp/hKwBXALdTxuAs4Psm2PfWNNm7DpgEnAtdRP4OzgF2AmUmWHaXbDwBbJnnbGF7xjPZODwKHULcUeAH4UE+Z04Gjgb8CBwGzqZ/DhSPUtz5wAXBl6/ffWoB5NjWYfi5wQHuvY4EfjqGPkiRJ4+ZScUmSpAFRSnkoyTzqrLvRrA9sVEq5c/hCktOBye36k+3yaUkuAI5KMq0t/d2dGsA7uJTSmwTnuCQppZQkFwE/BW4tpZz/Gl/t5lLKnj39XAXYEziklPJv4PwkewELJqCt4TbWAr4LHF5KOabn+gzgZmB/4JieR9YEdi+lnNfKnUENIu4J/K6VWeS4tec2A/YCdimlLNyPMsksamB0Jxa9T+Xx1IDkUJLrgGuB3wPXl1Je7qlvc2oA+ORSytSe50/q6ct7qImOTi+lfKXdPzXJY8DXk2xeSpnV8+y6wDallJk97RxO/T6+r5Ryb7s8LcnDwDeSnFRKeXAR7yNJkjRuzriUJEkaLM9RZyeOZnYnaBlgR+DX7XTV4T9gJnVW4Cat+I7AE8BPupWWUl613HoCnNY5vwZYJclblkBbwz5H/a07vTMWj1BnYG7eKf8csDBo2pZq/wV4Z0+ZsYzbTsA84MpOuze1Nrrtdus5k7rs/2pgM+AI6njdm+Qjnb4UanC2X1+2a8fuzMiT2vHTnetzeoOWPe9zDfB0532uogbJP7ao95EkSXotnHEpSZI0WFYAHhu1VM1K3ms1YAqwd/sbyXByl3WAu1vin6XhH53zp9txJeBfS6jN9YBQg5Qjealz/tAIQdungY17zscybutRg8T9PsNRE+y04OHMtkz7/cDOwL7A5Uk2aHtdrgM8XEp5ahFVrQW8TN0uoLf+R5I80+736n6noL7Pxryy52nXUksYJEmS/v8YuJQkSRoQbV/DFekEmvroZnseXklzPnBOn2duHWfXXqsFfa5nHHX1mxE6uXM+qZXdtk/7z3XOJ6qPk6hBy1363O8XAHyVUsp86mzHa5I8Qd1bc1v6f759qxpjuZEyiE+i7nl5Qp9n7lnMvkiSJI2ZgUtJkqTBsVs7dpfrjsXjwLPA5FLKVaOUHQI+mGTZUkp35uGwJbFkfCI8TZ1Z2tWdPThEDTrOKaVMVHBtLOM2RE2OdF3bT3Si3NiOa/S0s3WSlRcx6/IBauBxPXqSHbUkTlPa/dEMASuM4TslSZI04dzjUpIkaQAk2YK6n+Ec4BeL+3wpZQFwMbBjkg2795Os1nN6MbAq8NURyg3PMJzfjlMWty9L2BCwYpKFS7iTrAHs0Ck3gzqL8siedxoun5YgaHGNZdymU2d/HjFCmWVGyGbeLbNln1vD+1Xe3dOX8Ep29pH68tt2PLBT5OB2/M2i+tJMBz6cZOsR2pmSxIkQkiRpifGHhiRJ0tK3bZINqL/FVge2AD5JnQG3fSnlhXHW+y1q8pc/J/k5cCewMjUpz1btf4BzqRmyf5hkU+py5OVbmVOBy0opzye5E9g5yT3AU8DtpZTbx9m3iXIhNfP2JUlOBpYD9qMuWR5OPkQpZahlxD4WWDvJpdQZqe+gBjl/BvxgMdsey7jNTjINODTJe6kZwV+iznrcCZgKXLSINi5LMoeaZGmop/7PADe065RSZiU5DzggyXrUjOWTgI8Cs4BTSim3JDkH2LsFTGcDm1IzjV/aySjez4nA9tT9Nc+mJhlaHtgI+DywNjVhkSRJ0oQzcClJkrT0Hd2O/6EGBG+jzoo7q5Ty7HgrLaU82gJq36Fm1d4feBK4Azikp9yCJNsBhwFfpGaofhK4tvVl2F7UDNo/At5AzWD9ugYuSylPJtmBmin7BOoM1UOpgcFNOmWPa0HXg3hlZuKD1GDir8bR9pjGrZSyb5KbgH2AY4D/AnOp+49eN0ozewGfBb4ArEmdVXk/8H3g+E5ioC9R9y3dkxpgnEddUn59p777gT2oAdtHqMHcV2Uj7/PO85N8HPg2NfC6OzWh0j3UMZ03lnokSZLGI69OnihJkiRJkiRJry/3uJQkSZIkSZI0cAxcSpIkSZIkSRo4Bi4lSZIkSZIkDRwDl5IkSZIkSZIGjoFLSZIkSZIkSQPHwKUkSZIkSZKkgWPgUpIkSZIkSdLAMXApSZIkSZIkaeAYuJQkSZIkSZI0cAxcSpIkSZIkSRo4Bi4lSZIkSZIkDRwDl5IkSZIkSZIGzv8ASRYec6k/dkEAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -1178,8 +1178,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation Arnoldi vs direct 0.9877956269724696\n", - "Spearman Correlation Arnoldi vs direct 0.9754641408670681\n" + "Pearson Correlation Arnoldi vs direct 0.9876463041029632\n", + "Spearman Correlation Arnoldi vs direct 0.9772879562687357\n" ] } ], @@ -1271,7 +1271,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of Nyström over direct method:961.7160797119141 %\n" + "Percentage error of Nyström over direct method:52.49669551849365 %\n" ] } ], @@ -1297,7 +1297,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1341,8 +1341,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation Nyström vs direct 0.9964113434116059\n", - "Spearman Correlation Nyström vs direct 0.9900848930649672\n" + "Pearson Correlation Nyström vs direct 0.9949392350441726\n", + "Spearman Correlation Nyström vs direct 0.9883719172733456\n" ] } ], @@ -1422,7 +1422,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Percentage error of EK-FAC over direct method:19627.71759033203 %\n" + "Percentage error of EK-FAC over direct method:1528.7002563476562 %\n" ] } ], @@ -1456,7 +1456,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1508,8 +1508,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation EK-FAC vs direct 0.959103428045871\n", - "Spearman Correlation EK-FAC vs direct 0.8893014585485051\n" + "Pearson Correlation EK-FAC vs direct 0.9579606771217988\n", + "Spearman Correlation EK-FAC vs direct 0.895971987807643\n" ] } ], @@ -1550,8 +1550,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pearson Correlation EK-FAC vs direct - top-20 influences 0.9892283817509515\n", - "Spearman Correlation EK-FAC vs direct - top-20 influences 0.9729323308270676\n" + "Pearson Correlation EK-FAC vs direct - top-20 influences 0.9729110282877721\n", + "Spearman Correlation EK-FAC vs direct - top-20 influences 0.9759398496240601\n" ] } ], From 66e4ffe2c483edcb76c13505949017df33262288 Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Fri, 14 Jun 2024 16:58:30 +0200 Subject: [PATCH 09/11] Update CHANGELOG --- CHANGELOG.md | 19 ++++++++++++++++++- 1 file changed, 18 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4142c0fab..6435bb856 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -22,6 +22,9 @@ - Extend `ArnoldiInfluence` with block-diagonal and Gauss-Newton approximation [PR #598](https://github.com/aai-institute/pyDVL/pull/598) +- Extend `CgInfluence` with block-diagonal and Gauss-Newton + approximation + [PR #601](https://github.com/aai-institute/pyDVL/pull/601) ## Fixed - Replace `np.float_` with `np.float64` and `np.alltrue` with `np.all`, @@ -53,7 +56,21 @@ `lanczos_low_rank_hessian_approximation`, `model_hessian_low_rank` from `influence.torch.functional` [PR #598](https://github.com/aai-institute/pyDVL/pull/598) - + - Renaming of parameters of `CgInfluence`, + `hessian_regularization` -> `regularization` (modify type annotation), + `pre_conditioner` -> `preconditioner` + [PR #601](https://github.com/aai-institute/pyDVL/pull/601) + - Remove parameter `x0` from `CgInfluence` + [PR #601](https://github.com/aai-institute/pyDVL/pull/601) + - Rename module + `influence.torch.pre_conditioner` -> `influence.torch.preconditioner` + [PR #601](https://github.com/aai-institute/pyDVL/pull/601) + - Refactor preconditioner: + - renaming `PreConditioner` -> `Preconditioner` + - fit to `TensorOperator` + [PR #601](https://github.com/aai-institute/pyDVL/pull/601) + + ## 0.9.2 - 🏗 Bug fixes, logging improvement ### Added From 099930e8cfa67e5ec28e98ed31573b413926198f Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Fri, 14 Jun 2024 17:17:04 +0200 Subject: [PATCH 10/11] Rename parameter use_block_cg -> solve_simultaneously to not get confused with block-diagonal approximation --- CHANGELOG.md | 3 +- docs/influence/influence_function_model.md | 38 +++++++++++-------- notebooks/influence_wine.ipynb | 2 +- .../torch/influence_function_model.py | 16 +++----- tests/influence/test_influence_calculator.py | 2 +- tests/influence/torch/test_influence_model.py | 4 +- 6 files changed, 35 insertions(+), 30 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 6435bb856..2a21b74d5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -58,7 +58,8 @@ [PR #598](https://github.com/aai-institute/pyDVL/pull/598) - Renaming of parameters of `CgInfluence`, `hessian_regularization` -> `regularization` (modify type annotation), - `pre_conditioner` -> `preconditioner` + `pre_conditioner` -> `preconditioner`, + `use_block_cg` -> `solve_simultaneously` [PR #601](https://github.com/aai-institute/pyDVL/pull/601) - Remove parameter `x0` from `CgInfluence` [PR #601](https://github.com/aai-institute/pyDVL/pull/601) diff --git a/docs/influence/influence_function_model.md b/docs/influence/influence_function_model.md index fcfa0fa27..c4642d5aa 100644 --- a/docs/influence/influence_function_model.md +++ b/docs/influence/influence_function_model.md @@ -23,37 +23,45 @@ gradient method, defined in [@ji_breakdownfree_2017], which solves several right hand sides simultaneously. Optionally, the user can provide a pre-conditioner to improve convergence, such -as a [Jacobi pre-conditioner -][pydvl.influence.torch.pre_conditioner.JacobiPreConditioner], which +as a [Jacobi preconditioner +][pydvl.influence.torch.preconditioner.JacobiPreconditioner], which is a simple [diagonal pre-conditioner]( https://en.wikipedia.org/wiki/Preconditioner#Jacobi_(or_diagonal)_preconditioner) based on Hutchinson's diagonal estimator [@bekas_estimator_2007], -or a [Nyström approximation based pre-conditioner -][pydvl.influence.torch.pre_conditioner.NystroemPreConditioner], +or a [Nyström approximation based preconditioner +][pydvl.influence.torch.preconditioner.NystroemPreconditioner], described in [@frangella_randomized_2023]. ```python -from pydvl.influence.torch import CgInfluence +from pydvl.influence.torch import CgInfluence, BlockMode, SecondOrderMode from pydvl.influence.torch.preconditioner import NystroemPreconditioner if_model = CgInfluence( model, loss, - hessian_regularization=0.0, + regularization=0.0, rtol=1e-7, atol=1e-7, maxiter=None, - use_block_cg=True, - pre_conditioner=NystroemPreconditioner(rank=10) + solve_simultaneously=True, + preconditioner=NystroemPreconditioner(rank=10), + block_structure=BlockMode.FULL, + second_order_mode=SecondOrderMode.HESSIAN ) if_model.fit(train_loader) ``` -The additional optional parameters `rtol`, `atol`, `maxiter`, `use_block_cg` and -`pre_conditioner` are respectively, the relative +The additional optional parameters `rtol`, `atol`, `maxiter`, +`solve_simultaneously` and `preconditioner` are respectively, the relative tolerance, the absolute tolerance, the maximum number of iterations, -a flag indicating whether to use block variant of cg and an optional -pre-conditioner. +a flag indicating whether to use a variant of cg to +simultaneously solving the system for several right hand sides and an optional +preconditioner. + +This implementation is capable of using a block-diagonal +approximation, see +[Block-diagonal approximation](#block-diagonal-approximation), and can handle +[Gauss-Newton approximation](#gauss-newton-approximation). ### Linear time Stochastic Second-Order Approximation (LiSSA) @@ -78,7 +86,7 @@ from pydvl.influence.torch import LissaInfluence, BlockMode, SecondOrderMode if_model = LissaInfluence( model, loss, - regularization=0.0 + regularization=0.0, maxiter=1000, dampen=0.0, scale=10.0, @@ -114,7 +122,7 @@ the Hessian and \(V\) contains the corresponding eigenvectors. See also [@schioppa_scaling_2022]. ```python -from pydvl.influence.torch import ArnoldiInfluence +from pydvl.influence.torch import ArnoldiInfluence, BlockMode, SecondOrderMode if_model = ArnoldiInfluence( model, loss, @@ -207,7 +215,7 @@ see also [@hataya_nystrom_2023] and [@frangella_randomized_2023]. The essential parameter is the rank of the approximation. ```python -from pydvl.influence.torch import NystroemSketchInfluence +from pydvl.influence.torch import NystroemSketchInfluence, BlockMode, SecondOrderMode if_model = NystroemSketchInfluence( model, loss, diff --git a/notebooks/influence_wine.ipynb b/notebooks/influence_wine.ipynb index a0810e303..7ec902438 100644 --- a/notebooks/influence_wine.ipynb +++ b/notebooks/influence_wine.ipynb @@ -750,7 +750,7 @@ " F.cross_entropy,\n", " regularization=0.1,\n", " progress=True,\n", - " use_block_cg=True,\n", + " solve_simultaneously=True,\n", " preconditioner=NystroemPreconditioner(rank=5),\n", ")\n", "cg_influence_model = cg_influence_model.fit(training_data_loader)\n", diff --git a/src/pydvl/influence/torch/influence_function_model.py b/src/pydvl/influence/torch/influence_function_model.py index acdfdbffa..9e7d96325 100644 --- a/src/pydvl/influence/torch/influence_function_model.py +++ b/src/pydvl/influence/torch/influence_function_model.py @@ -458,14 +458,10 @@ class CgInfluence(TorchComposableInfluence[CgOperator]): maxiter: Maximum number of iterations. If None, defaults to 10*len(b). progress: If True, display progress bars for computing in the non-block mode (use_block_cg=False). - precompute_grad: If True, the full data gradient is precomputed and kept - in memory, which can speed up the hessian vector product computation. - Set this to False, if you can't afford to keep the full computation graph - in memory. - pre_conditioner: Optional pre-conditioner to improve convergence of conjugate + preconditioner: Optional preconditioner to improve convergence of conjugate gradient method - use_block_cg: If True, use block variant of conjugate gradient method, which - solves several right hand sides simultaneously + solve_simultaneously: If True, use a variant of conjugate gradient method to + simultaneously solve for several right hand sides. warn_on_max_iteration: If True, logs a warning, if the desired tolerance is not achieved within `maxiter` iterations. If False, the log level for this information is `logging.DEBUG` @@ -485,7 +481,7 @@ def __init__( progress: bool = False, precompute_grad: bool = False, preconditioner: Optional[Preconditioner] = None, - use_block_cg: bool = False, + solve_simultaneously: bool = False, warn_on_max_iteration: bool = True, block_structure: Union[BlockMode, OrderedDict[str, List[str]]] = BlockMode.FULL, second_order_mode: SecondOrderMode = SecondOrderMode.HESSIAN, @@ -493,7 +489,7 @@ def __init__( super().__init__(model, block_structure, regularization) self.loss = loss self.warn_on_max_iteration = warn_on_max_iteration - self.use_block_cg = use_block_cg + self.solve_simultaneously = solve_simultaneously self.preconditioner = preconditioner self.precompute_grad = precompute_grad self.progress = progress @@ -547,7 +543,7 @@ def _create_block( maxiter=self.maxiter, progress=self.progress, preconditioner=preconditioner, - use_block_cg=self.use_block_cg, + use_block_cg=self.solve_simultaneously, warn_on_max_iteration=self.warn_on_max_iteration, ) gp = TorchGradientProvider(self.model, self.loss, restrict_to=block_params) diff --git a/tests/influence/test_influence_calculator.py b/tests/influence/test_influence_calculator.py index 221cb746d..bfd976e2a 100644 --- a/tests/influence/test_influence_calculator.py +++ b/tests/influence/test_influence_calculator.py @@ -71,7 +71,7 @@ def influence_model(model_and_data, test_case, influence_factory): model, loss, hessian_reg, - use_block_cg=True, + solve_simultaneously=True, ).fit(train_dataLoader), lambda model, loss, train_dataLoader, hessian_reg: DirectInfluence( model, loss, hessian_reg diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index dd998b4f7..94374e796 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -398,7 +398,7 @@ def direct_influences_from_factors( loss, regularization=hessian_reg, preconditioner=NystroemPreconditioner(10), - use_block_cg=True, + solve_simultaneously=True, ).fit(train_dataLoader), 1e-4, ], @@ -776,7 +776,7 @@ def test_influences_cg( test_case.hessian_reg, maxiter=5, preconditioner=preconditioner, - use_block_cg=use_block_cg, + solve_simultaneously=use_block_cg, ) influence_model = influence_model.fit(train_dataloader) From 676bc6a782458f64d3d37dacccc8777621c36f07 Mon Sep 17 00:00:00 2001 From: Kristof Schroeder Date: Mon, 17 Jun 2024 11:30:25 +0200 Subject: [PATCH 11/11] Fix wrong parameter name in test --- tests/influence/torch/test_influence_model.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/influence/torch/test_influence_model.py b/tests/influence/torch/test_influence_model.py index 94374e796..529d1decd 100644 --- a/tests/influence/torch/test_influence_model.py +++ b/tests/influence/torch/test_influence_model.py @@ -854,13 +854,13 @@ def test_influences_cg( CgInfluence, maxiter=10, preconditioner=JacobiPreconditioner(), - use_block_cg=True, + solve_simultaneously=True, ), partial( CgInfluence, maxiter=10, preconditioner=NystroemPreconditioner(rank=5), - use_block_cg=True, + solve_simultaneously=True, ), ]