From 8389932e7a55f1bbe5bb40d84b4cd49e4f0823c8 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 2 Aug 2023 10:36:09 +0000 Subject: [PATCH 001/115] First attempt at sampling class --- .../cil/optimisation/algorithms/sampling.py | 101 +++++ .../algorithms/testing_sampling.ipynb | 419 ++++++++++++++++++ 2 files changed, 520 insertions(+) create mode 100644 Wrappers/Python/cil/optimisation/algorithms/sampling.py create mode 100644 Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampling.py b/Wrappers/Python/cil/optimisation/algorithms/sampling.py new file mode 100644 index 0000000000..b41b7032c8 --- /dev/null +++ b/Wrappers/Python/cil/optimisation/algorithms/sampling.py @@ -0,0 +1,101 @@ +# -*- coding: utf-8 -*- +# This work is part of the Core Imaging Library (CIL) developed by CCPi +# (Collaborative Computational Project in Tomographic Imaging), with +# substantial contributions by UKRI-STFC and University of Manchester. + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import numpy as np +import math +class Sampling(): + + def __init__(self, num_subsets, sampling_type='sequential', prob=None, seed=99): + self.type=sampling_type + self.num_subsets=num_subsets + self.seed=seed + + self.last_subset=-1 + if self.type=='sequential': + pass + elif self.type=='random': + if prob==None: + self.prob = [1/self.num_subsets] * self.num_subsets + else: + self.prob=prob + elif self.type=='herman_meyer': + + self.order=self.herman_meyer_order(self.num_subsets) + else: + raise NameError('Please choose from sequential, random, herman_meyer') + + + def herman_meyer_order(self, n): + # Assuming that the subsets are in geometrical order + n_variable = n + i = 2 + factors = [] + while i * i <= n_variable: + if n_variable % i: + i += 1 + else: + n_variable //= i + factors.append(i) + if n_variable > 1: + factors.append(n_variable) + n_factors = len(factors) + order = [0 for _ in range(n)] + value = 0 + for factor_n in range(n_factors): + n_rep_value = 0 + if factor_n == 0: + n_change_value = 1 + else: + n_change_value = math.prod(factors[:factor_n]) + for element in range(n): + mapping = value + n_rep_value += 1 + if n_rep_value >= n_change_value: + value = value + 1 + n_rep_value = 0 + if value == factors[factor_n]: + value = 0 + order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping + return order + + def next(self): + if self.type=='sequential': + self.last_subset= (self.last_subset+1)%self.num_subsets + return self.last_subset + elif self.type=='random': + if self.last_subset==-1: + np.random.seed(self.seed) + self.last_subset=0 + return int(np.random.choice(self.num_subsets, 1, p=self.prob)) + elif self.type=='herman_meyer': + self.last_subset= (self.last_subset+1)%self.num_subsets + return(self.order[self.last_subset]) + + + def show_epochs(self, num_epochs=2): + if self.type=='sequential': + for i in range(num_epochs): + print('Epoch {}: '.format(i), [j for j in range(self.num_subsets)]) + elif self.type=='random': + np.random.seed(self.seed) + for i in range(num_epochs): + print('Epoch {}: '.format(i), np.random.choice(self.num_subsets, self.num_subsets, p=self.prob)) + elif self.type=='herman_meyer': + for i in range(num_epochs): + print('Epoch {}: '.format(i), self.order) + \ No newline at end of file diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb new file mode 100644 index 0000000000..f135686d3c --- /dev/null +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb @@ -0,0 +1,419 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + " \n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import os\n", + "from sampling import Sampling\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n", + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n" + ] + } + ], + "source": [ + "sampler=Sampling(10,'sequential')\n", + "sampler.show_epochs(5)\n", + "for _ in range(100):\n", + " print(sampler.next())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: [ 7 5 9 0 8 6 3 0 10 0 8]\n", + "Epoch 1: [ 8 4 5 10 4 10 5 1 8 2 6]\n", + "Epoch 2: [3 8 9 2 7 1 4 1 1 2 5]\n", + "Epoch 3: [ 0 2 0 9 6 1 10 5 0 5 7]\n", + "Epoch 4: [ 8 9 2 10 5 2 6 4 2 10 10]\n", + "7\n", + "5\n", + "9\n", + "0\n", + "8\n", + "6\n", + "3\n", + "0\n", + "10\n", + "0\n", + "8\n", + "8\n", + "4\n", + "5\n", + "10\n", + "4\n", + "10\n", + "5\n", + "1\n", + "8\n", + "2\n", + "6\n", + "3\n", + "8\n", + "9\n", + "2\n", + "7\n", + "1\n", + "4\n", + "1\n", + "1\n", + "2\n", + "5\n", + "0\n", + "2\n", + "0\n", + "9\n", + "6\n", + "1\n", + "10\n", + "5\n", + "0\n", + "5\n", + "7\n", + "8\n", + "9\n", + "2\n", + "10\n", + "5\n", + "2\n", + "6\n", + "4\n", + "2\n", + "10\n", + "10\n", + "9\n", + "4\n", + "7\n", + "9\n", + "0\n", + "4\n", + "7\n", + "10\n", + "7\n", + "7\n", + "2\n", + "3\n", + "1\n", + "3\n", + "7\n", + "10\n", + "0\n", + "3\n", + "0\n", + "9\n", + "7\n", + "9\n", + "10\n", + "1\n", + "5\n", + "6\n", + "5\n", + "7\n", + "9\n", + "2\n", + "1\n", + "6\n", + "2\n", + "9\n", + "5\n", + "7\n", + "3\n", + "1\n", + "3\n", + "1\n", + "2\n", + "5\n", + "3\n", + "8\n", + "7\n" + ] + } + ], + "source": [ + "sampler=Sampling(11,'random')\n", + "sampler.show_epochs(5)\n", + "for _ in range(100):\n", + " print(sampler.next())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "Epoch 1: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "Epoch 2: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "Epoch 3: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "Epoch 4: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "0\n", + "30\n", + "15\n", + "45\n", + "5\n", + "35\n", + "20\n", + "50\n", + "10\n", + "40\n", + "25\n", + "55\n", + "1\n", + "31\n", + "16\n", + "46\n", + "6\n", + "36\n", + "21\n", + "51\n", + "11\n", + "41\n", + "26\n", + "56\n", + "2\n", + "32\n", + "17\n", + "47\n", + "7\n", + "37\n", + "22\n", + "52\n", + "12\n", + "42\n", + "27\n", + "57\n", + "3\n", + "33\n", + "18\n", + "48\n", + "8\n", + "38\n", + "23\n", + "53\n", + "13\n", + "43\n", + "28\n", + "58\n", + "4\n", + "34\n", + "19\n", + "49\n", + "9\n", + "39\n", + "24\n", + "54\n", + "14\n", + "44\n", + "29\n", + "59\n", + "0\n", + "30\n", + "15\n", + "45\n", + "5\n", + "35\n", + "20\n", + "50\n", + "10\n", + "40\n", + "25\n", + "55\n", + "1\n", + "31\n", + "16\n", + "46\n", + "6\n", + "36\n", + "21\n", + "51\n", + "11\n", + "41\n", + "26\n", + "56\n", + "2\n", + "32\n", + "17\n", + "47\n", + "7\n", + "37\n", + "22\n", + "52\n", + "12\n", + "42\n", + "27\n", + "57\n", + "3\n", + "33\n", + "18\n", + "48\n" + ] + } + ], + "source": [ + "sampler=Sampling(60,'herman_meyer')\n", + "sampler.show_epochs(5)\n", + "for _ in range(100):\n", + " print(sampler.next())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cil", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 7331c73156493673daef201b6b26018a12f02583 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 2 Aug 2023 14:31:39 +0000 Subject: [PATCH 002/115] Changed how probabilities and samplers interact in SPDHG --- .../optimisation/algorithms/SPDHG_sampling.py | 259 +++++++++++++++ .../SPDHG_sampling.cpython-310.pyc | Bin 0 -> 7987 bytes .../__pycache__/sampling.cpython-310.pyc | Bin 0 -> 2552 bytes .../algorithms/testing_sampling_SPDHG.ipynb | 308 ++++++++++++++++++ .../TotalVariation.cpython-310.pyc | Bin 0 -> 7665 bytes .../TotalVariationNew.cpython-310.pyc | Bin 0 -> 9895 bytes .../__pycache__/utils.cpython-310.pyc | Bin 0 -> 1846 bytes 7 files changed, 567 insertions(+) create mode 100644 Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py create mode 100644 Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc create mode 100644 Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc create mode 100644 Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb create mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariation.cpython-310.pyc create mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc create mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/utils.cpython-310.pyc diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py new file mode 100644 index 0000000000..e860500b7e --- /dev/null +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py @@ -0,0 +1,259 @@ +# -*- coding: utf-8 -*- +# Copyright 2020 United Kingdom Research and Innovation +# Copyright 2020 The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: +# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt +# Claire Delplancke (University of Bath) + +from cil.optimisation.algorithms import Algorithm +import numpy as np +import warnings +import logging +from sampling import Sampling +class SPDHG(Algorithm): + r'''Stochastic Primal Dual Hybrid Gradient + + Problem: + + .. math:: + + \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) + + Parameters + ---------- + f : BlockFunction + Each must be a convex function with a "simple" proximal method of its conjugate + g : Function + A convex function with a "simple" proximal + operator : BlockOperator + BlockOperator must contain Linear Operators + tau : positive float, optional, default=None + Step size parameter for Primal problem + sigma : list of positive float, optional, default=None + List of Step size parameters for Dual problem + initial : DataContainer, optional, default=None + Initial point for the SPDHG algorithm + prob : list of floats, optional, default=None + List of probabilities. If None each subset will have probability = 1/number of subsets + gamma : float + parameter controlling the trade-off between the primal and dual step sizes + sampler: instnace of the Sampling class + Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets + **kwargs: + norms : list of floats + precalculated list of norms of the operators + + Example + ------- + + Example of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py + + + Note + ---- + + Convergence is guaranteed provided that [2, eq. (12)]: + + .. math:: + + \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i + + Note + ---- + + Notation for primal and dual step-sizes are reversed with comparison + to PDHG.py + + Note + ---- + + this code implements serial sampling only, as presented in [2] + (to be extended to more general case of [1] as future work) + + References + ---------- + + [1]"Stochastic primal-dual hybrid gradient algorithm with arbitrary + sampling and imaging applications", + Chambolle, Antonin, Matthias J. Ehrhardt, Peter Richtárik, and Carola-Bibiane Schonlieb, + SIAM Journal on Optimization 28, no. 4 (2018): 2783-2808. + + [2]"Faster PET reconstruction with non-smooth priors by randomization and preconditioning", + Matthias J Ehrhardt, Pawel Markiewicz and Carola-Bibiane Schönlieb, + Physics in Medicine & Biology, Volume 64, Number 22, 2019. + ''' + + def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, + initial=None, prob=None, gamma=1.,sampler=None,**kwargs): + + super(SPDHG, self).__init__(**kwargs) + + + + if f is not None and operator is not None and g is not None: + self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + initial=initial, prob=prob, gamma=gamma,sampler=sampler, norms=kwargs.get('norms', None)) + + + def set_up(self, f, g, operator, tau=None, sigma=None, \ + initial=None, prob=None, gamma=1.,sampler=None, norms=None): + + '''set-up of the algorithm + Parameters + ---------- + f : BlockFunction + Each must be a convex function with a "simple" proximal method of its conjugate + g : Function + A convex function with a "simple" proximal + operator : BlockOperator + BlockOperator must contain Linear Operators + tau : positive float, optional, default=None + Step size parameter for Primal problem + sigma : list of positive float, optional, default=None + List of Step size parameters for Dual problem + initial : DataContainer, optional, default=None + Initial point for the SPDHG algorithm + prob : list of floats, optional, default=None + List of probabilities. If None each subset will have probability = 1/number of subsets + gamma : float + parameter controlling the trade-off between the primal and dual step sizes + + **kwargs: + norms : list of floats + precalculated list of norms of the operators + ''' + logging.info("{} setting up".format(self.__class__.__name__, )) + + # algorithmic parameters + self.f = f + self.g = g + self.operator = operator + self.tau = tau + self.sigma = sigma + self.prob = prob + self.ndual_subsets = len(self.operator) + self.gamma = gamma + self.rho = .99 + self.sampler=sampler + + if self.sampler==None: + if self.prob != None: + self.sampler=Sampling(self.ndual_subsets, 'random', prob=self.prob) + else: + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + self.sampler=Sampling(self.ndual_subsets, 'random', prob=self.prob) + else: + if self.prob==None: + if self.sampler.type=='random': + self.prob=self.sampler.prob + else: + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + else: + warnings.warn('You supplied both probabilites and a sampler. The sampler will be used for sampling and the probabilites for calculationg step sizes, if not explicitly set.') + + + + if self.sigma is None: + if norms is None: + # Compute norm of each sub-operator + norms = [operator.get_item(i,0).norm() for i in range(self.ndual_subsets)] + self.norms = norms + self.sigma = [self.gamma * self.rho / ni for ni in norms] + if self.tau is None: + self.tau = min( [ pi / ( si * ni**2 ) for pi, ni, si in zip(self.prob, norms, self.sigma)] ) + self.tau *= (self.rho / self.gamma) + + # initialize primal variable + if initial is None: + self.x = self.operator.domain_geometry().allocate(0) + else: + self.x = initial.copy() + + self.x_tmp = self.operator.domain_geometry().allocate(0) + + # initialize dual variable to 0 + self.y_old = operator.range_geometry().allocate(0) + + # initialize variable z corresponding to back-projected dual variable + self.z = operator.domain_geometry().allocate(0) + self.zbar= operator.domain_geometry().allocate(0) + # relaxation parameter + self.theta = 1 + self.configured = True + logging.info("{} configured".format(self.__class__.__name__, )) + + def update(self): + # Gradient descent for the primal variable + # x_tmp = x - tau * zbar + self.x.sapyb(1., self.zbar, -self.tau, out=self.x_tmp) + + self.g.proximal(self.x_tmp, self.tau, out=self.x) + + # Choose subset + i = int(self.sampler.next()) + + # Gradient ascent for the dual variable + # y_k = y_old[i] + sigma[i] * K[i] x + y_k = self.operator[i].direct(self.x) + + y_k.sapyb(self.sigma[i], self.y_old[i], 1., out=y_k) + + y_k = self.f[i].proximal_conjugate(y_k, self.sigma[i]) + + # Back-project + # x_tmp = K[i]^*(y_k - y_old[i]) + y_k.subtract(self.y_old[i], out=self.y_old[i]) + + self.operator[i].adjoint(self.y_old[i], out = self.x_tmp) + # Update backprojected dual variable and extrapolate + # zbar = z + (1 + theta/p[i]) x_tmp + + # z = z + x_tmp + self.z.add(self.x_tmp, out =self.z) + # zbar = z + (theta/p[i]) * x_tmp + + self.z.sapyb(1., self.x_tmp, self.theta / self.prob[i], out = self.zbar) + + # save previous iteration + self.save_previous_iteration(i, y_k) + + def update_objective(self): + # p1 = self.f(self.operator.direct(self.x)) + self.g(self.x) + p1 = 0. + for i,op in enumerate(self.operator.operators): + p1 += self.f[i](op.direct(self.x)) + p1 += self.g(self.x) + + d1 = - self.f.convex_conjugate(self.y_old) + tmp = self.operator.adjoint(self.y_old) + tmp *= -1 + d1 -= self.g.convex_conjugate(tmp) + + self.loss.append([p1, d1, p1-d1]) + + @property + def objective(self): + '''alias of loss''' + return [x[0] for x in self.loss] + @property + def dual_objective(self): + return [x[1] for x in self.loss] + + @property + def primal_dual_gap(self): + return [x[2] for x in self.loss] + def save_previous_iteration(self, index, y_current): + self.y_old[index].fill(y_current) diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af5025487fe715bfddba8e7e8c1b9d1ffd0f3e3a GIT binary patch literal 7987 zcmcIp%a0t#dGG3;_s%}FTvDV+TV+Z%ILht}xppFIEz73(kZ4J(m6oxS5$Q(Hbj?f; z`!TBSCU-}(2ZIE}iwqd>)xa)b1Yr)&E$0Bf<&Zz1Z-x(sPIjOKL1F{S@2j4kogtTy z7~8Yx>guZcp7quDs14@lD;j?9ZT_46^A|PkH}o<6%i-gDc)}}aY|Un_=CLMY)Yo0T zX{dLunN#n4Gmp377QAA!$h0>!J7?$bYj$3+dq%Tl>)Tqb@F_59HI|ewx!piIQP11N zS83bw2Cn0G+cZ7>BNpfv4$ug#$!x8u+pKAn^|EfSe5`etB2#YW)W~tWU>EN*uu`(i z_qArhuGn*U7e&dg+Vl6dd#qVTf5Bc<{R;X^_A{zKXD{2wu(tZKmeZQ^VE06l-`=|N z<{R-(%bK{Moyb=NyoEXekDfp=59+mHh)7}wj=zgQsMY*$)M#5Z-c8Z)zs_U zv!dR{#^Dg>H$BHUKib*jopW#P)c9ZV?m4`^b2xr8j6L2lopW!Q4xg-0D2R^gY+2Is zL?mRWKG!Bc_1WPY{B<{I-@X?6?Z^rI3Gh{`-Q!*yM!Y4s#oK{@N9^#b+hedJD29rpGPh}h zjt@y-f*bsb64`Gx#KnXZrF27%*83U$;ITvCjx z4!4GkKn5=P5>7%zIF@29=yYJ?(On^YH9APoujSj^rZXI7o178}$r}l|!5u%0e5);p z3#Fp5o8oQP3e&Yj{+-Ez2!$(f$i~Edu@iBeaA&P$MeW{11FKwubl`DCh*lFPe~MaO zdg=CEOLoK5x%h$f!pFAlP+L;8Ew>%JIJEY}T2r90pxF@&Q+IZCM`6xfxsA)$-(I^SydZ3}+@RI);8BHa+z7m& zE3H9qx3TSbDQoEYT~~a4{ru&g<@>^IkS{jxgr+jp`e3(`GO-zqy$`Xb#8eFq#2q2K z!p8dSW1|!GtcZWGzRJaib$;%`dhOPfd!BggDKCC=bWrDF1-QyT|0*>d0*xfp0ef#>Qclh^%SRxj2Si!r9 zOP(`KO=A7xD))mr{}w;De*VJ6+6G^L`QkU%)-RsFSce8@b%)(KdrciHzIF8mYz0m+ zjAX2$f2sjL@Yg~w2oT|+w?KxxwL5l78A;+8n+{kT{+p!jj`eUT^R&p;UEx9<^0p)H zI_=>TB>vUEOo_bJ+YOy|NEY>uu$?vnH~$8I-3i>F3#KC>6bQ#_W~Yzhc=o>i`YoJr}uT+aI{h77wjjDX(ObPF_Wt! zWU+YHN4k2SA8CDK#76qa80AL!QDIaZl}6=JWj|*F;y}0cPb!oFZ_hln+-8zjF0@uj zSSMlKq?9?)#DHr^^2%={#c|M1auo2Ayb5SZaU61F0sKDHYI!V=k@iT+f0L4F5|n8s z1;k7<9wbIrM76mjhj`PGMXZq}YLKOBl5`FlL%^ z2{ZqDtziuYjke=9eh5bl;$dTJ7nz=~#wbnloKTr#W0E9<4dsf>>H%Rs<-@M`pF1EqPCYhz`hm88 zW@`0U@I4Lv)knUcC+(Qro=5vNwQCEryJj0Gr53FhVaqVzwRn)FQxh|q_^+)j$39H1 zCe=(D+2QT@lS>+!{Y#WJg!jnOh9;h}ydjXxH6Tfwtz@QrIjx(W{BmUu!TrBV9RfU} z_)z)CR+=%B&&tXjTK*@NJcJ@E7LK6>CXA#$NQPOCN&0{-w(wT1_H9mP>zO2}F>Y zWQ5_*Tm}*Pqe~&0`7@S7lao1HVGxxss4^5IPg7|S0R4vZAMGIzjZ_&G54yj68zy9P|OBCDB@3w5U|##Qcgpo<6@FlCHR_Gde{voc)9x_R=H9aXI)|*Zwyd*~|$B14(pD+h% zQ1PCEw>*U=sl4jq4uPtH*Zu+DpAo?`+Ayu`>uKsxe-(E@mK(l?PPX_lE-C9cg3G@4 zKvSL-qpnpC?vy-+=_j(N#+nfAVYi{6`u(i)Mx>5hT@Y;|Xb2 zsb>DBvB&oGJ<7)n%Fm8zD_TbSA^Vi%OF77msSX_ZA_fyZbW*w#X;lRbto9CPn0)Q~)G7$L|D50XvUtJ9(0@A`kO%(}slUi76LlTZ!Qczd7$y zDPoQLq#DcUPz!Ffnj%kQhT}&|Jh#0q(WTt_X1R zCU=t(>PhTjBoelheJEiT<(TW2Y;7IS&Xq86so~Jh`P$`gN zT~O;6Q8bKK9q0;bDO;Vr0ii2C6ovjX**M-9oKStkpmZ!#2nP_wc&vBx7nz)&8 zv44WfmIL6R;-qG5$~=^U+jS#|quR6buknSl!Wy7B-atPs6kett6%Wl4Jf6DXO$=NM zrqx1@uCSDwNeZ?DZyu$U#YKW5n`tg*P$rBjy$DW9FnZM2?Ivzm1AjMb3EOswW-_^`3>5owe4bxO={J#!N~s2mSjijI9Z z_DT2o1Ekz9YkTa&611)DlQm(CM$j|%l_edpIc<+tv;8vK5^N|x%G>%Y8s0Qsz&b!( zOjlK4X$<3dPHJ6)N{;akcEOtZefl|mwQ5opxE3Wf3AHKBa+XMjsY|+q)oP>DEnUK% z;7^|2sQQ;ujhaELPnVr{ z#BTr*QrVZ&SJ)Z0#Fq30R>J!^eRv{0x{rd)YzGB8^2)^5XXLR_Y3uiCJ2a|s$e4%o zmP^+xxMw83XTS-R0tf|<&sNZ=;8DPipkP0hMJfuoN|J|Zh)UI@;=^o^_)kJZI9Igc z3n}*#Nso%2h;!Eo_t!H5slHT1E>9r;1G6ghz%Umd!8#+&v@+xtpm36B7EFsP-=hUg zo}SQtf6|+k>c456G&DSyQdiMw!roDW$r}W7lvoS1!2gAHN@Gj_>fi$eKekN3vrT zAjmyuhnsC8Rie|FHN;^uKfYXQ3)dZAFr|__OG{L$Ku7jDJSyKSX*s69sk4R8 z^{S5BqSAY%7xaY+(~b05($!U1t=v3~8>;&BZB%`7jSxyw3hv=z4>^(U4`hR=y+nhh kEWuZ)mqIqB+R0f-O0TBMc#X_dU13#MN^oW+Rz;5Tf2{XI0RR91 literal 0 HcmV?d00001 diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..aebdc95d144e7b9b034882bb369e611ed685fd05 GIT binary patch literal 2552 zcmaJ?UvC>l5Z~SV>$9D^o1j7xZ{%!<(?1pJqGa1l&kW4&$*^k~{t1NG?EgH4m(##IWVOft4Mt*wmBn`8) zG}ADYWjzYgY$_|wu}YqltwmcuQ8HAeRSmUHFbW?im8iBw4x(K}u;@0^Y1Dn%M>Qc+ zb&wZKwJ`j7e=``5H+zF<^RWUKs&wIqoP9y*?jPv^dcAm_Y5 zwhLpA6=rVa2C^uga&;4!Fjknlgj|acSz*LAl3Ztn$juX$8_ziho$05ITmUI1utBSW zRx@Dfh!>VLqxNbEjzJHGQsHUdz3wmKx@c6qi}yXkQLc?5+|<744PVd3}{tKCutG+O5U@lvU?Q z)p{002VvK(gnrzu$G!^3FedR*?DzV#OEoW@FbYTLHKjAcNzi>>`(K5Y$=<`4Zh@G> z1ZEq+EN~0VHvV#LLU2nj1F+`!D$FX@_mor^!r+T_~*gy@w-Q4(x?8s$HM(Y=cU z4;QEh5dtuZ6;O0MNEW)=`&z?WG|dUq`jDiiT7Zf^!jVx79X#@ z0;K<}_?%Z2e-`DoP%8*W$%kh$MFp=Y-aEvsf=t%u0Z#kL*M3MFr*AB94U3y(sKHRL zz;GRc(i$tB``rZhW2Uj8Zjq+8A#kX5BKkJcpfEHj&;xJ{R(q;7(x5x4BDy)%7Y^0M zQcByQO!*CNzVyTrxLcZQ@MXZo" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reader = ZEISSDataReader()\n", + "filename = '../../../data/valnut_tomo-A.txrm'\n", + "reader.set_up(file_name=filename)\n", + "data3D = reader.read()\n", + "\n", + "# reorder data to match default order for Astra/Tigre operator\n", + "data3D.reorder('astra')\n", + "\n", + "# Get Image and Acquisition geometries\n", + "ag3D = data3D.geometry\n", + "ig3D = ag3D.get_ImageGeometry()\n", + "\n", + "# Extract vertical slice\n", + "data2D = data3D.get_slice(vertical='centre')\n", + "\n", + "# Select every 10 angles\n", + "sliced_data = Slicer(roi={'angle':(0,1601,10)})(data2D)\n", + "\n", + "# Reduce background regions\n", + "binned_data = Binner(roi={'horizontal':(120,-120,2)})(sliced_data)\n", + "\n", + "# Create absorption data \n", + "data = TransmissionAbsorptionConverter()(binned_data) \n", + "\n", + "# Remove circular artifacts\n", + "data -= np.mean(data.as_array()[80:100,0:30])\n", + "\n", + "# Get Image and Acquisition geometries for one slice\n", + "ag2D = data.geometry\n", + "ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian')\n", + "ig2D = ag2D.get_ImageGeometry()\n", + "\n", + "A = ProjectionOperator(ig2D, ag2D, device = \"gpu\")\n", + "\n", + "show2D(data)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define number of subsets\n", + "n_subsets = 10\n", + "\n", + "partitioned_data=data.partition(n_subsets, 'staggered')\n", + "show2D(partitioned_data)\n", + "\n", + "\n", + "# Initialize the lists containing the F_i's and A_i's\n", + "f_subsets = []\n", + "A_subsets = []\n", + "\n", + "# Define F_i's and A_i's\n", + "for i in range(n_subsets):\n", + " # Define F_i and put into list\n", + " fi = 0.5*L2NormSquared(b = partitioned_data[i])\n", + " f_subsets.append(fi)\n", + " # Define A_i and put into list \n", + " ageom_subset = partitioned_data[i].geometry\n", + " Ai = ProjectionOperator(ig2D, ageom_subset)\n", + " A_subsets.append(Ai)\n", + "\n", + "# Define F and K\n", + "F = BlockFunction(*f_subsets)\n", + "K = BlockOperator(*A_subsets)\n", + "\n", + "# Define G (by default the positivity constraint is on)\n", + "alpha = 0.025\n", + "G = alpha * FGP_TV()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 50 0.000 6.90194e+03\n", + " 10 50 3.976 1.59092e+02\n", + " 20 50 5.019 5.91546e+01\n", + " 30 50 5.163 4.56431e+01\n", + " 40 50 4.928 4.06590e+01\n", + " 50 50 4.903 3.73280e+01\n", + "-------------------------------------------------------\n", + " 50 50 4.903 3.73280e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + } + ], + "source": [ + "# Setup and run SPDHG for 50 iterations\n", + "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", + " update_objective_interval = 10, sampler=Sampling(n_subsets, 'sequential'))\n", + "spdhg.run()\n", + "\n", + "spdhg_recon = spdhg.solution " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 50 0.000 6.90194e+03\n", + " 10 50 4.855 1.61868e+02\n", + " 20 50 4.709 6.13522e+01\n", + " 30 50 4.840 3.85550e+01\n", + " 40 50 4.864 3.88311e+01\n", + " 50 50 4.832 3.46613e+01\n", + "-------------------------------------------------------\n", + " 50 50 4.832 3.46613e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + } + ], + "source": [ + "# Setup and run SPDHG for 50 iterations\n", + "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", + " update_objective_interval = 10, sampler=Sampling(n_subsets, 'random'))\n", + "spdhg.run()\n", + "\n", + "spdhg_recon = spdhg.solution " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 50 0.000 6.90194e+03\n", + " 10 50 5.370 1.61868e+02\n", + " 20 50 5.122 6.13522e+01\n", + " 30 50 5.079 3.85550e+01\n", + " 40 50 5.180 3.88311e+01\n", + " 50 50 5.169 3.46613e+01\n", + "-------------------------------------------------------\n", + " 50 50 5.169 3.46613e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + } + ], + "source": [ + "# Setup and run SPDHG for 50 iterations\n", + "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", + " update_objective_interval = 10)\n", + "spdhg.run()\n", + "\n", + "spdhg_recon = spdhg.solution " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Iter Max Iter Time/Iter Objective\n", + " [s] \n", + " 0 50 0.000 6.90194e+03\n", + " 10 50 4.708 1.56371e+02\n", + " 20 50 4.701 5.73612e+01\n", + " 30 50 4.564 4.46291e+01\n", + " 40 50 4.731 4.00863e+01\n", + " 50 50 4.812 3.69452e+01\n", + "-------------------------------------------------------\n", + " 50 50 4.812 3.69452e+01\n", + "Stop criterion has been reached.\n", + "\n" + ] + } + ], + "source": [ + "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", + " update_objective_interval = 10, sampler=Sampling(n_subsets, 'herman_meyer'))\n", + "spdhg.run()\n", + "\n", + "spdhg_recon = spdhg.solution " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "cil", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariation.cpython-310.pyc b/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariation.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8230db2f152ec73973b6e3c4f698f61a81d77534 GIT binary patch literal 7665 zcmb_h%X8dDdPf5o%y9S+MN$vz<+hStYiw%xuwq-x=3&c}*HsF`TCudX46_i3#*i3c zfKdY@lOr&dTB)+RIF(bbOCELGbE=X`F8K#?!zoocq;yLzIpnhWeGOn{IHc`ORfdHR z{leG%y}$k#O;6V~{PwQ=v-tU$ce~c&I0uY*DfwoO=JzyPuTkja#2BW?a zn4QXYMYUOAZC5d72DQ$__CzsO->!eDiHfjZYr^vMSH||FV2`y%^(`=K8x1|HJ?w>U z;zwaN^;IZ**GVGzd34ZV+3c6n5xy5Df7C)GuKSd7);=c#*v~4D| zZC$W!L+HW~rl@#kyE3T}6qcycU#tF0t;Ix5OuU}hw!EsSi^Pa0f$d%Xb2Vuh{F@l&ALjd>QR~=+}%ynpQCBx;UDsy#OdugL3iKbTTkvBG!zy>SN_z%rX!t>mv}N>D;5;5 zwJyzI&jZ`Xv^vcib@`wh^Qgriez`fMs{A%N?0Vy$`eCxjh1YU=LBdy-m&>*JK1mc{ zlhF0n_~Rt%cKvXVyWo^3!P9c7LOZgu6-3Sm(x)3y=snHZ#d$%18%gN}#ql2uJABtm zzV^J3KYiSFTzuw)VhJ+IyASrAF!X}>sghH&?+v6`>h`HKo!TT$xU2JHi0x>FwRIt%K-mPp)zG;=55V z6a(~;O!lKaXmG&0Lye6>9F7>^M&S$ZfX80KAC%-MffOinLmyK9^lsQ~`eEy7xj3i2 z*M)Ofj;-~kO{ zY^Spu9lShswxi#6qjYqO6zGQoK%Wk9JK=!B1|MKQEzYHbuTZ>&umLDfL8~hAucMPXfewzzdeR}S8<+}9)r_&8QIL=~Z>k0n@I74!|ALPz` z=-W&G8%F^aZ9Qqi#t!_B6Wk$E7dgB&##frl10{ocgi+$b<3GjZQ|>w;oEGQ^RY>Jv z8Aco_ox>*I0uAtT@RwK@d)&v#eE5!J-$_86*S#D2eGe?~V8_CzNJXSW^PMiO6ir3L zPrSnGj70;^KWp;OJ@*;8N&Y9;&x7*_0&kJuJ{9clevaJ*|E!F2x%YYyg>XxbA7W}O z=#{+V{Hu<$=kYJRF!EzM8}0Okw;S{%x05h!Hy~vLY5? zP+`DAcuhjFSjdI*7g5mUE1xccqj;|@@@}`uSMROdzq@+xqkD^dBYJ`U^78$~;dw;l zuOU!1S5}tqFKvCb*`#@Z)lXM{Z#icd>7Cl+tw0*HkyVtp&zQUQ(48Dfcc^U?Py9D% zBwE5!?Umlvk%6&q7_u)t)odfhsBNayuB25!D>VSCsR>w1D}WQJ1z1le(X)VI3cYEe z0nR9RLBUxCFQyY1pG#|i^JyJ$A=TOoa$OMCOG0~$tPoj@xq(!TJ^GLQ$p86A4;z=W zO5B5|mKMgcnr%~9vhD2Z>HNf2c1HO_Rv+dC*~B17XA=V-l1+|;$*fugtgNEqM^;f@ zToRYET4@_uJ?V69^xF1=Y{K3v^2@Ahi>L#2$|~J1R%DiXtz;${JWftdDVzA(ksa8$ zOtSjE6RVad8k3nBdqFFkK9$+kT_{ z&-xOKXvy`1rJqW)kW4LY9wL~AYAos|ey7OimRd#f950}xb{zu=o!5a4tD7JVmFWuxK--{Cd@~B}!L*W#l21u$T?VL?)Ax~YG zGLo5vAc6ckGs*eO_c8lMSF~r97f#Ug&SSwZuu3truFpXhXQ(4SE9$n<=vygkla;cc zYGIW@8VvMO|7Ro&UA_wlt8AOcl@wGTTY_NqL|cHM&dlkJsIW^SRI&h za|&$56#(&wE&*?e>u*UD8nvvp=S9f<<)M5B1G%D;XfaV5nk9Thj0AQ@iBe`DPbvAr z4#s#wUcz;Pz_$MyNMgdI8&k|;H7M;3c0)f$RrB?(fwkq2+5^tvvirT9OPOG)F7$5< zcrv4ZZ@`QHLqbazTLV!xGooJ7FyspM&AD;~EevoP_=Lb3fzt+&O_7VruXy%@zr%u< z?zg&`Q$Nf4*T*bmbp0vniShyU89LvmH%Fv1#*vwtg5B5fh6c$^=vw6q?a$|qDrx1| zI?>uyL<`)lztN#}X1j){V&=W)x6q$ZJwze2>xd1-9Jp%sH2G!9jwe&|1a$!5MN4rT zn1o3q$5SV??|EN}@A|S)>8}oCMXEYv3g1LHN20cq?zkdKc2fK04qSV3c*G?sFZ_}c z1I5*i#`K7|u3kuSBA+p#cUt=b@||)WeK$+_Put4BOfIH+GMCJ^7w}wa8LxEtS1D>RZ92(i z!bupfYxgysD4IJxSB@8>`c1V8UtJN^9+Ur)PKerNWMI#9`H!^c@l{YeS**4`$ycMF z&)lRr>RoxpY6BNANEPS_Pq)UW53ZnbYw7FclC!YXzZHca#$S(GQXaU!%T#}r+x z6SDBy-!gfXX(4;QE-1sirXcOkF>@bp#TB$yllR2r@onUglPCHsd>d9VGDRa4m6g;1HFHLv z(-+tcb{QjeeF{!;27kzLnf{lv`ix$KqnyHX%a}E0F+QbRI_7>uS#b@C#vGdg9&)Jk z-I-(q(M8?2&!lOCyqGjd6}$C~Jv7xXr|M(0$LPyu5l&DLvjo~Uqu7fgL@ewFK%zg?1VB!m9EPlViK8(Za>QAkvh4k6ephj$nVDPzMu3Z zT^z>Fsr2P09gWh8I{0I;{_NQC9-UzdWnt<(WO4~kLD?wN5*<0Z(L$Ck7vR73XBB$G zi z8nA{$h13(GAt7By0GTI8jw?MSq8rLNDUXEwk^F~zLO>niJVCjb{h-vLt49C!n2^rl z(wVajE>t8orA7>DbO|j85TWi81c){sb=9Dx87D5(3(51ZP#J?t5pT;o0FQ7XqW|V_ zzeNQpR9}?n@b3;(a}K>^P-KCmBq~oaR&jTqibbmWM3R3&{~kg4h8GuiT1BP4J)m$} zRJ9snr3i4R&>Y%t*Haf6Dr+^6rw=dbjfx}@2QEDgkK*4bsUh4K4y zN%t9(81R;?@cS>TDQN*NtMA1SoP(10`nO+AM>JF^CwXQ`cOMlTKr=@>vvN#hT1(e1 ziG0?!KN-*lUueN^o}sN=nLCmN`ZUD9e^A${+jb`sy@1+Nw*9>41jS6%hRj@i`IydN zAPrZA3RR?mW+aE|j5wS})kpa$omxe+A5)8>fOH6`xJ5di+X8vmY`UnTxE@^_M+m!3 z>wZ9hycXs2F~$3uX6pK)&ghQ_%v(B}`EUJW1PTO{TBSZyuh)6)&vXP36GE<4^$G$_ zRbgsOWd`ar*)@RXXkn%~D9lK5#d#g-?5ffhVoCazRZxmW;YM+$nwMo`6}zP%By{!> dqLjBGqO#hLa%TS_B$nTlYZvK0P*cx>`M-GAy<-3X literal 0 HcmV?d00001 diff --git a/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc b/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..61876cc7f5fe76b9822b8ebc3f96907ef499010e GIT binary patch literal 9895 zcmd5?OK;p*b|zV@r%JLctL10AZ+Fj3RBpK}X(l~rrR{0Ar`2P?qcPfw2N5dGV%4Q2 zmRV%^l4ZSEo5;Wb0SpAQ%PP|BdNIEvn;^(yR$R;`i@>|dBAYCdeCP5}ReE@A>O+^?Z8Px1m)>qv{kgqs@kh%`Yo6$)cT4iFrbg3W3zOTH z8~mbY2^zA7#==^^+pE6*o*^`&yCZWOFSr^qMMJ3hrPyi`E@`+S;Te5r1fQJdkHP^<7+ z{vMu9@Hu`N-&M?VgI_sLj_R0!t(6{IwtUn#h_iJqBE^CAh*K9c^>o-E1ed2Z3w=K5P z_PDju9Oq1v&96TNf$_7H9ZhDo1D~1rXKkaA0s|1)j>*Kl1 z+ho+V(soSWUuo7y#jc4Nq--+N<>TE>%3qUti6kzZWZfnm37trG6br2JjlH!Um_m3v zY<{!RwnaNWuUg!Bb3Qq~T{(2@c;opWy4a8zu(s)23vzEg;qBU8)5&&1w5>m7+_QY< zdI8%uUs#}oS-W5t^F60e!X|0ku~^@i55YGml#QN}U8b|;2|L*CvcRJuFRYc5^rgZ_ z>ko{BMqu_w1#&RoiY2n|a!dGDaL^wdq+?96)wSKhfHgLS**;hr94yoL0hq;ZvsNSg z_F#FyJ{g@443ayO1qsSA!X?|(7pRHRhukSdP(P}Q7 z*=`QoH@5rBi%W~mdL?G~V^f%23#T)pEh8$^HFu5V>~N+lY{hGJR+_dOU`B3jntdmL z5H2k)O1_c#__+yjfkAMk)g%J4@qWg|)vq598C;iR1J8koxNT6Dtg`8N=J+~mo@-?b zJqf&C&vv(188?eta*~s=ah#A)Q zgs>cGP_v!-ff(aQ^GVNaTg_~}2P0!zR%#J3N&P1m&?A0{G^x6Fd1 zLY2BEoFLKEGTYBAn2{BhaP8Dy+D+;=Lj9M?5J()EtUgTIn5{asl3d8~b}W%m{3n0p zaPDJj7h5qQDh#?|xge+wG4K0yWMk`%I%u+uvEyD~R(-2Z@+=MZXs3C(mj%}E!8q0u zM#!80pZiOApE;>)mn{!MZ@Oc$vo88W8UJ%wPYZSuoF9&cWQ=$`QbXH?XNtYf`cr6j zeBh(5Jlu`tn!NRM5ghCqu!@NlM15J--{`by&Y|AO`K0#`JaY+6wYjFxD14Hr2Bpq*7fNEV~_R z8RKSPCfu?ipYO1(ha}E$pTu-XcTZqXBTm9UZJH85FlL$JgMyZL?v??4d139^!5-E8 zz=YnMZwQCx_CAZpJA0&Ym;r=~F59sP31CaDy+qlh7M;5m5YUQ5ea*&}+3lLm8tbK= zfhaUNANr^h__01TtZM)sv2LGi~|tcKTE_L|8q!ypn*gV zF*5)k2s$LNq4CJt3`7RB{##p#7a?eJu=Gj1m;@>bQi(UwI`Qxv_`>3y5b~7C9%Cfaf+;E!5aY6nScCf(sN7^uv~9w98wsT#0_s?X1wJSqTp`>%|LQ3 z7CYJ(7KGae1a*LXJi_B7Vm`J@@R_7NhDSTL<48nGIFwL3Kq%+ZGQtc9Ypd@d5`#d0?AvggNMNU4=C)6X^q7;5tIkmY~x_5zSwZA=Lkiq1OplaIvDa( z@4}hPuillOXMss@aTl{E0OKyEetY)O@(Hy5-{s+a;~e35lkrNpc^-eH=?8O{tlK}# z7%9amma|(Y#p)FE&UG+%<=k(>M{vFtbCJr|9NCq%C@&Fpq_)>rg^HGT6-D}?dM>&A ze?TQr0yR_)wT^~tk@`wS_DBmABNw98&_k-{!y?K;m_u0%b(Ezr&y~I+J`T#A%7ik= zhXr|mi|z-7FpoYHVF6_|n8aNH^H1UK0#{H@%kpAaMtvq!Iy2&D!KI^Fo;$|sVF|78 zg%c>}@N7=3b6W9oSV4IOEd|jGt{&1n*SPXT39b+8wLB%E)JOjkQ~QUX>@P6{V4Gf( zyePMN!a{b-s z%ov%|k1E5kEh=Y0P*l#2Jen8@g`#2-h(wy(i*ndsl$VMW*wjdb5~HlxY02v^MDnV6;GJu0qHag~ZoRD4LqO)9=e#YZT@c@2YX0kbI|#AE2|il@*^*4LL^TpK$paih{O(>+~+po3Twp(ht??u;i|2p+E`M zKt0s_sQ{VQqgY;j!>#tO)+t6TSKDD*|AD*|s3i4DGB>>HuNseNHZ6S?yFsKzE z^axK0e77x8#DYIAn133>15fkr~}J} z>3mXTO|L>DN@_*NrOm3kcHwhjMHj7uVki-WY%TKqD-AfMFepJfNYkHl9d%mw zLbksgo|l7Zv|c<^f2#cDUk@swJ^-%h=$#p0lUzJYnCn~uzEOEmw&3j=dd$+ixJpv; z%HnTT#qG$E?*RqnlaW9t*kkd!GN^`m;2V_56Cj`;gC2~yjQy$NAHxbS&p|q$X{hIq zu7KLfa55}V4LU$|^nHe&poBPbwQ~)aswiiK^m8q^esqItyb@0EiAz$Gj@8QwpTO!m zR(~I3N*EzI1L`KYc0~#G>k2fafctnq`2kQ^r-ZX3G*)`Pi@TeDqmu5$J4O9+@WIhd zUOi$!T$9HdVKTQQ+a{@vETgIfABM$46{U8lKGQI2DJ*tA!YuOCl3kS0{%Ht}kx#R@vES34{i-%$OcCFVw7Jo|9k#7+Mh{TVnz}sden!;;?Ez3y#PgH^f@CXx2fEH=JW$`if)7u_k z)g2l~zFoSVs3bFjJ!dbv5ChNQJb5{+MfsrHGoD8iFvx_^4Ao&&phi(Gr&VEK;9ETCf-uVv?gg!U34; z9Hu#GsqbSWC3pv4prVzA9#qdwYXx-%e+3|#0x(UbFa@7FgR7+K>NLLTei}Wfjux$o zmXbDy=T-FA)fxS!HjN(W53~vokgKY*=r@z2S)~W~-nbVdM10yUjiD(*AsK=t$&>o2 z?XQn{%?#xvxzg-(-VOO|VSf3Md`n=UAoqBJkZ@w(s3of|NS%QIF0;Hk&*!`T8IddZsih%?gWE71g~;jdqp9- zbkqop^E`J%E=Y+%KVa-{ve&KYn=y)u+Yord_%^+Mqy~CZ9YcG(HlQbaR#0c_WQJwD znF>HN3q_mpn|(5QqZ7uqyP4ul{73*<$Y!eVO$H3S?QtJTahXAp784SZ#gzO08LN&n zkk&gGj79Y1FVZFH?MAv@x*XfI1>QWjESxiCdL4&cMT(~DwPI{JDc%@vMclw`RC!9# zi;Quk0TO2&IZ4G19Xa8xN?}ed=+pmk7Enu zWz4-M=oe68f~srlt8tEMRV>i5(=@eA$Ie(;mQF=PGI`Uzw|1De;o76)Wm=RVI;YQ_(e~IqIV+je3^S5M<(H z(nn@qWX|P`{^_qMbSpC!!sUgjk}mpnGJjX3_*yYl-@JiE1rTH9)miQ0=4*sCbF`dWnjcs0dK; z4XP&D=^E7HCmq0q%h8=9tf~$pJJm?h5X~P*vMySp4ezdq#TvXfg!i2EI#<}M9<>`! z2j7lUotm`BKb6Hu8a07*I7l--80;VJOC8Wmw|QA^Lw(yX6nIkU?Pn8nQsgdIlqMaen&W=9kH`4{9lbp^X{NWziH)(wYOy{n z_7F>AU}CCJF)MY~A%RI(_n+VxqJ2T1gMjA5&#!g^2<$f50%8Jm20BMLevAR+G@#1HkZi|(R3 zBb7L21p2!uWoBM`%+kGRT15{;muNv4=qcF))(Ax%MQvr zxhuHah;6U5lsU=2 zJ0d{@cylCmBem)8e6jmfy$-9ZH^B6$dK3NSvHxEm9P$80=uI%UePFQ9h=!EW7&@cg z#fcu+HtOYA@sT_))Jw;^LJ`{_ACJn3!WongCJEd%mpH*W*KT}Xh;b(O3$s^@bKy?F zU6nSdhkK=4ZBtwy11M@VBDd6Cz8>p!m($Kn70 literal 0 HcmV?d00001 From 2bce666a30edabb55c0e09c7b416aef19239f59a Mon Sep 17 00:00:00 2001 From: Margaret Duff <43645617+MargaretDuff@users.noreply.github.com> Date: Tue, 8 Aug 2023 12:23:29 +0100 Subject: [PATCH 003/115] Update sampling.py Quick docstring Signed-off-by: Margaret Duff <43645617+MargaretDuff@users.noreply.github.com> --- Wrappers/Python/cil/optimisation/algorithms/sampling.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampling.py b/Wrappers/Python/cil/optimisation/algorithms/sampling.py index b41b7032c8..3481e170b5 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/sampling.py +++ b/Wrappers/Python/cil/optimisation/algorithms/sampling.py @@ -19,7 +19,9 @@ import numpy as np import math class Sampling(): - + + r"""Takes an integer number of subsets and a sampling type and returns a class object with a next function. On each call of next, an integer value between 0 and the number of subsets is returned, the next sample.""" + def __init__(self, num_subsets, sampling_type='sequential', prob=None, seed=99): self.type=sampling_type self.num_subsets=num_subsets @@ -98,4 +100,4 @@ def show_epochs(self, num_epochs=2): elif self.type=='herman_meyer': for i in range(num_epochs): print('Epoch {}: '.format(i), self.order) - \ No newline at end of file + From ea759c5a87ba99a75cc21eb6d2040aeea1800555 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 9 Aug 2023 10:59:04 +0000 Subject: [PATCH 004/115] Changed to factory method style and added in permuatations --- .../algorithms/{sampling.py => sampler.py} | 101 +++++++++++------- 1 file changed, 62 insertions(+), 39 deletions(-) rename Wrappers/Python/cil/optimisation/algorithms/{sampling.py => sampler.py} (52%) diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampling.py b/Wrappers/Python/cil/optimisation/algorithms/sampler.py similarity index 52% rename from Wrappers/Python/cil/optimisation/algorithms/sampling.py rename to Wrappers/Python/cil/optimisation/algorithms/sampler.py index 3481e170b5..5676ed1da5 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/sampling.py +++ b/Wrappers/Python/cil/optimisation/algorithms/sampler.py @@ -18,31 +18,58 @@ import numpy as np import math -class Sampling(): +import time +class Sampler(): r"""Takes an integer number of subsets and a sampling type and returns a class object with a next function. On each call of next, an integer value between 0 and the number of subsets is returned, the next sample.""" - def __init__(self, num_subsets, sampling_type='sequential', prob=None, seed=99): + + @staticmethod + def hermanMeyer(num_subsets): + order=_herman_meyer_order(self.num_subsets) + sampler=Sampler(num_subsets, sampling_type='herman_meyer', order=order) + return sampler + + @staticmethod + def sequential(num_subsets): + order=range(self.num_subsets) + sampler=Sampler(num_subsets, sampling_type='sequential', order=order) + return sampler + + @staticmethod + def randomWithReplacement(num_subsets, prob=None, seed=None): + if prob==None: + prob = [1/self.num_subsets] * self.num_subsets + else: + prob=prob + sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) + return sampler + + @staticmethod + def randomWithoutReplacement(num_subsets, seed=None): + order=range(self.num_subsets) + sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) + return sampler + + + def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): self.type=sampling_type self.num_subsets=num_subsets - self.seed=seed - - self.last_subset=-1 - if self.type=='sequential': - pass - elif self.type=='random': - if prob==None: - self.prob = [1/self.num_subsets] * self.num_subsets - else: - self.prob=prob - elif self.type=='herman_meyer': - - self.order=self.herman_meyer_order(self.num_subsets) + if seed !=None: + self.seed=seed else: - raise NameError('Please choose from sequential, random, herman_meyer') - + self.seed=int(time.time()) + self.order=order + if order!=None: + self.iterator=self._next_order + self.prob=prob + if prob!=None: + self.iterator=self._next_prob + self.shuffle=shuffle + self.last_subset=self.num_subsets-1 + - def herman_meyer_order(self, n): + def _herman_meyer_order(self, n): # Assuming that the subsets are in geometrical order n_variable = n i = 2 @@ -75,29 +102,25 @@ def herman_meyer_order(self, n): order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping return order + + def _next_order(self) + if shuffle=True & self.last_subset==self.numsubsets-1: + self.order=np.random.perumatation(self.order) + self.last_subset= (self.last_subset+1)%self.num_subsets + return(self.order[self.last_subset]) + + def _next_prob(self): + return int(np.random.choice(self.num_subsets, 1, p=self.prob)) + def next(self): - if self.type=='sequential': - self.last_subset= (self.last_subset+1)%self.num_subsets - return self.last_subset - elif self.type=='random': - if self.last_subset==-1: - np.random.seed(self.seed) - self.last_subset=0 - return int(np.random.choice(self.num_subsets, 1, p=self.prob)) - elif self.type=='herman_meyer': - self.last_subset= (self.last_subset+1)%self.num_subsets - return(self.order[self.last_subset]) + return (self.iterator()) def show_epochs(self, num_epochs=2): - if self.type=='sequential': - for i in range(num_epochs): - print('Epoch {}: '.format(i), [j for j in range(self.num_subsets)]) - elif self.type=='random': - np.random.seed(self.seed) - for i in range(num_epochs): - print('Epoch {}: '.format(i), np.random.choice(self.num_subsets, self.num_subsets, p=self.prob)) - elif self.type=='herman_meyer': - for i in range(num_epochs): - print('Epoch {}: '.format(i), self.order) + current_state=np.random.get_state() + np.random.seed(self.seed) + for i in range(num_epochs): + rint('Epoch {}: '.format(i), [next() for _ in range(self.num_subsets)]) + np.random.set_state(current_state) + From d1909a381832ee198cc2e0dfe220cba684dda09d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 9 Aug 2023 13:20:34 +0000 Subject: [PATCH 005/115] Debugging and fixing random generator in show epochs --- .../cil/optimisation/algorithms/sampler.py | 109 +++---- .../algorithms/testing_sampling.ipynb | 277 +++++++++++++----- 2 files changed, 270 insertions(+), 116 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampler.py b/Wrappers/Python/cil/optimisation/algorithms/sampler.py index 5676ed1da5..aaf1334ab5 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/sampler.py +++ b/Wrappers/Python/cil/optimisation/algorithms/sampler.py @@ -23,31 +23,66 @@ class Sampler(): r"""Takes an integer number of subsets and a sampling type and returns a class object with a next function. On each call of next, an integer value between 0 and the number of subsets is returned, the next sample.""" + @staticmethod def hermanMeyer(num_subsets): - order=_herman_meyer_order(self.num_subsets) + @staticmethod + def _herman_meyer_order(n): + # Assuming that the subsets are in geometrical order + n_variable = n + i = 2 + factors = [] + while i * i <= n_variable: + if n_variable % i: + i += 1 + else: + n_variable //= i + factors.append(i) + if n_variable > 1: + factors.append(n_variable) + n_factors = len(factors) + order = [0 for _ in range(n)] + value = 0 + for factor_n in range(n_factors): + n_rep_value = 0 + if factor_n == 0: + n_change_value = 1 + else: + n_change_value = math.prod(factors[:factor_n]) + for element in range(n): + mapping = value + n_rep_value += 1 + if n_rep_value >= n_change_value: + value = value + 1 + n_rep_value = 0 + if value == factors[factor_n]: + value = 0 + order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping + return order + + order=_herman_meyer_order(num_subsets) sampler=Sampler(num_subsets, sampling_type='herman_meyer', order=order) return sampler @staticmethod def sequential(num_subsets): - order=range(self.num_subsets) + order=list(range(num_subsets)) sampler=Sampler(num_subsets, sampling_type='sequential', order=order) return sampler @staticmethod def randomWithReplacement(num_subsets, prob=None, seed=None): if prob==None: - prob = [1/self.num_subsets] * self.num_subsets - else: - prob=prob + prob = [1/num_subsets] *num_subsets + else: + prob=prob sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) return sampler @staticmethod def randomWithoutReplacement(num_subsets, seed=None): - order=range(self.num_subsets) + order=list(range(num_subsets)) sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) return sampler @@ -59,7 +94,9 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N self.seed=seed else: self.seed=int(time.time()) + self.generator=np.random.RandomState(self.seed) self.order=order + self.initial_order=order if order!=None: self.iterator=self._next_order self.prob=prob @@ -68,59 +105,31 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N self.shuffle=shuffle self.last_subset=self.num_subsets-1 - - def _herman_meyer_order(self, n): - # Assuming that the subsets are in geometrical order - n_variable = n - i = 2 - factors = [] - while i * i <= n_variable: - if n_variable % i: - i += 1 - else: - n_variable //= i - factors.append(i) - if n_variable > 1: - factors.append(n_variable) - n_factors = len(factors) - order = [0 for _ in range(n)] - value = 0 - for factor_n in range(n_factors): - n_rep_value = 0 - if factor_n == 0: - n_change_value = 1 - else: - n_change_value = math.prod(factors[:factor_n]) - for element in range(n): - mapping = value - n_rep_value += 1 - if n_rep_value >= n_change_value: - value = value + 1 - n_rep_value = 0 - if value == factors[factor_n]: - value = 0 - order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping - return order + - def _next_order(self) - if shuffle=True & self.last_subset==self.numsubsets-1: - self.order=np.random.perumatation(self.order) - self.last_subset= (self.last_subset+1)%self.num_subsets - return(self.order[self.last_subset]) + def _next_order(self): + # print(self.last_subset) + if self.shuffle==True and self.last_subset==self.num_subsets-1: + self.order=self.generator.permutation(self.order) + print(self.order) + self.last_subset= (self.last_subset+1)%self.num_subsets + return(self.order[self.last_subset]) def _next_prob(self): - return int(np.random.choice(self.num_subsets, 1, p=self.prob)) + return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) def next(self): return (self.iterator()) def show_epochs(self, num_epochs=2): - current_state=np.random.get_state() - np.random.seed(self.seed) + save_generator=self.generator + save_order=self.order + self.order=self.initial_order + self.generator=np.random.RandomState(self.seed) for i in range(num_epochs): - rint('Epoch {}: '.format(i), [next() for _ in range(self.num_subsets)]) - np.random.set_state(current_state) - + print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) + self.generator=save_generator + self.order=save_order diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb index f135686d3c..a187c08575 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb @@ -11,7 +11,7 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import os\n", - "from sampling import Sampling\n" + "from sampler import Sampler\n" ] }, { @@ -132,7 +132,7 @@ } ], "source": [ - "sampler=Sampling(10,'sequential')\n", + "sampler=Sampler.sequential(10)\n", "sampler.show_epochs(5)\n", "for _ in range(100):\n", " print(sampler.next())" @@ -147,116 +147,131 @@ "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: [ 7 5 9 0 8 6 3 0 10 0 8]\n", - "Epoch 1: [ 8 4 5 10 4 10 5 1 8 2 6]\n", - "Epoch 2: [3 8 9 2 7 1 4 1 1 2 5]\n", - "Epoch 3: [ 0 2 0 9 6 1 10 5 0 5 7]\n", - "Epoch 4: [ 8 9 2 10 5 2 6 4 2 10 10]\n", - "7\n", - "5\n", - "9\n", - "0\n", - "8\n", - "6\n", + "[ 2 4 3 0 10 5 6 8 7 1 9]\n", + "Epoch 0: [2, 4, 3, 0, 10, 5, 6, 8, 7, 1, 9]\n", + "[ 2 7 6 1 4 10 5 8 0 3 9]\n", + "Epoch 1: [2, 7, 6, 1, 4, 10, 5, 8, 0, 3, 9]\n", + "[ 3 9 8 5 7 10 4 2 6 1 0]\n", + "Epoch 2: [3, 9, 8, 5, 7, 10, 4, 2, 6, 1, 0]\n", + "[ 3 1 9 10 4 2 0 6 7 5 8]\n", + "Epoch 3: [3, 1, 9, 10, 4, 2, 0, 6, 7, 5, 8]\n", + "[ 6 8 1 5 10 7 4 9 0 3 2]\n", + "Epoch 4: [6, 8, 1, 5, 10, 7, 4, 9, 0, 3, 2]\n", + "[ 2 4 3 0 10 5 6 8 7 1 9]\n", + "2\n", + "4\n", "3\n", "0\n", "10\n", - "0\n", - "8\n", - "8\n", - "4\n", "5\n", - "10\n", - "4\n", - "10\n", - "5\n", - "1\n", - "8\n", - "2\n", "6\n", - "3\n", "8\n", - "9\n", - "2\n", "7\n", "1\n", - "4\n", - "1\n", - "1\n", - "2\n", - "5\n", - "0\n", - "2\n", - "0\n", "9\n", + "[ 2 7 6 1 4 10 5 8 0 3 9]\n", + "2\n", + "7\n", "6\n", "1\n", + "4\n", "10\n", "5\n", + "8\n", "0\n", + "3\n", + "9\n", + "[ 3 9 8 5 7 10 4 2 6 1 0]\n", + "3\n", + "9\n", + "8\n", "5\n", "7\n", - "8\n", - "9\n", - "2\n", "10\n", - "5\n", - "2\n", - "6\n", "4\n", "2\n", - "10\n", - "10\n", + "6\n", + "1\n", + "0\n", + "[ 3 1 9 10 4 2 0 6 7 5 8]\n", + "3\n", + "1\n", "9\n", + "10\n", "4\n", - "7\n", - "9\n", + "2\n", "0\n", - "4\n", + "6\n", "7\n", + "5\n", + "8\n", + "[ 6 8 1 5 10 7 4 9 0 3 2]\n", + "6\n", + "8\n", + "1\n", + "5\n", "10\n", "7\n", - "7\n", - "2\n", + "4\n", + "9\n", + "0\n", "3\n", + "2\n", + "[ 4 1 2 7 0 5 10 3 8 9 6]\n", + "4\n", "1\n", - "3\n", + "2\n", "7\n", - "10\n", "0\n", + "5\n", + "10\n", "3\n", - "0\n", + "8\n", "9\n", - "7\n", + "6\n", + "[ 5 6 9 3 10 4 1 0 8 2 7]\n", + "5\n", + "6\n", "9\n", + "3\n", "10\n", + "4\n", "1\n", - "5\n", + "0\n", + "8\n", + "2\n", + "7\n", + "[ 6 7 0 3 1 10 8 5 4 2 9]\n", "6\n", - "5\n", "7\n", - "9\n", - "2\n", + "0\n", + "3\n", "1\n", - "6\n", + "10\n", + "8\n", + "5\n", + "4\n", "2\n", "9\n", - "5\n", + "[ 9 4 7 3 6 0 5 8 10 2 1]\n", + "9\n", + "4\n", "7\n", "3\n", - "1\n", - "3\n", - "1\n", - "2\n", + "6\n", + "0\n", "5\n", - "3\n", "8\n", - "7\n" + "10\n", + "2\n", + "1\n", + "[ 3 8 10 7 2 0 6 1 9 5 4]\n", + "3\n" ] } ], "source": [ - "sampler=Sampling(11,'random')\n", + "sampler=Sampler.randomWithoutReplacement(11)\n", "sampler.show_epochs(5)\n", "for _ in range(100):\n", " print(sampler.next())" @@ -380,12 +395,142 @@ } ], "source": [ - "sampler=Sampling(60,'herman_meyer')\n", + "sampler=Sampler.hermanMeyer(60)\n", "sampler.show_epochs(5)\n", "for _ in range(100):\n", " print(sampler.next())" ] }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: [3, 3, 10, 8, 7, 9, 1, 3, 10, 5, 2]\n", + "Epoch 1: [4, 1, 10, 8, 8, 3, 4, 6, 0, 1, 8]\n", + "Epoch 2: [8, 4, 3, 9, 5, 5, 8, 0, 7, 0, 4]\n", + "Epoch 3: [9, 4, 10, 8, 2, 1, 8, 4, 8, 6, 9]\n", + "Epoch 4: [8, 1, 2, 1, 10, 9, 2, 9, 0, 0, 4]\n", + "3\n", + "3\n", + "10\n", + "8\n", + "7\n", + "9\n", + "1\n", + "3\n", + "10\n", + "5\n", + "2\n", + "4\n", + "1\n", + "10\n", + "8\n", + "8\n", + "3\n", + "4\n", + "6\n", + "0\n", + "1\n", + "8\n", + "8\n", + "4\n", + "3\n", + "9\n", + "5\n", + "5\n", + "8\n", + "0\n", + "7\n", + "0\n", + "4\n", + "9\n", + "4\n", + "10\n", + "8\n", + "2\n", + "1\n", + "8\n", + "4\n", + "8\n", + "6\n", + "9\n", + "8\n", + "1\n", + "2\n", + "1\n", + "10\n", + "9\n", + "2\n", + "9\n", + "0\n", + "0\n", + "4\n", + "8\n", + "4\n", + "6\n", + "7\n", + "7\n", + "6\n", + "3\n", + "3\n", + "0\n", + "5\n", + "8\n", + "8\n", + "3\n", + "1\n", + "7\n", + "5\n", + "4\n", + "8\n", + "3\n", + "8\n", + "5\n", + "5\n", + "3\n", + "10\n", + "8\n", + "5\n", + "6\n", + "3\n", + "3\n", + "2\n", + "8\n", + "4\n", + "6\n", + "3\n", + "7\n", + "10\n", + "4\n", + "2\n", + "7\n", + "6\n", + "6\n", + "1\n", + "5\n", + "8\n", + "5\n", + "Epoch 0: [3, 3, 10, 8, 7, 9, 1, 3, 10, 5, 2]\n", + "Epoch 1: [4, 1, 10, 8, 8, 3, 4, 6, 0, 1, 8]\n", + "Epoch 2: [8, 4, 3, 9, 5, 5, 8, 0, 7, 0, 4]\n", + "Epoch 3: [9, 4, 10, 8, 2, 1, 8, 4, 8, 6, 9]\n", + "Epoch 4: [8, 1, 2, 1, 10, 9, 2, 9, 0, 0, 4]\n" + ] + } + ], + "source": [ + "sampler=Sampler.randomWithReplacement(11)\n", + "sampler.show_epochs(5)\n", + "for _ in range(100):\n", + " print(sampler.next())\n", + "sampler.show_epochs(5)" + ] + }, { "cell_type": "code", "execution_count": null, From 98b0694db3b2e60e2d89adbb16c1336518a82cf9 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 9 Aug 2023 15:32:37 +0000 Subject: [PATCH 006/115] Testing SPDHG --- .../optimisation/algorithms/SPDHG_sampling.py | 16 ++- .../SPDHG_sampling.cpython-310.pyc | Bin 7987 -> 8022 bytes .../algorithms/testing_sampling.ipynb | 118 ++++-------------- .../algorithms/testing_sampling_SPDHG.ipynb | 102 +++++++++------ 4 files changed, 91 insertions(+), 145 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py index e860500b7e..ea5083ea08 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py @@ -22,7 +22,7 @@ import numpy as np import warnings import logging -from sampling import Sampling +from sampler import Sampler class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -50,7 +50,7 @@ class SPDHG(Algorithm): List of probabilities. If None each subset will have probability = 1/number of subsets gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: instnace of the Sampling class + sampler: instnace of the Sampler class Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets **kwargs: norms : list of floats @@ -144,20 +144,18 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ self.tau = tau self.sigma = sigma self.prob = prob - self.ndual_subsets = len(self.operator) + self.ndual_subsets = len(self.f) self.gamma = gamma self.rho = .99 self.sampler=sampler if self.sampler==None: - if self.prob != None: - self.sampler=Sampling(self.ndual_subsets, 'random', prob=self.prob) - else: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets - self.sampler=Sampling(self.ndual_subsets, 'random', prob=self.prob) + if self.prob == None: + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) else: if self.prob==None: - if self.sampler.type=='random': + if self.sampler.prob!=None: self.prob=self.sampler.prob else: self.prob = [1/self.ndual_subsets] * self.ndual_subsets diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc index af5025487fe715bfddba8e7e8c1b9d1ffd0f3e3a..1736e8dc51b534726c18e85e3a339f29a2dde79b 100644 GIT binary patch delta 1054 zcmZ`%OHUI~6rMAs(=xQ>)t1s1cq5CfDzf&?}g z$z5tpo4638Zt9Mei9f(-Vj>A!jccRv5u@j{k$~bXzWd$peCL}v_fER)ZJRA-wW<<6 zHJfjkt$M?j$Tjtars9)fKDJS4-*~hPchfbHmm`OHy485y1nQ7fX&EI46dk?m}4wJ2*j=Enoqstjg&XXB0}BuzA}!9g5G6@)MLs zKP5jV6jw8}h?B1RyyN6Bgc#$k;+882Wg_J&gO}+St|Cy*kh@8|EA=QXMBBypQXg7e z?gscEy4?>Cdq}1UH)T%qb9&=JbAJ^sPor{{s#T)L&4Sq_BARUC`cf-d|gl@4E~0yPI8<_*fz&`EFR|iEbk|6fMAHALtOHA!hm?-@3hsD N5G0_x6kq(Oegkjb_cH(h delta 1063 zcmZ`(OHUI~6rMBF4rSFl|Bny!{nGI26_Pfd)^m}6AWKp`9sTlw%=4W~2Fr*=%t1h8KL$=Z1|F3?m z<}+nn;&)PbKfESqrR%^PEWdrmku0H@X*e!T!!0d^QT_TXU|D1NGmex-I%@goa;!IJ zl3rGTH7QvtR$Tk0USK6JU6zs3KIY7j*B`T|)N~+2kLLfYYRpOL;0|{P*E_q*|5%4< z;C_?25G#^W8kjpRW2!P@%RmMkATgy+s`X@N+(&I@PUX=Ui;vX;cj1OiE?kO_n~8A? z_hOKl1B2py@jd$*U`bdd6YyAkD4C3eaha22!%M)uNO>WFpP&NaDUnJsr}x%u7_DI* zK`kdIhBvIc{m<@uO{f$V-Yf1ZYV{B(2x8IuZqG?1x}hp6Y@NWy7?C!j$H;6OjVBU0HELOdF;=UtkDQaOW^Rg(Kr^fg9$2gklAY#Sk~vMy=}G=I z?Pt+pw5X@3S}krGA^0dB7_D$dECjP2guZMOTJeI>n57{NyMEYWJw9jtVH zLHbEXD3m94VFq=v81Tz{J-dOjc@4pO)c=xykfTq04>oNjH-)MSzL9zXVbUvp1-*iY z+VFio54EVBDE^ehYUl(si2Cy8NEcbV5poWT$E`u0oZ#n3J5O+tpi|r~?}Q%ls=TwL RiG(_YoFlRM3lRSB;oplJ`1=3= diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb index a187c08575..64a25a7c76 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb @@ -403,132 +403,56 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: [3, 3, 10, 8, 7, 9, 1, 3, 10, 5, 2]\n", - "Epoch 1: [4, 1, 10, 8, 8, 3, 4, 6, 0, 1, 8]\n", - "Epoch 2: [8, 4, 3, 9, 5, 5, 8, 0, 7, 0, 4]\n", - "Epoch 3: [9, 4, 10, 8, 2, 1, 8, 4, 8, 6, 9]\n", - "Epoch 4: [8, 1, 2, 1, 10, 9, 2, 9, 0, 0, 4]\n", - "3\n", - "3\n", - "10\n", - "8\n", + "Epoch 0: [7, 1, 6, 6, 4, 7, 6, 7, 7, 4, 5]\n", + "Epoch 1: [6, 3, 4, 7, 1, 4, 9, 6, 9, 2, 5]\n", + "Epoch 2: [4, 7, 7, 4, 3, 1, 10, 10, 6, 0, 1]\n", + "Epoch 3: [6, 1, 10, 5, 9, 2, 5, 10, 5, 8, 1]\n", + "Epoch 4: [8, 8, 3, 6, 7, 8, 4, 7, 10, 7, 9]\n", "7\n", - "9\n", - "1\n", - "3\n", - "10\n", - "5\n", - "2\n", - "4\n", "1\n", - "10\n", - "8\n", - "8\n", - "3\n", - "4\n", "6\n", - "0\n", - "1\n", - "8\n", - "8\n", - "4\n", - "3\n", - "9\n", - "5\n", - "5\n", - "8\n", - "0\n", - "7\n", - "0\n", - "4\n", - "9\n", - "4\n", - "10\n", - "8\n", - "2\n", - "1\n", - "8\n", - "4\n", - "8\n", "6\n", - "9\n", - "8\n", - "1\n", - "2\n", - "1\n", - "10\n", - "9\n", - "2\n", - "9\n", - "0\n", - "0\n", - "4\n", - "8\n", "4\n", - "6\n", - "7\n", "7\n", "6\n", - "3\n", - "3\n", - "0\n", - "5\n", - "8\n", - "8\n", - "3\n", - "1\n", "7\n", - "5\n", + "7\n", "4\n", - "8\n", - "3\n", - "8\n", - "5\n", - "5\n", - "3\n", - "10\n", - "8\n", "5\n", + "Epoch 0: [7, 1, 6, 6, 4, 7, 6, 7, 7, 4, 5]\n", + "Epoch 1: [6, 3, 4, 7, 1, 4, 9, 6, 9, 2, 5]\n", + "Epoch 2: [4, 7, 7, 4, 3, 1, 10, 10, 6, 0, 1]\n", + "Epoch 3: [6, 1, 10, 5, 9, 2, 5, 10, 5, 8, 1]\n", + "Epoch 4: [8, 8, 3, 6, 7, 8, 4, 7, 10, 7, 9]\n", "6\n", "3\n", - "3\n", - "2\n", - "8\n", "4\n", - "6\n", - "3\n", "7\n", - "10\n", + "1\n", "4\n", - "2\n", - "7\n", - "6\n", + "9\n", "6\n", - "1\n", - "5\n", - "8\n", - "5\n", - "Epoch 0: [3, 3, 10, 8, 7, 9, 1, 3, 10, 5, 2]\n", - "Epoch 1: [4, 1, 10, 8, 8, 3, 4, 6, 0, 1, 8]\n", - "Epoch 2: [8, 4, 3, 9, 5, 5, 8, 0, 7, 0, 4]\n", - "Epoch 3: [9, 4, 10, 8, 2, 1, 8, 4, 8, 6, 9]\n", - "Epoch 4: [8, 1, 2, 1, 10, 9, 2, 9, 0, 0, 4]\n" + "9\n", + "2\n", + "5\n" ] } ], "source": [ "sampler=Sampler.randomWithReplacement(11)\n", "sampler.show_epochs(5)\n", - "for _ in range(100):\n", + "for _ in range(11):\n", " print(sampler.next())\n", - "sampler.show_epochs(5)" + "sampler.show_epochs(5)\n", + "for _ in range(11):\n", + " print(sampler.next())" ] }, { diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb index be4d3a1752..78fe5957cf 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb @@ -28,7 +28,7 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import os\n", - "from sampling import Sampling\n" + "from sampler import Sampler\n" ] }, { @@ -49,7 +49,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 2, @@ -106,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -138,13 +138,13 @@ " fi = 0.5*L2NormSquared(b = partitioned_data[i])\n", " f_subsets.append(fi)\n", " # Define A_i and put into list \n", - " ageom_subset = partitioned_data[i].geometry\n", - " Ai = ProjectionOperator(ig2D, ageom_subset)\n", - " A_subsets.append(Ai)\n", + "ageom_subset = partitioned_data.geometry\n", + "A = ProjectionOperator(ig2D, ageom_subset)\n", + "\n", "\n", "# Define F and K\n", "F = BlockFunction(*f_subsets)\n", - "K = BlockOperator(*A_subsets)\n", + "K = A\n", "\n", "# Define G (by default the positivity constraint is on)\n", "alpha = 0.025\n", @@ -153,7 +153,26 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "print(ageom_subset)\n", + "print(A)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -163,13 +182,13 @@ " Iter Max Iter Time/Iter Objective\n", " [s] \n", " 0 50 0.000 6.90194e+03\n", - " 10 50 3.976 1.59092e+02\n", - " 20 50 5.019 5.91546e+01\n", - " 30 50 5.163 4.56431e+01\n", - " 40 50 4.928 4.06590e+01\n", - " 50 50 4.903 3.73280e+01\n", + " 10 50 3.313 1.59092e+02\n", + " 20 50 3.019 5.91546e+01\n", + " 30 50 2.909 4.56431e+01\n", + " 40 50 2.849 4.06590e+01\n", + " 50 50 2.813 3.73280e+01\n", "-------------------------------------------------------\n", - " 50 50 4.903 3.73280e+01\n", + " 50 50 2.813 3.73280e+01\n", "Stop criterion has been reached.\n", "\n" ] @@ -178,7 +197,7 @@ "source": [ "# Setup and run SPDHG for 50 iterations\n", "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampling(n_subsets, 'sequential'))\n", + " update_objective_interval = 10, sampler=Sampler.sequential(n_subsets))\n", "spdhg.run()\n", "\n", "spdhg_recon = spdhg.solution " @@ -186,7 +205,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -196,13 +215,13 @@ " Iter Max Iter Time/Iter Objective\n", " [s] \n", " 0 50 0.000 6.90194e+03\n", - " 10 50 4.855 1.61868e+02\n", - " 20 50 4.709 6.13522e+01\n", - " 30 50 4.840 3.85550e+01\n", - " 40 50 4.864 3.88311e+01\n", - " 50 50 4.832 3.46613e+01\n", + " 10 50 0.071 1.68032e+02\n", + " 20 50 0.114 4.89967e+01\n", + " 30 50 0.096 4.18854e+01\n", + " 40 50 0.096 3.86103e+01\n", + " 50 50 0.092 3.70240e+01\n", "-------------------------------------------------------\n", - " 50 50 4.832 3.46613e+01\n", + " 50 50 0.092 3.70240e+01\n", "Stop criterion has been reached.\n", "\n" ] @@ -211,7 +230,7 @@ "source": [ "# Setup and run SPDHG for 50 iterations\n", "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampling(n_subsets, 'random'))\n", + " update_objective_interval = 10, sampler=Sampler.randomWithReplacement(n_subsets))\n", "spdhg.run()\n", "\n", "spdhg_recon = spdhg.solution " @@ -219,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -229,13 +248,18 @@ " Iter Max Iter Time/Iter Objective\n", " [s] \n", " 0 50 0.000 6.90194e+03\n", - " 10 50 5.370 1.61868e+02\n", - " 20 50 5.122 6.13522e+01\n", - " 30 50 5.079 3.85550e+01\n", - " 40 50 5.180 3.88311e+01\n", - " 50 50 5.169 3.46613e+01\n", + "[8 7 5 4 3 2 6 0 9 1]\n", + " 10 50 2.593 1.57735e+02\n", + "[2 0 9 6 3 5 1 4 8 7]\n", + " 20 50 2.916 5.82732e+01\n", + "[3 4 1 9 5 6 2 8 7 0]\n", + " 30 50 3.032 4.02467e+01\n", + "[4 9 6 2 5 3 7 1 0 8]\n", + " 40 50 2.937 3.73084e+01\n", + "[0 7 2 6 8 3 5 9 4 1]\n", + " 50 50 2.880 3.50773e+01\n", "-------------------------------------------------------\n", - " 50 50 5.169 3.46613e+01\n", + " 50 50 2.880 3.50773e+01\n", "Stop criterion has been reached.\n", "\n" ] @@ -244,7 +268,7 @@ "source": [ "# Setup and run SPDHG for 50 iterations\n", "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10)\n", + " update_objective_interval = 10 , sampler=Sampler.randomWithoutReplacement(n_subsets))\n", "spdhg.run()\n", "\n", "spdhg_recon = spdhg.solution " @@ -252,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -262,13 +286,13 @@ " Iter Max Iter Time/Iter Objective\n", " [s] \n", " 0 50 0.000 6.90194e+03\n", - " 10 50 4.708 1.56371e+02\n", - " 20 50 4.701 5.73612e+01\n", - " 30 50 4.564 4.46291e+01\n", - " 40 50 4.731 4.00863e+01\n", - " 50 50 4.812 3.69452e+01\n", + " 10 50 2.494 1.56371e+02\n", + " 20 50 3.314 5.73612e+01\n", + " 30 50 3.081 4.46291e+01\n", + " 40 50 2.944 4.00863e+01\n", + " 50 50 2.862 3.69452e+01\n", "-------------------------------------------------------\n", - " 50 50 4.812 3.69452e+01\n", + " 50 50 2.862 3.69452e+01\n", "Stop criterion has been reached.\n", "\n" ] @@ -276,7 +300,7 @@ ], "source": [ "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampling(n_subsets, 'herman_meyer'))\n", + " update_objective_interval = 10, sampler=Sampler.hermanMeyer(n_subsets))\n", "spdhg.run()\n", "\n", "spdhg_recon = spdhg.solution " From 05b67cb683bce486c0ae581c43c7014bdbfa3179 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 10 Aug 2023 09:45:43 +0000 Subject: [PATCH 007/115] Changed the show epochs --- .../SPDHG_sampling.cpython-310.pyc | Bin 8022 -> 8022 bytes .../cil/optimisation/algorithms/sampler.py | 7 +- .../algorithms/testing_sampling.ipynb | 285 +++++++++--------- .../algorithms/testing_sampling_SPDHG.ipynb | 44 ++- 4 files changed, 163 insertions(+), 173 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc index 1736e8dc51b534726c18e85e3a339f29a2dde79b..6a00f61acf1be2c577ed24a01169f0ddf83fc42f 100644 GIT binary patch delta 29 jcmca+cg>DBpO=@50SIK~UrAx#$a{u|k#+Meo*E$le!U2W delta 29 jcmca+cg>DBpO=@50SI(fUQXfL$a{u|k$v+mo*E$lfTaki diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampler.py b/Wrappers/Python/cil/optimisation/algorithms/sampler.py index aaf1334ab5..f175340c49 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/sampler.py +++ b/Wrappers/Python/cil/optimisation/algorithms/sampler.py @@ -112,7 +112,7 @@ def _next_order(self): # print(self.last_subset) if self.shuffle==True and self.last_subset==self.num_subsets-1: self.order=self.generator.permutation(self.order) - print(self.order) + #print(self.order) self.last_subset= (self.last_subset+1)%self.num_subsets return(self.order[self.last_subset]) @@ -125,6 +125,8 @@ def next(self): def show_epochs(self, num_epochs=2): save_generator=self.generator + save_last_subset=self.last_subset + self.last_subset=self.num_subsets-1 save_order=self.order self.order=self.initial_order self.generator=np.random.RandomState(self.seed) @@ -132,4 +134,5 @@ def show_epochs(self, num_epochs=2): print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) self.generator=save_generator self.order=save_order - + self.last_subset=save_last_subset + diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb index 64a25a7c76..171bc3e4f4 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -16,18 +16,22 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "0\n", "1\n", "2\n", @@ -140,157 +144,60 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[ 2 4 3 0 10 5 6 8 7 1 9]\n", - "Epoch 0: [2, 4, 3, 0, 10, 5, 6, 8, 7, 1, 9]\n", - "[ 2 7 6 1 4 10 5 8 0 3 9]\n", - "Epoch 1: [2, 7, 6, 1, 4, 10, 5, 8, 0, 3, 9]\n", - "[ 3 9 8 5 7 10 4 2 6 1 0]\n", - "Epoch 2: [3, 9, 8, 5, 7, 10, 4, 2, 6, 1, 0]\n", - "[ 3 1 9 10 4 2 0 6 7 5 8]\n", - "Epoch 3: [3, 1, 9, 10, 4, 2, 0, 6, 7, 5, 8]\n", - "[ 6 8 1 5 10 7 4 9 0 3 2]\n", - "Epoch 4: [6, 8, 1, 5, 10, 7, 4, 9, 0, 3, 2]\n", - "[ 2 4 3 0 10 5 6 8 7 1 9]\n", - "2\n", - "4\n", - "3\n", - "0\n", - "10\n", - "5\n", - "6\n", - "8\n", - "7\n", - "1\n", - "9\n", - "[ 2 7 6 1 4 10 5 8 0 3 9]\n", - "2\n", - "7\n", - "6\n", - "1\n", - "4\n", - "10\n", - "5\n", - "8\n", - "0\n", - "3\n", - "9\n", - "[ 3 9 8 5 7 10 4 2 6 1 0]\n", - "3\n", - "9\n", - "8\n", - "5\n", - "7\n", - "10\n", - "4\n", - "2\n", - "6\n", - "1\n", - "0\n", - "[ 3 1 9 10 4 2 0 6 7 5 8]\n", - "3\n", - "1\n", - "9\n", - "10\n", - "4\n", - "2\n", - "0\n", - "6\n", - "7\n", - "5\n", - "8\n", - "[ 6 8 1 5 10 7 4 9 0 3 2]\n", - "6\n", - "8\n", - "1\n", - "5\n", - "10\n", - "7\n", - "4\n", - "9\n", - "0\n", - "3\n", - "2\n", - "[ 4 1 2 7 0 5 10 3 8 9 6]\n", - "4\n", - "1\n", - "2\n", - "7\n", - "0\n", - "5\n", - "10\n", - "3\n", - "8\n", - "9\n", - "6\n", - "[ 5 6 9 3 10 4 1 0 8 2 7]\n", - "5\n", - "6\n", - "9\n", - "3\n", - "10\n", - "4\n", - "1\n", - "0\n", - "8\n", - "2\n", - "7\n", - "[ 6 7 0 3 1 10 8 5 4 2 9]\n", - "6\n", - "7\n", - "0\n", - "3\n", - "1\n", - "10\n", - "8\n", - "5\n", - "4\n", - "2\n", - "9\n", - "[ 9 4 7 3 6 0 5 8 10 2 1]\n", - "9\n", - "4\n", - "7\n", - "3\n", - "6\n", - "0\n", - "5\n", - "8\n", - "10\n", - "2\n", - "1\n", - "[ 3 8 10 7 2 0 6 1 9 5 4]\n", - "3\n" + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "Epoch 0: [6, 9, 7, 5, 1, 8, 3, 2, 4, 0, 10]\n", + "Epoch 1: [7, 3, 0, 4, 8, 1, 10, 9, 6, 2, 5]\n", + "Epoch 2: [2, 9, 3, 7, 1, 6, 5, 0, 8, 4, 10]\n", + "Epoch 3: [3, 0, 6, 1, 10, 7, 2, 9, 8, 5, 4]\n", + "Epoch 4: [4, 5, 10, 6, 9, 8, 7, 3, 2, 0, 1]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "[ 2 9 3 7 1 6 5 0 8 4 10]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "Epoch 0: [6, 9, 7, 5, 1, 8, 3, 2, 4, 0, 10]\n", + "Epoch 1: [7, 3, 0, 4, 8, 1, 10, 9, 6, 2, 5]\n", + "Epoch 2: [2, 9, 3, 7, 1, 6, 5, 0, 8, 4, 10]\n", + "Epoch 3: [3, 0, 6, 1, 10, 7, 2, 9, 8, 5, 4]\n", + "Epoch 4: [4, 5, 10, 6, 9, 8, 7, 3, 2, 0, 1]\n", + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", + "[ 2 9 3 7 1 6 5 0 8 4 10]\n" ] } ], "source": [ "sampler=Sampler.randomWithoutReplacement(11)\n", "sampler.show_epochs(5)\n", - "for _ in range(100):\n", - " print(sampler.next())" + "for _ in range(30):\n", + " sampler.next()\n", + "sampler.show_epochs(5)\n" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ + "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 0: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 1: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 2: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 3: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 4: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", + "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "0\n", "30\n", "15\n", @@ -403,56 +310,140 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: [7, 1, 6, 6, 4, 7, 6, 7, 7, 4, 5]\n", - "Epoch 1: [6, 3, 4, 7, 1, 4, 9, 6, 9, 2, 5]\n", - "Epoch 2: [4, 7, 7, 4, 3, 1, 10, 10, 6, 0, 1]\n", - "Epoch 3: [6, 1, 10, 5, 9, 2, 5, 10, 5, 8, 1]\n", - "Epoch 4: [8, 8, 3, 6, 7, 8, 4, 7, 10, 7, 9]\n", + "None\n", + "None\n", + "Epoch 0: [9, 2, 2, 6, 9, 9, 9, 4, 7, 8, 5]\n", + "Epoch 1: [8, 8, 2, 3, 6, 10, 7, 2, 10, 9, 2]\n", + "Epoch 2: [1, 9, 3, 2, 6, 4, 6, 4, 4, 1, 5]\n", + "Epoch 3: [1, 0, 7, 8, 2, 5, 1, 6, 5, 0, 10]\n", + "Epoch 4: [9, 10, 3, 10, 7, 8, 7, 8, 0, 6, 8]\n", + "None\n", + "None\n", + "9\n", + "2\n", + "2\n", + "6\n", + "9\n", + "9\n", + "9\n", + "4\n", "7\n", + "8\n", + "5\n", + "8\n", + "8\n", + "2\n", + "3\n", + "6\n", + "10\n", + "7\n", + "2\n", + "10\n", + "9\n", + "2\n", "1\n", + "9\n", + "3\n", + "2\n", "6\n", + "4\n", "6\n", "4\n", + "4\n", + "1\n", + "5\n", + "1\n", + "0\n", "7\n", + "8\n", + "2\n", + "5\n", + "1\n", "6\n", + "5\n", + "0\n", + "10\n", + "9\n", + "10\n", + "3\n", + "10\n", "7\n", + "8\n", "7\n", - "4\n", - "5\n", - "Epoch 0: [7, 1, 6, 6, 4, 7, 6, 7, 7, 4, 5]\n", - "Epoch 1: [6, 3, 4, 7, 1, 4, 9, 6, 9, 2, 5]\n", - "Epoch 2: [4, 7, 7, 4, 3, 1, 10, 10, 6, 0, 1]\n", - "Epoch 3: [6, 1, 10, 5, 9, 2, 5, 10, 5, 8, 1]\n", - "Epoch 4: [8, 8, 3, 6, 7, 8, 4, 7, 10, 7, 9]\n", + "8\n", + "0\n", "6\n", - "3\n", + "8\n", + "1\n", "4\n", + "1\n", + "0\n", + "6\n", + "10\n", + "2\n", + "5\n", + "2\n", + "8\n", + "2\n", + "0\n", + "9\n", "7\n", "1\n", - "4\n", + "10\n", + "1\n", + "3\n", + "5\n", + "5\n", + "8\n", + "0\n", + "5\n", + "10\n", + "2\n", "9\n", - "6\n", + "1\n", + "1\n", + "0\n", + "7\n", + "0\n", + "9\n", + "5\n", + "5\n", + "0\n", + "7\n", "9\n", + "0\n", + "7\n", + "3\n", "2\n", - "5\n" + "5\n", + "6\n", + "8\n", + "8\n", + "None\n", + "None\n", + "Epoch 0: [9, 2, 2, 6, 9, 9, 9, 4, 7, 8, 5]\n", + "Epoch 1: [8, 8, 2, 3, 6, 10, 7, 2, 10, 9, 2]\n", + "Epoch 2: [1, 9, 3, 2, 6, 4, 6, 4, 4, 1, 5]\n", + "Epoch 3: [1, 0, 7, 8, 2, 5, 1, 6, 5, 0, 10]\n", + "Epoch 4: [9, 10, 3, 10, 7, 8, 7, 8, 0, 6, 8]\n", + "None\n", + "None\n" ] } ], "source": [ "sampler=Sampler.randomWithReplacement(11)\n", "sampler.show_epochs(5)\n", - "for _ in range(11):\n", + "for _ in range(100):\n", " print(sampler.next())\n", - "sampler.show_epochs(5)\n", - "for _ in range(11):\n", - " print(sampler.next())" + "sampler.show_epochs(5)\n" ] }, { diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb index 78fe5957cf..5651c7688c 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb @@ -49,7 +49,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 2, @@ -106,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -138,6 +138,7 @@ " fi = 0.5*L2NormSquared(b = partitioned_data[i])\n", " f_subsets.append(fi)\n", " # Define A_i and put into list \n", + " \n", "ageom_subset = partitioned_data.geometry\n", "A = ProjectionOperator(ig2D, ageom_subset)\n", "\n", @@ -153,15 +154,15 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "\n", - "\n" + "\n", + "\n" ] } ], @@ -172,25 +173,20 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 5, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 50 0.000 6.90194e+03\n", - " 10 50 3.313 1.59092e+02\n", - " 20 50 3.019 5.91546e+01\n", - " 30 50 2.909 4.56431e+01\n", - " 40 50 2.849 4.06590e+01\n", - " 50 50 2.813 3.73280e+01\n", - "-------------------------------------------------------\n", - " 50 50 2.813 3.73280e+01\n", - "Stop criterion has been reached.\n", - "\n" + "ename": "TypeError", + "evalue": "object of type 'BlockFunction' has no len()", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39m# Setup and run SPDHG for 50 iterations\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m spdhg \u001b[39m=\u001b[39m SPDHG(f \u001b[39m=\u001b[39;49m F, g \u001b[39m=\u001b[39;49m G, operator \u001b[39m=\u001b[39;49m K, max_iteration \u001b[39m=\u001b[39;49m \u001b[39m50\u001b[39;49m,\n\u001b[1;32m 3\u001b[0m update_objective_interval \u001b[39m=\u001b[39;49m \u001b[39m10\u001b[39;49m, sampler\u001b[39m=\u001b[39;49mSampler\u001b[39m.\u001b[39;49msequential(n_subsets))\n\u001b[1;32m 4\u001b[0m spdhg\u001b[39m.\u001b[39mrun()\n\u001b[1;32m 6\u001b[0m spdhg_recon \u001b[39m=\u001b[39m spdhg\u001b[39m.\u001b[39msolution \n", + "File \u001b[0;32m/app/cil/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py:107\u001b[0m, in \u001b[0;36mSPDHG.__init__\u001b[0;34m(self, f, g, operator, tau, sigma, initial, prob, gamma, sampler, **kwargs)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[39msuper\u001b[39m(SPDHG, \u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m\u001b[39m__init__\u001b[39m(\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 106\u001b[0m \u001b[39mif\u001b[39;00m f \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m operator \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m g \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 107\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mset_up(f\u001b[39m=\u001b[39;49mf, g\u001b[39m=\u001b[39;49mg, operator\u001b[39m=\u001b[39;49moperator, tau\u001b[39m=\u001b[39;49mtau, sigma\u001b[39m=\u001b[39;49msigma, \n\u001b[1;32m 108\u001b[0m initial\u001b[39m=\u001b[39;49minitial, prob\u001b[39m=\u001b[39;49mprob, gamma\u001b[39m=\u001b[39;49mgamma,sampler\u001b[39m=\u001b[39;49msampler, norms\u001b[39m=\u001b[39;49mkwargs\u001b[39m.\u001b[39;49mget(\u001b[39m'\u001b[39;49m\u001b[39mnorms\u001b[39;49m\u001b[39m'\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m))\n", + "File \u001b[0;32m/app/cil/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py:147\u001b[0m, in \u001b[0;36mSPDHG.set_up\u001b[0;34m(self, f, g, operator, tau, sigma, initial, prob, gamma, sampler, norms)\u001b[0m\n\u001b[1;32m 145\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msigma \u001b[39m=\u001b[39m sigma\n\u001b[1;32m 146\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprob \u001b[39m=\u001b[39m prob\n\u001b[0;32m--> 147\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mndual_subsets \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mf)\n\u001b[1;32m 148\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mgamma \u001b[39m=\u001b[39m gamma\n\u001b[1;32m 149\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrho \u001b[39m=\u001b[39m \u001b[39m.99\u001b[39m\n", + "\u001b[0;31mTypeError\u001b[0m: object of type 'BlockFunction' has no len()" ] } ], @@ -205,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -238,7 +234,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -276,7 +272,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": {}, "outputs": [ { From 001350b65a84ed7070fb83ff5a6cdab7f758223c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 11 Aug 2023 08:45:02 +0000 Subject: [PATCH 008/115] Meeting with Vaggelis, Jakob, Gemma and Edo --- .../SPDHG_sampling.cpython-310.pyc | Bin 8022 -> 8022 bytes .../algorithms/testing_sampling.ipynb | 245 ++++++++++-------- .../algorithms/testing_sampling_SPDHG.ipynb | 9 +- 3 files changed, 137 insertions(+), 117 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc index 6a00f61acf1be2c577ed24a01169f0ddf83fc42f..50238c405fe007f4ad1d74ed7ea628949025d970 100644 GIT binary patch delta 19 Zcmca+cg>C~pO=@50SIEYY~=Eh2LLz+1pEL1 delta 19 Zcmca+cg>C~pO=@50SIK~Z{+fk2LLu61g8K1 diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb index 171bc3e4f4..5da23f9c53 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 16, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -16,22 +16,18 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "0\n", "1\n", "2\n", @@ -133,42 +129,77 @@ "8\n", "9\n" ] + }, + { + "ename": "TypeError", + "evalue": "'Sampler' object is not an iterator", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[6], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[39mfor\u001b[39;00m _ \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39m100\u001b[39m):\n\u001b[1;32m 4\u001b[0m \u001b[39mprint\u001b[39m(sampler\u001b[39m.\u001b[39mnext())\n\u001b[0;32m----> 6\u001b[0m \u001b[39mnext\u001b[39;49m(sampler)\n", + "\u001b[0;31mTypeError\u001b[0m: 'Sampler' object is not an iterator" + ] } ], "source": [ "sampler=Sampler.sequential(10)\n", "sampler.show_epochs(5)\n", "for _ in range(100):\n", - " print(sampler.next())" + " print(sampler.next())\n", + "\n", + "next(sampler)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "Epoch 0: [6, 9, 7, 5, 1, 8, 3, 2, 4, 0, 10]\n", - "Epoch 1: [7, 3, 0, 4, 8, 1, 10, 9, 6, 2, 5]\n", - "Epoch 2: [2, 9, 3, 7, 1, 6, 5, 0, 8, 4, 10]\n", - "Epoch 3: [3, 0, 6, 1, 10, 7, 2, 9, 8, 5, 4]\n", - "Epoch 4: [4, 5, 10, 6, 9, 8, 7, 3, 2, 0, 1]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "[ 2 9 3 7 1 6 5 0 8 4 10]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "Epoch 0: [6, 9, 7, 5, 1, 8, 3, 2, 4, 0, 10]\n", - "Epoch 1: [7, 3, 0, 4, 8, 1, 10, 9, 6, 2, 5]\n", - "Epoch 2: [2, 9, 3, 7, 1, 6, 5, 0, 8, 4, 10]\n", - "Epoch 3: [3, 0, 6, 1, 10, 7, 2, 9, 8, 5, 4]\n", - "Epoch 4: [4, 5, 10, 6, 9, 8, 7, 3, 2, 0, 1]\n", - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", - "[ 2 9 3 7 1 6 5 0 8 4 10]\n" + "Epoch 0: [8, 7, 4, 2, 3, 0, 9, 5, 1, 10, 6]\n", + "Epoch 1: [1, 3, 0, 7, 5, 2, 6, 8, 9, 10, 4]\n", + "Epoch 2: [0, 10, 4, 7, 9, 3, 5, 2, 8, 6, 1]\n", + "Epoch 3: [3, 8, 7, 10, 2, 1, 6, 4, 0, 5, 9]\n", + "Epoch 4: [5, 10, 1, 2, 7, 9, 4, 3, 6, 8, 0]\n", + "8\n", + "7\n", + "4\n", + "2\n", + "3\n", + "0\n", + "9\n", + "5\n", + "1\n", + "10\n", + "6\n", + "1\n", + "3\n", + "0\n", + "7\n", + "5\n", + "2\n", + "6\n", + "8\n", + "9\n", + "10\n", + "4\n", + "0\n", + "10\n", + "4\n", + "7\n", + "9\n", + "3\n", + "5\n", + "2\n", + "Epoch 0: [8, 7, 4, 2, 3, 0, 9, 5, 1, 10, 6]\n", + "Epoch 1: [1, 3, 0, 7, 5, 2, 6, 8, 9, 10, 4]\n", + "Epoch 2: [0, 10, 4, 7, 9, 3, 5, 2, 8, 6, 1]\n", + "Epoch 3: [3, 8, 7, 10, 2, 1, 6, 4, 0, 5, 9]\n", + "Epoch 4: [5, 10, 1, 2, 7, 9, 4, 3, 6, 8, 0]\n" ] } ], @@ -176,28 +207,24 @@ "sampler=Sampler.randomWithoutReplacement(11)\n", "sampler.show_epochs(5)\n", "for _ in range(30):\n", - " sampler.next()\n", + " print(sampler.next())\n", "sampler.show_epochs(5)\n" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 0: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 1: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 2: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 3: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "Epoch 4: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "[0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", "0\n", "30\n", "15\n", @@ -310,131 +337,123 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "None\n", - "None\n", - "Epoch 0: [9, 2, 2, 6, 9, 9, 9, 4, 7, 8, 5]\n", - "Epoch 1: [8, 8, 2, 3, 6, 10, 7, 2, 10, 9, 2]\n", - "Epoch 2: [1, 9, 3, 2, 6, 4, 6, 4, 4, 1, 5]\n", - "Epoch 3: [1, 0, 7, 8, 2, 5, 1, 6, 5, 0, 10]\n", - "Epoch 4: [9, 10, 3, 10, 7, 8, 7, 8, 0, 6, 8]\n", - "None\n", - "None\n", - "9\n", - "2\n", + "Epoch 0: [0, 0, 2, 0, 4, 7, 10, 1, 1, 3, 9]\n", + "Epoch 1: [5, 4, 9, 1, 10, 2, 4, 0, 10, 4, 9]\n", + "Epoch 2: [3, 8, 3, 3, 4, 5, 1, 4, 6, 8, 0]\n", + "Epoch 3: [2, 0, 7, 1, 10, 5, 5, 10, 8, 7, 7]\n", + "Epoch 4: [9, 1, 5, 9, 2, 7, 4, 5, 6, 6, 0]\n", + "0\n", + "0\n", "2\n", - "6\n", - "9\n", - "9\n", - "9\n", + "0\n", "4\n", "7\n", - "8\n", - "5\n", - "8\n", - "8\n", - "2\n", - "3\n", - "6\n", - "10\n", - "7\n", - "2\n", "10\n", - "9\n", - "2\n", "1\n", - "9\n", - "3\n", - "2\n", - "6\n", - "4\n", - "6\n", - "4\n", - "4\n", "1\n", + "3\n", + "9\n", "5\n", + "4\n", + "9\n", "1\n", - "0\n", - "7\n", - "8\n", + "10\n", "2\n", - "5\n", - "1\n", - "6\n", - "5\n", + "4\n", "0\n", "10\n", + "4\n", "9\n", - "10\n", "3\n", - "10\n", - "7\n", - "8\n", - "7\n", - "8\n", - "0\n", - "6\n", "8\n", - "1\n", + "3\n", + "3\n", "4\n", + "5\n", "1\n", - "0\n", + "4\n", "6\n", - "10\n", - "2\n", - "5\n", - "2\n", "8\n", + "0\n", "2\n", "0\n", - "9\n", "7\n", "1\n", "10\n", - "1\n", - "3\n", "5\n", "5\n", - "8\n", - "0\n", - "5\n", "10\n", - "2\n", - "9\n", - "1\n", - "1\n", - "0\n", + "8\n", + "7\n", "7\n", - "0\n", "9\n", + "1\n", "5\n", + "9\n", + "2\n", + "7\n", + "4\n", "5\n", + "6\n", + "6\n", + "0\n", "0\n", - "7\n", "9\n", + "4\n", + "2\n", + "8\n", + "6\n", + "1\n", + "6\n", "0\n", - "7\n", + "9\n", + "2\n", + "6\n", + "8\n", "3\n", + "1\n", "2\n", + "8\n", + "3\n", + "4\n", + "1\n", + "8\n", + "8\n", + "10\n", + "8\n", + "9\n", + "3\n", + "10\n", + "10\n", + "4\n", + "4\n", + "9\n", "5\n", - "6\n", + "7\n", + "4\n", + "1\n", "8\n", "8\n", - "None\n", - "None\n", - "Epoch 0: [9, 2, 2, 6, 9, 9, 9, 4, 7, 8, 5]\n", - "Epoch 1: [8, 8, 2, 3, 6, 10, 7, 2, 10, 9, 2]\n", - "Epoch 2: [1, 9, 3, 2, 6, 4, 6, 4, 4, 1, 5]\n", - "Epoch 3: [1, 0, 7, 8, 2, 5, 1, 6, 5, 0, 10]\n", - "Epoch 4: [9, 10, 3, 10, 7, 8, 7, 8, 0, 6, 8]\n", - "None\n", - "None\n" + "9\n", + "8\n", + "4\n", + "9\n", + "7\n", + "4\n", + "2\n", + "3\n", + "Epoch 0: [0, 0, 2, 0, 4, 7, 10, 1, 1, 3, 9]\n", + "Epoch 1: [5, 4, 9, 1, 10, 2, 4, 0, 10, 4, 9]\n", + "Epoch 2: [3, 8, 3, 3, 4, 5, 1, 4, 6, 8, 0]\n", + "Epoch 3: [2, 0, 7, 1, 10, 5, 5, 10, 8, 7, 7]\n", + "Epoch 4: [9, 1, 5, 9, 2, 7, 4, 5, 6, 6, 0]\n" ] } ], diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb index 5651c7688c..ed214d17a2 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb +++ b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb @@ -49,7 +49,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 2, @@ -130,18 +130,19 @@ "\n", "# Initialize the lists containing the F_i's and A_i's\n", "f_subsets = []\n", - "A_subsets = []\n", "\n", - "# Define F_i's and A_i's\n", + "\n", + "# Define F_i's \n", "for i in range(n_subsets):\n", " # Define F_i and put into list\n", " fi = 0.5*L2NormSquared(b = partitioned_data[i])\n", " f_subsets.append(fi)\n", - " # Define A_i and put into list \n", + " \n", " \n", "ageom_subset = partitioned_data.geometry\n", "A = ProjectionOperator(ig2D, ageom_subset)\n", "\n", + "#F = L2NormSquared.fromBlockDataContainer(partitioned_data, constant=0.5)\n", "\n", "# Define F and K\n", "F = BlockFunction(*f_subsets)\n", From 890dec05fdf2a88de6fb3680213538e8a38c1a6d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 14 Aug 2023 14:18:44 +0000 Subject: [PATCH 009/115] Set up for installation --- Wrappers/Python/cil/framework/__init__.py | 1 + .../cil/optimisation/algorithms/SPDHG.py | 40 +- .../optimisation/algorithms/SPDHG_sampling.py | 257 --------- .../cil/optimisation/algorithms/sampler.py | 138 ----- .../algorithms/testing_sampling.ipynb | 498 ------------------ .../algorithms/testing_sampling_SPDHG.ipynb | 329 ------------ 6 files changed, 28 insertions(+), 1235 deletions(-) delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/sampler.py delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb diff --git a/Wrappers/Python/cil/framework/__init__.py b/Wrappers/Python/cil/framework/__init__.py index 4571441515..19e6e89c1e 100644 --- a/Wrappers/Python/cil/framework/__init__.py +++ b/Wrappers/Python/cil/framework/__init__.py @@ -34,3 +34,4 @@ from .BlockGeometry import BlockGeometry from .framework import DataOrder from .framework import Partitioner +from .sampler import Sampler diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 37efd460b8..058002f139 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -22,7 +22,7 @@ import numpy as np import warnings import logging - +from cil.framework import Sampler class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -50,7 +50,8 @@ class SPDHG(Algorithm): List of probabilities. If None each subset will have probability = 1/number of subsets gamma : float parameter controlling the trade-off between the primal and dual step sizes - + sampler: instnace of the Sampler class + Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets **kwargs: norms : list of floats precalculated list of norms of the operators @@ -95,19 +96,20 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, prob=None, gamma=1.,**kwargs): + def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, + initial=None, prob=None, gamma=1.,sampler=None,**kwargs): super(SPDHG, self).__init__(**kwargs) - + + if f is not None and operator is not None and g is not None: self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - initial=initial, prob=prob, gamma=gamma, norms=kwargs.get('norms', None)) + initial=initial, prob=prob, gamma=gamma,sampler=sampler, norms=kwargs.get('norms', None)) def set_up(self, f, g, operator, tau=None, sigma=None, \ - initial=None, prob=None, gamma=1., norms=None): + initial=None, prob=None, gamma=1.,sampler=None, norms=None): '''set-up of the algorithm Parameters @@ -142,14 +144,26 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ self.tau = tau self.sigma = sigma self.prob = prob - self.ndual_subsets = len(self.operator) + self.ndual_subsets = self.operator.shape[0] self.gamma = gamma self.rho = .99 - - if self.prob is None: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets + self.sampler=sampler + + if self.sampler==None: + if self.prob == None: + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) + else: + if self.prob==None: + if self.sampler.prob!=None: + self.prob=self.sampler.prob + else: + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + else: + warnings.warn('You supplied both probabilites and a sampler. The sampler will be used for sampling and the probabilites for calculationg step sizes, if not explicitly set.') + + - if self.sigma is None: if norms is None: # Compute norm of each sub-operator @@ -187,7 +201,7 @@ def update(self): self.g.proximal(self.x_tmp, self.tau, out=self.x) # Choose subset - i = int(np.random.choice(len(self.sigma), 1, p=self.prob)) + i = int(self.sampler.next()) # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py deleted file mode 100644 index ea5083ea08..0000000000 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py +++ /dev/null @@ -1,257 +0,0 @@ -# -*- coding: utf-8 -*- -# Copyright 2020 United Kingdom Research and Innovation -# Copyright 2020 The University of Manchester -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# Authors: -# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt -# Claire Delplancke (University of Bath) - -from cil.optimisation.algorithms import Algorithm -import numpy as np -import warnings -import logging -from sampler import Sampler -class SPDHG(Algorithm): - r'''Stochastic Primal Dual Hybrid Gradient - - Problem: - - .. math:: - - \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) - - Parameters - ---------- - f : BlockFunction - Each must be a convex function with a "simple" proximal method of its conjugate - g : Function - A convex function with a "simple" proximal - operator : BlockOperator - BlockOperator must contain Linear Operators - tau : positive float, optional, default=None - Step size parameter for Primal problem - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem - initial : DataContainer, optional, default=None - Initial point for the SPDHG algorithm - prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets - gamma : float - parameter controlling the trade-off between the primal and dual step sizes - sampler: instnace of the Sampler class - Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets - **kwargs: - norms : list of floats - precalculated list of norms of the operators - - Example - ------- - - Example of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py - - - Note - ---- - - Convergence is guaranteed provided that [2, eq. (12)]: - - .. math:: - - \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i - - Note - ---- - - Notation for primal and dual step-sizes are reversed with comparison - to PDHG.py - - Note - ---- - - this code implements serial sampling only, as presented in [2] - (to be extended to more general case of [1] as future work) - - References - ---------- - - [1]"Stochastic primal-dual hybrid gradient algorithm with arbitrary - sampling and imaging applications", - Chambolle, Antonin, Matthias J. Ehrhardt, Peter Richtárik, and Carola-Bibiane Schonlieb, - SIAM Journal on Optimization 28, no. 4 (2018): 2783-2808. - - [2]"Faster PET reconstruction with non-smooth priors by randomization and preconditioning", - Matthias J Ehrhardt, Pawel Markiewicz and Carola-Bibiane Schönlieb, - Physics in Medicine & Biology, Volume 64, Number 22, 2019. - ''' - - def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, prob=None, gamma=1.,sampler=None,**kwargs): - - super(SPDHG, self).__init__(**kwargs) - - - - if f is not None and operator is not None and g is not None: - self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - initial=initial, prob=prob, gamma=gamma,sampler=sampler, norms=kwargs.get('norms', None)) - - - def set_up(self, f, g, operator, tau=None, sigma=None, \ - initial=None, prob=None, gamma=1.,sampler=None, norms=None): - - '''set-up of the algorithm - Parameters - ---------- - f : BlockFunction - Each must be a convex function with a "simple" proximal method of its conjugate - g : Function - A convex function with a "simple" proximal - operator : BlockOperator - BlockOperator must contain Linear Operators - tau : positive float, optional, default=None - Step size parameter for Primal problem - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem - initial : DataContainer, optional, default=None - Initial point for the SPDHG algorithm - prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets - gamma : float - parameter controlling the trade-off between the primal and dual step sizes - - **kwargs: - norms : list of floats - precalculated list of norms of the operators - ''' - logging.info("{} setting up".format(self.__class__.__name__, )) - - # algorithmic parameters - self.f = f - self.g = g - self.operator = operator - self.tau = tau - self.sigma = sigma - self.prob = prob - self.ndual_subsets = len(self.f) - self.gamma = gamma - self.rho = .99 - self.sampler=sampler - - if self.sampler==None: - if self.prob == None: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets - self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) - else: - if self.prob==None: - if self.sampler.prob!=None: - self.prob=self.sampler.prob - else: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets - else: - warnings.warn('You supplied both probabilites and a sampler. The sampler will be used for sampling and the probabilites for calculationg step sizes, if not explicitly set.') - - - - if self.sigma is None: - if norms is None: - # Compute norm of each sub-operator - norms = [operator.get_item(i,0).norm() for i in range(self.ndual_subsets)] - self.norms = norms - self.sigma = [self.gamma * self.rho / ni for ni in norms] - if self.tau is None: - self.tau = min( [ pi / ( si * ni**2 ) for pi, ni, si in zip(self.prob, norms, self.sigma)] ) - self.tau *= (self.rho / self.gamma) - - # initialize primal variable - if initial is None: - self.x = self.operator.domain_geometry().allocate(0) - else: - self.x = initial.copy() - - self.x_tmp = self.operator.domain_geometry().allocate(0) - - # initialize dual variable to 0 - self.y_old = operator.range_geometry().allocate(0) - - # initialize variable z corresponding to back-projected dual variable - self.z = operator.domain_geometry().allocate(0) - self.zbar= operator.domain_geometry().allocate(0) - # relaxation parameter - self.theta = 1 - self.configured = True - logging.info("{} configured".format(self.__class__.__name__, )) - - def update(self): - # Gradient descent for the primal variable - # x_tmp = x - tau * zbar - self.x.sapyb(1., self.zbar, -self.tau, out=self.x_tmp) - - self.g.proximal(self.x_tmp, self.tau, out=self.x) - - # Choose subset - i = int(self.sampler.next()) - - # Gradient ascent for the dual variable - # y_k = y_old[i] + sigma[i] * K[i] x - y_k = self.operator[i].direct(self.x) - - y_k.sapyb(self.sigma[i], self.y_old[i], 1., out=y_k) - - y_k = self.f[i].proximal_conjugate(y_k, self.sigma[i]) - - # Back-project - # x_tmp = K[i]^*(y_k - y_old[i]) - y_k.subtract(self.y_old[i], out=self.y_old[i]) - - self.operator[i].adjoint(self.y_old[i], out = self.x_tmp) - # Update backprojected dual variable and extrapolate - # zbar = z + (1 + theta/p[i]) x_tmp - - # z = z + x_tmp - self.z.add(self.x_tmp, out =self.z) - # zbar = z + (theta/p[i]) * x_tmp - - self.z.sapyb(1., self.x_tmp, self.theta / self.prob[i], out = self.zbar) - - # save previous iteration - self.save_previous_iteration(i, y_k) - - def update_objective(self): - # p1 = self.f(self.operator.direct(self.x)) + self.g(self.x) - p1 = 0. - for i,op in enumerate(self.operator.operators): - p1 += self.f[i](op.direct(self.x)) - p1 += self.g(self.x) - - d1 = - self.f.convex_conjugate(self.y_old) - tmp = self.operator.adjoint(self.y_old) - tmp *= -1 - d1 -= self.g.convex_conjugate(tmp) - - self.loss.append([p1, d1, p1-d1]) - - @property - def objective(self): - '''alias of loss''' - return [x[0] for x in self.loss] - @property - def dual_objective(self): - return [x[1] for x in self.loss] - - @property - def primal_dual_gap(self): - return [x[2] for x in self.loss] - def save_previous_iteration(self, index, y_current): - self.y_old[index].fill(y_current) diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampler.py b/Wrappers/Python/cil/optimisation/algorithms/sampler.py deleted file mode 100644 index f175340c49..0000000000 --- a/Wrappers/Python/cil/optimisation/algorithms/sampler.py +++ /dev/null @@ -1,138 +0,0 @@ -# -*- coding: utf-8 -*- -# This work is part of the Core Imaging Library (CIL) developed by CCPi -# (Collaborative Computational Project in Tomographic Imaging), with -# substantial contributions by UKRI-STFC and University of Manchester. - -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at - -# http://www.apache.org/licenses/LICENSE-2.0 - -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - - -import numpy as np -import math -import time -class Sampler(): - - r"""Takes an integer number of subsets and a sampling type and returns a class object with a next function. On each call of next, an integer value between 0 and the number of subsets is returned, the next sample.""" - - - - @staticmethod - def hermanMeyer(num_subsets): - @staticmethod - def _herman_meyer_order(n): - # Assuming that the subsets are in geometrical order - n_variable = n - i = 2 - factors = [] - while i * i <= n_variable: - if n_variable % i: - i += 1 - else: - n_variable //= i - factors.append(i) - if n_variable > 1: - factors.append(n_variable) - n_factors = len(factors) - order = [0 for _ in range(n)] - value = 0 - for factor_n in range(n_factors): - n_rep_value = 0 - if factor_n == 0: - n_change_value = 1 - else: - n_change_value = math.prod(factors[:factor_n]) - for element in range(n): - mapping = value - n_rep_value += 1 - if n_rep_value >= n_change_value: - value = value + 1 - n_rep_value = 0 - if value == factors[factor_n]: - value = 0 - order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping - return order - - order=_herman_meyer_order(num_subsets) - sampler=Sampler(num_subsets, sampling_type='herman_meyer', order=order) - return sampler - - @staticmethod - def sequential(num_subsets): - order=list(range(num_subsets)) - sampler=Sampler(num_subsets, sampling_type='sequential', order=order) - return sampler - - @staticmethod - def randomWithReplacement(num_subsets, prob=None, seed=None): - if prob==None: - prob = [1/num_subsets] *num_subsets - else: - prob=prob - sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) - return sampler - - @staticmethod - def randomWithoutReplacement(num_subsets, seed=None): - order=list(range(num_subsets)) - sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) - return sampler - - - def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): - self.type=sampling_type - self.num_subsets=num_subsets - if seed !=None: - self.seed=seed - else: - self.seed=int(time.time()) - self.generator=np.random.RandomState(self.seed) - self.order=order - self.initial_order=order - if order!=None: - self.iterator=self._next_order - self.prob=prob - if prob!=None: - self.iterator=self._next_prob - self.shuffle=shuffle - self.last_subset=self.num_subsets-1 - - - - - def _next_order(self): - # print(self.last_subset) - if self.shuffle==True and self.last_subset==self.num_subsets-1: - self.order=self.generator.permutation(self.order) - #print(self.order) - self.last_subset= (self.last_subset+1)%self.num_subsets - return(self.order[self.last_subset]) - - def _next_prob(self): - return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) - - def next(self): - return (self.iterator()) - - - def show_epochs(self, num_epochs=2): - save_generator=self.generator - save_last_subset=self.last_subset - self.last_subset=self.num_subsets-1 - save_order=self.order - self.order=self.initial_order - self.generator=np.random.RandomState(self.seed) - for i in range(num_epochs): - print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) - self.generator=save_generator - self.order=save_order - self.last_subset=save_last_subset - diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb deleted file mode 100644 index 5da23f9c53..0000000000 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling.ipynb +++ /dev/null @@ -1,498 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - " \n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import os\n", - "from sampler import Sampler\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n", - "0\n", - "1\n", - "2\n", - "3\n", - "4\n", - "5\n", - "6\n", - "7\n", - "8\n", - "9\n" - ] - }, - { - "ename": "TypeError", - "evalue": "'Sampler' object is not an iterator", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[6], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[39mfor\u001b[39;00m _ \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(\u001b[39m100\u001b[39m):\n\u001b[1;32m 4\u001b[0m \u001b[39mprint\u001b[39m(sampler\u001b[39m.\u001b[39mnext())\n\u001b[0;32m----> 6\u001b[0m \u001b[39mnext\u001b[39;49m(sampler)\n", - "\u001b[0;31mTypeError\u001b[0m: 'Sampler' object is not an iterator" - ] - } - ], - "source": [ - "sampler=Sampler.sequential(10)\n", - "sampler.show_epochs(5)\n", - "for _ in range(100):\n", - " print(sampler.next())\n", - "\n", - "next(sampler)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: [8, 7, 4, 2, 3, 0, 9, 5, 1, 10, 6]\n", - "Epoch 1: [1, 3, 0, 7, 5, 2, 6, 8, 9, 10, 4]\n", - "Epoch 2: [0, 10, 4, 7, 9, 3, 5, 2, 8, 6, 1]\n", - "Epoch 3: [3, 8, 7, 10, 2, 1, 6, 4, 0, 5, 9]\n", - "Epoch 4: [5, 10, 1, 2, 7, 9, 4, 3, 6, 8, 0]\n", - "8\n", - "7\n", - "4\n", - "2\n", - "3\n", - "0\n", - "9\n", - "5\n", - "1\n", - "10\n", - "6\n", - "1\n", - "3\n", - "0\n", - "7\n", - "5\n", - "2\n", - "6\n", - "8\n", - "9\n", - "10\n", - "4\n", - "0\n", - "10\n", - "4\n", - "7\n", - "9\n", - "3\n", - "5\n", - "2\n", - "Epoch 0: [8, 7, 4, 2, 3, 0, 9, 5, 1, 10, 6]\n", - "Epoch 1: [1, 3, 0, 7, 5, 2, 6, 8, 9, 10, 4]\n", - "Epoch 2: [0, 10, 4, 7, 9, 3, 5, 2, 8, 6, 1]\n", - "Epoch 3: [3, 8, 7, 10, 2, 1, 6, 4, 0, 5, 9]\n", - "Epoch 4: [5, 10, 1, 2, 7, 9, 4, 3, 6, 8, 0]\n" - ] - } - ], - "source": [ - "sampler=Sampler.randomWithoutReplacement(11)\n", - "sampler.show_epochs(5)\n", - "for _ in range(30):\n", - " print(sampler.next())\n", - "sampler.show_epochs(5)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "Epoch 1: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "Epoch 2: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "Epoch 3: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "Epoch 4: [0, 30, 15, 45, 5, 35, 20, 50, 10, 40, 25, 55, 1, 31, 16, 46, 6, 36, 21, 51, 11, 41, 26, 56, 2, 32, 17, 47, 7, 37, 22, 52, 12, 42, 27, 57, 3, 33, 18, 48, 8, 38, 23, 53, 13, 43, 28, 58, 4, 34, 19, 49, 9, 39, 24, 54, 14, 44, 29, 59]\n", - "0\n", - "30\n", - "15\n", - "45\n", - "5\n", - "35\n", - "20\n", - "50\n", - "10\n", - "40\n", - "25\n", - "55\n", - "1\n", - "31\n", - "16\n", - "46\n", - "6\n", - "36\n", - "21\n", - "51\n", - "11\n", - "41\n", - "26\n", - "56\n", - "2\n", - "32\n", - "17\n", - "47\n", - "7\n", - "37\n", - "22\n", - "52\n", - "12\n", - "42\n", - "27\n", - "57\n", - "3\n", - "33\n", - "18\n", - "48\n", - "8\n", - "38\n", - "23\n", - "53\n", - "13\n", - "43\n", - "28\n", - "58\n", - "4\n", - "34\n", - "19\n", - "49\n", - "9\n", - "39\n", - "24\n", - "54\n", - "14\n", - "44\n", - "29\n", - "59\n", - "0\n", - "30\n", - "15\n", - "45\n", - "5\n", - "35\n", - "20\n", - "50\n", - "10\n", - "40\n", - "25\n", - "55\n", - "1\n", - "31\n", - "16\n", - "46\n", - "6\n", - "36\n", - "21\n", - "51\n", - "11\n", - "41\n", - "26\n", - "56\n", - "2\n", - "32\n", - "17\n", - "47\n", - "7\n", - "37\n", - "22\n", - "52\n", - "12\n", - "42\n", - "27\n", - "57\n", - "3\n", - "33\n", - "18\n", - "48\n" - ] - } - ], - "source": [ - "sampler=Sampler.hermanMeyer(60)\n", - "sampler.show_epochs(5)\n", - "for _ in range(100):\n", - " print(sampler.next())" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 0: [0, 0, 2, 0, 4, 7, 10, 1, 1, 3, 9]\n", - "Epoch 1: [5, 4, 9, 1, 10, 2, 4, 0, 10, 4, 9]\n", - "Epoch 2: [3, 8, 3, 3, 4, 5, 1, 4, 6, 8, 0]\n", - "Epoch 3: [2, 0, 7, 1, 10, 5, 5, 10, 8, 7, 7]\n", - "Epoch 4: [9, 1, 5, 9, 2, 7, 4, 5, 6, 6, 0]\n", - "0\n", - "0\n", - "2\n", - "0\n", - "4\n", - "7\n", - "10\n", - "1\n", - "1\n", - "3\n", - "9\n", - "5\n", - "4\n", - "9\n", - "1\n", - "10\n", - "2\n", - "4\n", - "0\n", - "10\n", - "4\n", - "9\n", - "3\n", - "8\n", - "3\n", - "3\n", - "4\n", - "5\n", - "1\n", - "4\n", - "6\n", - "8\n", - "0\n", - "2\n", - "0\n", - "7\n", - "1\n", - "10\n", - "5\n", - "5\n", - "10\n", - "8\n", - "7\n", - "7\n", - "9\n", - "1\n", - "5\n", - "9\n", - "2\n", - "7\n", - "4\n", - "5\n", - "6\n", - "6\n", - "0\n", - "0\n", - "9\n", - "4\n", - "2\n", - "8\n", - "6\n", - "1\n", - "6\n", - "0\n", - "9\n", - "2\n", - "6\n", - "8\n", - "3\n", - "1\n", - "2\n", - "8\n", - "3\n", - "4\n", - "1\n", - "8\n", - "8\n", - "10\n", - "8\n", - "9\n", - "3\n", - "10\n", - "10\n", - "4\n", - "4\n", - "9\n", - "5\n", - "7\n", - "4\n", - "1\n", - "8\n", - "8\n", - "9\n", - "8\n", - "4\n", - "9\n", - "7\n", - "4\n", - "2\n", - "3\n", - "Epoch 0: [0, 0, 2, 0, 4, 7, 10, 1, 1, 3, 9]\n", - "Epoch 1: [5, 4, 9, 1, 10, 2, 4, 0, 10, 4, 9]\n", - "Epoch 2: [3, 8, 3, 3, 4, 5, 1, 4, 6, 8, 0]\n", - "Epoch 3: [2, 0, 7, 1, 10, 5, 5, 10, 8, 7, 7]\n", - "Epoch 4: [9, 1, 5, 9, 2, 7, 4, 5, 6, 6, 0]\n" - ] - } - ], - "source": [ - "sampler=Sampler.randomWithReplacement(11)\n", - "sampler.show_epochs(5)\n", - "for _ in range(100):\n", - " print(sampler.next())\n", - "sampler.show_epochs(5)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "cil", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb b/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb deleted file mode 100644 index ed214d17a2..0000000000 --- a/Wrappers/Python/cil/optimisation/algorithms/testing_sampling_SPDHG.ipynb +++ /dev/null @@ -1,329 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "from cil.framework import DataContainer, BlockDataContainer, Partitioner\n", - "\n", - "# Import libraries\n", - " \n", - "from SPDHG_sampling import SPDHG\n", - "from cil.optimisation.operators import GradientOperator, BlockOperator\n", - "from cil.optimisation.functions import IndicatorBox, BlockFunction, L2NormSquared, MixedL21Norm\n", - " \n", - "from cil.io import ZEISSDataReader\n", - " \n", - "from cil.processors import Slicer, Binner, TransmissionAbsorptionConverter\n", - " \n", - "from cil.plugins.astra.operators import ProjectionOperator\n", - "from cil.plugins.ccpi_regularisation.functions import FGP_TV\n", - " \n", - "from cil.utilities.display import show2D\n", - "from cil.utilities.jupyter import islicer\n", - " \n", - " \n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import os\n", - "from sampler import Sampler\n" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABAgAAAMBCAYAAABiMYZcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9ebBtW1XfP/e5p7kPfKIgCEgbLVtALTQG1IhRoaiITaySmIQoEoMRUAQpNaTsyvphkwpaJGpMEYlGQyr2ViiMKZtAKFP6IqWGlF1siEAwRlrvPc09+/fHq+++n/093zHX2vuce9+9785RtWvvvdZcc4455phjju+YzVosl8tlGzRo0KBBgwYNGjRo0KBBgwbd0bRzXzMwaNCgQYMGDRo0aNCgQYMGDbrvaQQIBg0aNGjQoEGDBg0aNGjQoEEjQDBo0KBBgwYNGjRo0KBBgwYNGgGCQYMGDRo0aNCgQYMGDRo0aFAbAYJBgwYNGjRo0KBBgwYNGjRoUBsBgkGDBg0aNGjQoEGDBg0aNGhQGwGCQYMGDRo0aNCgQYMGDRo0aFAbAYJBgwYNGjRo0KBBgwYNGjRoUBsBgkGDBg0aNGjQoEGDBg0aNGhQa233vmbgdqHT09P2tre9rd19991tsVjc1+wMGjRo0KBBgwYNGnTD6fT0tL397W9vH/mRH9kuXbp0X7MzaNBGdPXq1XZ0dHRfs9Faa21/f79dvnz5vmZjmpa3EH3f933f8olPfOLy7rvvXt59993Lv/bX/tryda97XZn+bW972/JLvuRLlh/5kR+5XCwWy6/5mq/p5v/v/t2/W7bWlp//+Z+/MW9vfetbl6218Rmf8Rmf8Rmf8Rmf8RmfO+7zlre8ZZbP/Cu/8ivLz/3cz10+4hGPWLbWlj/1Uz91Js1b3vKW5bOe9azlB37gBy4/4AM+YPkpn/Ipyz/+4z9e3b969eryhS984fIhD3nI8gEPeMDyWc961vKtb33rxv77oDubrly5snz4wx9+n/cdfR7+8Icvr1y5cl+LZZJuqRUEj3rUo9p3fMd3tI/4iI9orbX2b/7Nv2mf//mf337jN36jfdzHfdyZ9IeHh+2hD31oe/nLX95e+cpXdvP+4z/+4/Z1X/d17dM//dO34u3uu+9urbX2uMc9ru3sbLcz4/T0tLXWNnp+uVyuViwsl8vVf32Wy2X3+cVi0XZ2dtrBwUHb29tbfe/u7rZLly61S5cutZ2dnVU60e7ubtvZ2VnLX799BUVaUXF6erril/9TWqXRffGm752dnba7u9sWi0Xb29tbq//Ozs7qc+nSpbU0qpfqfXBw0Pb391fXl8vlii/S3t7eShanp6ft5ORkre56drlctmvXrq3yuXbtWrt27Vo7Pj5ux8fH7ejoaPX72rVr7fDwcJWfylW9dE9l6vdyuVzJQN+Uwf7+ftvf31+re9IfyoP32EbUM8+D9U1p+CzbXtdVJz4nntgv9Nv18+DgYK2tJQd92P5e38VisXZvd3d3pQsHBwer6+JJZVV5iVeXg9fZ9ZtpeH25XK50zO+nD+Ws9nA56v/p6ekZe0M9kFzYZteuXVvTed3Tc+qb1MPj4+O1erIvUI5uZ/Tb+3CSgYj9Q+2pa2wj3acOHh8fr+SmfFXXo6OjFc/Xrl07I5OqfPFJW6DnVCeXPfXbdfzk5GStbai/khf11fPmPdWPMk7jj+qjckmyTfqonmpn6nyy7y4XlScZ0SZK9vpPuZNSmygv3XdbQ6Kt9PZq7fr4p2/KjH1H9avI5UQ5ql107+rVq6vrkoFkT71lmZI9eeVYL51Qnkojm6nnLl26tHpub2+vXbp0aa1/i5SP2kn93ut17dq11fj3F3/xF+3w8LC9733vW5Mz85V+S74cYzkukjimSD6Hh4drNky86B6fYd7V2EeizZ/yuyqijZpTpqfheD41bosqv2su6fnlctne9a53tQ/4gA+Y9dz73//+9vEf//Htuc99bvuiL/qiM/f/4A/+oH3ap31ae97znte+9Vu/tT3oQQ9q//N//s+1mdUXv/jF7ed+7ufaa1/72vaQhzykvfSlL22f+7mf2+65556ximHQbDo6OmrveMc72lvf+tb2gR/4gfcpL+95z3vaox/96HZ0dHTLryJYLLe1dDeJHvzgB7fv/u7vbs973vO66Z72tKe1T/iET2jf8z3fc+betWvX2md8xme05z73ue0Nb3hDe9e73tV++qd/eiM+3vOe97QHPehB7a/8lb9yywQICAoqkhOgwf/y5curAAEB+K0cIKATnYIaBC7u/DBAcPny5Y0DBHI+5gYITk5OVkGBw8PDtQABHcAqQEBnS+W7DOi4CehOBQgoD95Tee6wJFB7MwMEclLF9+XLl88ECPb392OAgLpRBQikC3Ki2bZVgIDy2zZAQBmcJ0BAsOay6wUIHKxLxkmPpwIE+/v7awEC2qJegCAFWhggoN1JAQI5/KrP7u7uSjddxwk6Tk9P29HRUQwQ6J4DC5UrMEfZK98EAvWtfkvZ045JlilAQD1mX/B6iW5GgEDtukmAgOCROiXdTQECB8ROvQCB96HE12Jxb3CVz04FCLyOcwMEPk6kAMHp6ena+KCPZC+9dXCbAgQa4xlUlVw1pnqAQEHTvb291XjSCxAwmOb1UllHR0ft6Oio/cVf/EW7evVqe+973xsDBLTP+j8VIGCZ0nGNsR4gYP/2vk/bxjI4niVAn9zmdM3HW4211J+eD+dBCcrOdZv5JJ9xiirfTGVeu3atvetd72pvfetb26Me9ajJ/Dzvn/qpn2pf8AVfsLr2t//23257e3vtR37kR+Iz7373u9tDH/rQ9iM/8iPt2c9+dmuttbe97W3t0Y9+dHvd617XnvGMZ2zEw6A7l4Tf3v3ud98SAYJbhZcpumUPKbx27Vp77Wtf297//ve3pzzlKefK69u+7dvaQx/60MkgA+nw8LC95z3vWfvcKNokRuMzYpuW4WVNRcN7gH7O/bl8OiCgM8qPHCjO8qV0dGKraH1y1umIuxPPgIoDSHceExBP5XuQwp0gz4N5efkCVnKQ5CTx22VJh3NKF0gJBFf1rPIkOJScOYPFTwUwEyV9c2fKdcyDF1UeU59KPokSaPG69ertQT0HfnK8XX89yMZyEh8MkLAM1yXKgY625+ez0Q4+OetXyTnpbtVW/K/f/K4CGP5xAOr8pHp7O7rcCW5k19hXK8DrfLN99D/d69kttq8HlTzfKngxZRe9Dh4UnbI/SQec5vShFFhh3ZP9rvRnE16p47LTHhAmz756zMcotwGUa69/qAxvt8R7snGV/rNODLQRlFf9N/VVyiLpuH/S5IICJy67VO+psWWKpp6v/ILz5p3Gnh4fm5Tr9N73vnfNLz48PNw4j9PT0/Yf/+N/bB/5kR/ZnvGMZ7SHPexh7VM+5VPWJu7uueeednx83J7+9Kevrj3ykY9sT3jCE9qb3vSmrfkfdOfSHB/uZnxuF7qlthi01tpv/dZvtac85Snt6tWr7QM+4APaT/3UT7WP/diP3Tq///pf/2t79atf3d785jdv9NwrXvGK9q3f+q2z0jr44DXR1MDRAxfL5XLrgUsRazklXI6rgTo5GM575WAk/nnNo9qUVXIIFovFGQDBgV357e7uru5pkPfoPB0DladPmhFqrZ1xHtxhkwOkNiEgUJTd28ln3uT4ObCoHDrdJ8CiM0QHkjMqyke8c6bL6+/1rIhtQH6SDrB9/RnqhNqHM63uyKVVI9SdOUZXsmC7HB8fr/LVjJnSuU4m2SR97jlxbBNek1zdWa3qxXspSEAd1yqVqbZlHckfVw44UHY5+H+2mZ7x4N2lS5dW/UY6Sp2ogBlnUL1uibcUfOPznEWULroN80BAyp88exk+a616y0awfylQJjlVwSDaOLflSadYhq4pjT+v9mcfo+2qlvmy/mlW1oFiCljyGebjlMYY8Vz1W8mcdsb138coPpvqyWuuowTNvqKCKylYhq9goJxOTk7OtIuI2xBOT09XY77XQf0rBQzFj/jwsdr55zXxpxUEV69eXQvot7ZuF2gPOTvOa15HyUP3pIf7+/ur8lVPruLhuJ3GLbe5bgurdMnfq64nnarSpHv+7NTYV41ZPh46VWW4P/7N3/zN7Vu+5Vu6PDi9853vbO973/vad3zHd7Rv//Zvb9/5nd/ZXv/617e/9bf+VvulX/ql9hmf8RntHe94R9vf328f/MEfvPbsh37oh7Z3vOMdG5U3aNCgzemWCxB81Ed9VHvzm9/c3vWud7Wf+ImfaF/6pV/afuVXfmWrIMF73/ve9vf+3t9r/+pf/av2IR/yIRs9+43f+I3tJS95yeq/9o30yA1uAg+8Pjef6loqJ5Gc0N3d3VWQwAfmTaNadHrTgJcc5MSzfhOU0cHZ2dlZ41lOi5wDpeHv5BB7gED3qtlpAlamlWMmmXL5bgJYqoccQ+Wl795sqbeNO5KcAVE9lJdOa03Ol8re3d1dXRf5zOFc/UhBjfRcAicCOAKyqV7O+zYBAn9WsuLsE3mmA6rrkgmdy56TpTK9fck/+UqAjnrjIKlnJxxkUJ8J8vWM9DrJi/LxFTqUC/Nv7SwQIFhS/skhl+xTngTp0nkGjZSWcnZA73aA8vFgAclBnedZgW3lqS1AXDKu55WedpW22gE5AxsEeJRnLxjA65z5p6yZh/c59kvf6kL5EPA5wCToTduXKkDU6+8O8F03/T8DOuw7HtDgfcnP9c77eQLNvOc23wPOHvDgOMLxgP3e+wW3CzmlVXE9OXudaAO8TY+Ojs5ss6Oc2B4eHHN777aP7evjIduFYzZlRhvGekwB+ylfhmm3IdZ5Th5VYGJqTOqNW1Nlv+Utb2kf9mEftvp/cHAwyaeT2uzzP//z29d+7de21lr7hE/4hPamN72p/cAP/ED7jM/4jK14HzSoR5v4ijeSh9uFbrkAwf7+/uqQwk/6pE9qv/Zrv9a+93u/t/3Lf/kvN87rD/7gD9of/dEftWc961mra5yB/p3f+Z324R/+4fFZHWp3XqKjy0Gmtb5z7zTHKE4FFirFPM9gcV7qBU4oJzpFHphwouNNZ195OoiiM5YcfIJUOZNpIO+1Hb8TP1WQhW3n+RN8JYc2BRqYBx0qUeVg9HQgAa7W5m+BcQeVQRvWkTxu6iA4UKjkXTmBnra6PqePpnz8OefTQRavTT0nveUsmvLiqpYUrOA1fQjkHIi7I802FKX+6TJkQCEFCVg2gX2St8pM15PsWFe3CRVoSnbF24F6nPpqNYPt9sF5SjyzbMqXaXy1ANvd5eTPEZTxu2rPnl1ZLvtnm8wZw5z4XJJVqnPiMenfVF/19vI2luwYHJrSR6X3VVYaD5Md82Cjl8Fxw/WSdU1jNPtVqqO+qy1cKivZN+XrbZf6lOqha1zlxIAWfQgFDFiG62tqjznXpuw/857y6dI9f36KaEMuiu6+++5z753+kA/5kLa7u3tm4u9jPuZj2hvf+MbWWmsPf/jDV2dYcBXBO9/5zvbUpz71XOUPGjRomm65AIHTcrncao9Ta6199Ed/dPut3/qttWv/5J/8k/be9763fe/3fu/kioCLIAdv5xkQtqE5QKoHuCrwswlPm4I5L1+DO2XB2V3Obqm8itfk3PU+nobPeeBnqv49J9cBYOLDgTRna/zaHBBK+SZZycmackiq9vWZNZ+logzTyo/z6E3isXLsE2gRv+5k637KR/cqeW3Tj6lfro+t5QNPlbaagZ8qz8vygFbv2UTsq9RtB+8OEPTN9BVA96XkyS4kYls52OF95e0BwtauBy1bux50S4CN+fZWDLG8KRmndFPtnGTYA9CpvFTmHBCf5FJRsonnJebBg/H8XhUs4DdBp677qpCkU16/KX7Tc1wBeHJysgocpGAxg3Fzx7eq71R9hGMRDwhk+h71QPMcuaXgga+STNf56fkJFW3qn50XqM99PtX7Isq/KNrf32+f/Mmf3H7nd35n7frv/u7vtsc+9rGttdae/OQnt729vfYLv/AL7Yu/+Itba629/e1vb7/927/dvuu7vuum8zxo0J1Gt1SA4B//43/cnvnMZ7ZHP/rR7b3vfW977Wtf2375l3+5vf71r2+t3bvs/0//9E/bD//wD6+e0dkC73vf+9qf/dmftTe/+c1tf3+/fezHfmy7fPlye8ITnrBWxgd90Ae11tqZ65tStQRVNOVkieY67XNoWweKz6WZhOr/nKDCnLKnnD85GD7bqYH+0qVLaw4NwZHPbJB3gtNq1tpXgDhg4oyF153APjmLPhPiMhXY4BJv8id5yBljgKBaVkxKM0xeR59RrNqQbannKIu0jFX/+VpKpkmrOlhexUdybFW+8+sOopxcyZJ5pZlYyszlyP/8rmSnMlzeDtDTUnJ3AJXOl4Xzty8RZnlcLePPTQWfKA/OcEov2bekv61dnyGlLLwe4oO8cwlxa21lD2QznLwPKr90yjnzdJkwCLFcXt8OIN3hPmiVq1Pftew7BfOqJd/sm943GCRxu+Ltl/Jk3lxl57aTNsN1J+lFb2sHrzs5uPM6TFEFIClTP5ujN8Z5YMfTUb/JI/XQ7XIqK/V/H++cL239cVJ56fwWHuan315/XyWiazycVEEAvr3nypUr7ejoqF25cmXt0E23V+w/IuquBw1ct6vxk8FI2htf7cJ24taNqUBBpVs9SvzOoUrXN+kDKTiQdNv55LVt6H3ve1/7/d///dX/P/zDP2xvfvOb24Mf/OD2mMc8pr3sZS9rz372s9tf/+t/vX3mZ35me/3rX99+7ud+rv3yL/9ya621Bz3oQe15z3tee+lLX9oe8pCHtAc/+MHt677u69oTn/jE9tmf/dlb8TTozqa548eN5uF2oVsqQPB//s//ac95znPa29/+9vagBz2oPelJT2qvf/3r2+d8zue01u6NHv7Jn/zJ2jOf+ImfuPp9zz33tB/7sR9rj33sY9sf/dEf3TS+pwCLaE5QwR31Xvo5PDCf3jMEZFNlbDKwsA4VsEhgh//p6BN0c+8ol6fLUefzDuzInwcIPFiQ+HUQm/ZuKy/lr4MV01sW/GAz1kX10QFnkgdfv0gALHn7bL2TL3UlUQaiSj/c2aicODqmlJ0cXAdAiX/ymvQ6rdiRLNN5E5R72mqhmTmBzkTkk6Am9ROR0lXLvJOM9RyBoNfDndwkN1/anBxHAmE/QC7t2U3givyojzjAkR6TZ58dle7ruRRoYzBBdUx14z0Hb3qHugOT1ta3GSmNQL764V133bWqZ/UGAp0NwkNERX4GggcCJJt0verDlKunS4EG1lHEFRLs0wymsJ1TWeKDcu85axVgJxB3e1eNQd6G+ug8CO+L1FHlSb5Vlgc/XI8pg6lVXSlwk9Kl7TRuv6R75Ed19XGFJ/1XgRsPxnmAQH348PCwHR0dtfe///3t8PCwvf/9718Fr6u8KUcCeF53W+7Pq99z1Ze+WS/JToc2UraVvWD7p3bqtVXyOXo6kOg8YKI3FlVl6pmpIMkc+vVf//X2mZ/5mav/OtPrS7/0S9trXvOa9oVf+IXtB37gB9orXvGK9tVf/dXtoz7qo9pP/MRPtE/7tE9bPfPKV76y7e7uti/+4i9uV65caZ/1WZ/VXvOa15SHow4aNOji6JYKELz61a/u3n/Na15z5tqmBjTlsS1tYjh95jTNEnh6Xvf7aaCaQ3TCWXbPOan4SA5Z9dym95xfOisOHB1kOrisgIKnb+164IFAgODLHUcd/FiV1Vo747SIklPNeglQ6zRzBQg020EgwtOu9bxmjypyoJiIAGLODAiBq18nUPdZLaYjCJrKdw6p3NSn2CZs48S7ryAQpbZtbT3A52X3eBUvLJv3VBZn3OUIE8SQP34rf3d8PeDg6arlwuSLZTpw1DWCHAH0nm7568mcF/120OT3HAQyOMBABYmBR9oZtrnKURBD+SR+uOqnKss/lLPbq0R08lMAwYGD8uwBHfFegSbmXfFUpeuBJvJAm+w2aQ6x/RW0ba2dCe6yXP1mMMmDUIvF9bcEJSCc5KR8fVyaAmZpfBN5EIJjplZLVK9L1HkG6XnWwV+Ry0CBggRXr15dfSuNyPXWAwXUrblAOwUJWmtrZzRQdhqzVXeO61NtlNpjzn/WizbooqkC+FPjTpL3eelpT3vaZF5f/uVf3r78y7+8vH/58uX2qle9qr3qVa+6EJ4GDRo0n26pAMH9gbYFMU4+Q3IRlEDDFKUo9K1EvQGocsxEU0GZTakClpUDXj1PwDV3cE+zLbq3CaX0PnsypeM9xzaBnyle3cmaSlPxMRdQJLCZfjPfqf7Epehz9KsKGvGay1PXt3X25rRtr549m9XTK//v8iYwTICLepk+zKt3r0cEZgSovO+/kw6lAEtrZ4MD/vxcSrJJdako6QABWGtnD5BL+XlAokeSbQqYOg9zr/N+dW2ufL3tqG/U+dS2fNYDWZu2TeLdg5A+Mz6lq3PKZF3mfBio6AWMNgGtmzyXqDe2zxmbBw0adPtTNf7ebB5uFxoBgi1pGwDPiH66nmYEUhmbOLbpWXese9S7P1X2lEM3d7Cf4wC6g1LNdqbnCbbSjHmiNFOr/DiTwdPjr127tprVIO+JJ2574EyH9nv6MmZ++3JrLu1OshO5XjnwpTzpdFJHq5UvrJPveU2rWdLzU2nJA+XWeyb1pd5WAqVJWxmqfChLgl2mTQ48Z695fbm8PhPNuipf3ydf1Yn5eZkVmN7Z2Tkz0+h1rMrQN3XVVwJoNQ7L5Cv0vL35rOrJdvJZVfHI99F7P3Z9XizuXY6u2Uc+n3RJbcb3z7NO3qZ63s8eqOoqfqeCEr1gDlfwVIE077uuq9Q/8ufbK9J2C9pdPUubW42R/iz1MgXhKrtX2V7Xd9bBt1NwVYG+WQb5rlZreT+SbrCc1D/9W+mk0621tre3t8qfW6xSndPkQZKDrxrQ5+joaPXhAYXejh5QUZ29j/j/JCuXW5IlV4po7PVVdTzk0bf+pDx7NMcfc53cNugxl7zvJNr0+qBBg+7/NAIE5yAOpKTk9CdnrXoulZEoORq92RwO7tVyQs+/50hV/zm7QkqDojtkidx5r5wcOWlaPuggRDzQMSVvdNBZj1SW8iUAIJAXmGitrb7l+MlpoRNCZ1y88DwFATO9X9q3GZDnxWKx9hz5YzskWbhD6PX2E9tTXmn7gN9LQQVvj0SVo+xgSWXw4DiBZ3esve4kydfPZODS3ApwsB+ovBQkSPVjG/qZGtQ9AskUzOGsLMG5k+u8g4FkC3r86zeX4Ss9D+gj6CKgoKMuoE3dJshmAMH5cNDE+qVT1tMql52dnXZwcLAKbDE4oDxpK8TH/v7+2haGFKxgedIlB+/K+9q1a2tbSVzWlR6y7VhGCm54IID18nNSlIbjoNqCADHJ2AM5zi8/3NpAvnQuiMpPdiTdS/afOk8bqHajznq9/Tu1Q7KrLmfalhQooV3jh1vipGuqn76pU0nOSWbeDuozfvbA8fFxu3r1art69Wq7cuVKOzw8bMfHx/HVlZRbWmovvWYgoRd0dFlLt9i3UqA2tQ+D8HOAfqpb9dxUYKh63vtnKtvlwWsVr6mMQYMGDSKNAMEW5JHvCkinSPGcPNP/OXn4fQ9Q0FGtBsE50eZe2e5Uzkk/JUNS5Qi746U6Vk6o8mKenG3wNF6OO74OKORwENxI9u7485vBAX4Wi8UqMMDT1h14eBvoHh0nB7lV27RWO2ettQi2GdhwIOKzo+TXy/ZrbJfkWLMt3XHmKd/pGc83BUZcdgJqrJvn48+7w8p2d/64+uTg4OCMHVG7i05PT9cAnPSN91NfclnqNwNQ1CGVn+ro/YB9wXn3PuRgUjrOAIHKv3z58po++Ixua2dPKvfzBRaLe88KSAFYB+cMEOje0dHRms6zjT0QxmCs+EnBgBT0quwPP94HVfd0cryDTM9H6Ty929cEjNh+XOXksuVvH+c4HhDsejs5iO4Bo9S+ye6xXP2Xjkh/PAhXycPly3ReDl9RqOdZJ7aNryq7dOnSanWL+FPfcVuf5JOCBEnHuFrCgwM6e0AfXZvyAdinKTu3w6o/Ax9OKUjAtqDsGJh0/dfZIKnNUplToN/vJb/ObfAc36nHR698lZv6zFQeI5Aw6Hanqi/fbB5uFxoBghtEFeC9mWVWQYbquTRgzy0r3Z+bz3meZ/q5g3WiTQdLOk29AEQPkKby0wwmHQf/kB996JjyOS8vzaR4HXuyoA7wN4FOBXoYsNAzrZ199WIlqxQk8DQsNwHhOXXSd5qtJ8Cv+oODL7/H7wTQKE/yR37U5mlW2//3ZKqy0hLji6BKX0UpWEA5C2wmO5XAWuozrCtBmsvByfVZ1xLg4r0qIMg8U9+fI8s5dr2iueX4M16/FHh0efMZBlH8OebrcmP5SY4uj22AVgXmaefTGOOz/Ck/v5YCUy6DZNN4X78rvXT9qtq8N5awnqnu6pf69sDlpn6QZKOgm+uc7rlM9Js8VvbUZZR0cBNKftemeVSU6jQViJiy8z1/5XYCL4MGDbqxNAIEW1IywpsAkZtBbvA16HP/YGtnX+XGE8yrga+qf/o9xWNPlryXQCZJzoWWpGrWh3sPdY+zCnyGM14VsOYMlA/ePmO6WCzWZoj0VgL9d4fRl66TD9/L6wEKXte+Sl5LM5VzAx3p/xRQYp4sX//ZrvydnOfEg+umlzvl7HjfoLyn0nAprAC6+HLH1svUc6xzL5DiZbP+CUClND0iQJ3zbJJTqmPqO1X+6ifcwsL8OOO3WCza/v7+WjnJzrGtevrgM4xptYqWmGuLAcvgiiG3S36PwMcBXCVL7+NpewHLY4DH76e8p9Kk3/6MA1aesZC2gKR8UvtQnrLhyT5U7Zt0ibaWq2S4uo5pE8jvUQLXPR5pI6XP5MNlK92pznGhLfKPr+KaCli4PWV6XwGUKMmf16pJiQSKXU+q604cZ9m3OdbqWb2K2OuaeJvqO6m+m1Kl01W/TH7TVH7n4WXQoNuJ5viFN4OH24VGgGALqhwjv0fqKcUmA0jleLtTXoEnLQ2U06plexqkec3znXLkdE/3e2AvDWIVGHFHyAEV66Y0qp8741p+2dr60mSBNi2Nd7kx3+VyueZIECSKV8lQ5Yu34+PjFcDhHk0ud1YgQfnRga3eSe/OzHK5XHuVU2tttRSVTnzl3FVbLRzQMX89Q3l6IIVtX7V/Ak2enk6v6zd5Ig9zgG2VLoFeP2zSHXOvVwWwXJYOCNhXXEa8ToDBfujBiHSYGpffKp0fdujAm3XyuhHcsB6UMQFLkqnqcu3atXZ4eLjSf+15Pjg4OLO32p1l54ftRDnu7Oy0/f39VX7qY+pvV65cWfGqACuf97wSKJONIG+UXwVEed0BawJ6vmqGaV03Uv6p/IpP1Y/nBGjZu/QnHe6X2sj7M+uh7TZevgKhDlQdXLNOfrirxgTaVbepbr+8LX18TEGaytYyrfLwPkow29r6gZZ8hau2d6ms6uBLjXOSh5/z4DLzVT3si9pykIIpiVKQoLWzr0nlNcpYOp5scqoDy+PY5M9oXFb+CrTruam6pT7n5ffGvU18xORveZkpbx8v3ZafJ5gxaNCg+xeNAMGGRFDa2rwl0e5QVEDBn/H/U0EI8sR917zuoFizMjwITQ5XtYxXPCTQx3RJVk4OclI5/nGHh/k7IFc9HTSqnvpPAOOAz/nl7BjlyZPL6bQSlPmBUqrv1atXV06WAgSqH50wBgh8Sbby8mAJAZqDep/ZF1WzULzmqx3cCZaTVYGAXiAg8dNzsgiOKBvdS+kTuQOVKDlb+p9Avs9I07HlzDId/dbaWrAq8elgVPnJgScoZfCAIIcBgtbWX5dGPVHAKckpyYpBIOqa/rMc1sMPRJQu8aR0HRZ41113td3d3dUZDayXKM2sUidVts56UB/WPmrxc+XKlTW5p7ZmkFXfBLiSM6/7O+UTgKcupz39BE2ub+wrvUBP1Y68loIDPg7Idim9QBaDLf4Mv5l34t95VACVhwhW/ddto3g6PDws5Z/GhQTKXBbeThWpD5AvluF6w3GBuuuz4Pot27y3t7cmY9WLY4r0h76DB0moqycnJ6t+QvlRJnNsqCj5HB5orIIELJP1kwwYLEn9n/1GzzFY1Bs/ev4Y7eBUgCHJZIpSX9oU6E+ln8P7oEGD7n80AgQb0lxj71QtpZsy5HQgzhPddVDDV/vwICgOuhpU9fx5BxGV0cuDvPJ6AkTOj/iXo6JXptEJ8uWumjnRvcphJdBmWzroIBinQ9Pa9bcZ+OyS88rydN9ncBKQoCOn1QMEYr4qwEFaz1lLDrsHD1L7pd9JT7x8dwhTuSn/5LzPCRC4c9UDSg5ECSZEyXn19O6wc4YwOZaVI5xs0pSzyfQp2MbggtfDnexqtjS1ZwKCqV4k6fzx8XE7OjpaBTUFigiaHMzyULc0K6lvgS8G+fjKRa26YloPEqRAgctif39/lZZB2iTHnj31rRgpoCeqdCGBHAfCTFvxlfoq39jC8SS1b+J1qi6eprWzK8LcBtM+EJTzAELaVqdkRyp9dZkx0OZ6kuw4ZZ3ealGNhbou8rfhsJwUYNYz1AHyQvkw6NMb1ymrCnCTekGFZFv4P91XnarxUnZXtkQTLOr/2/hdU/6Q8zkll15+1fi2Dd9e1rZ5DBp0K1Jl2282D7cLzTuRbtCKbgUFOy+5E91a/crG6tp5aY6jlcBnBUo9jznOpa6548jrIjqfidLy4jkyoLOXQCIduOSku9NGSoCD6ZWmAvQVv6zvnHYkubxTuQmgJF68vHStRxfh/KRghL79kxx7X0VR1asHoqf67Jz+Qj1zHd+27GRnek7uJraVAIXvXe/lk5Zasz6cHfXtQ6TqeU/D31XZ7E9c3ePpKxvlMql4mdNuFSXw6m06JaNK9yteK7syV97Or6+4am3d9lX2PsmA9+e2Ae/5mOu8OjFdT55VmjntkGTm4wW/01sAKNvzUgpkzL0+h3rjVk+W56VeHucB9OfNa64PMGjQoDuHxgqCLWibQTA5Q631I72LxSI6qFVaN/I9x761dYfYZ9jS7NcmUeUpYD7nXnJo+C1eHbTy/fFctq36Sq7cv8rzALzu/K80lIXkpWe1HSA50q1dX86dANrR0VFbLteXHmuLAd9BrTSq1xTgZ30pX59NJWnVAdshvbYwLWmuAgiUmzuUTO9615sh7V1vbV2fmb7ii9dSfj2QK7mxjq6vXLrPrQVpJtqBlAMllem6kAIEboPUD9zh9zowj8qRTADK+4wDNIINAnPnhTzITp2eXj8X4PDwsO3u7rbd3d22v7+/mgWkDHUwqHSJ+qSy9OrCxWKx6m/cZqD2SiA+yTbZfM4Ga/ZS/Orjy+X14RYP6ib1xYNRCeAQzPX0uwKNbm+cyNdyeX1WlnVWPZUHZZVWOzk/zid1gzqnwBHTk+dqW4fSJXvg+XDVVy9wwLYR3+QlBWKoKxw3OL5x25pstNJp9QBXBTCP1tpaO7A+XGWhj15jqFfuamzSdxXkcHL7RJlLltUzyS9hP67I9VIy0DMay7RCSfLnWRrOT/Jzqj411ydKtEn6TYIDiS+X06BBg+5MGgGCDSmBBjeim0Z0eyDcAeYc48+lixUPdPa0XFVL4HlgUTWQV9QbVKoZkwoYEkSlwIC+md6XCvMwJs6O+j5UOZJyCAhyGWRwx518yBlWfVgWHde02oBLG+V86XN0dLS215OOWAJcLnMGSJxv1U1OUWoHtasCL3rW/zuQT8CWukEH3J0+pnWAqN9zggRpJnZuX3R+WY6DBU8rkElZUSepAz57zLqS755tYLt7kCjJTR8tr9YSerVJkrMvUXYevG2d2P/kcDMwwJUAFfBUv7p27Vq7evXq6t7+/n676667VjooGXAPtnjwgJHK0150BkyUj2QiQEabRBujunn76cM+xn3jek4BQfLB4GAK2Lg+EyCmQAXbOfUZpqPuESx6eyd9o73Ts6yj237qWaUDSpeCA7wvnpI+6dleUE2UznzwMUSUggOpfdn+Ll/vQ8yT8tzb21u9EYd6TH2kvroukl9d48GD1H1ev3LlyuqQUI1NJycn7erVqyt5OznoTHJx/fMgkQdd/TrHoORPuL54P1K7qo+q7jyPoacnveCAqKq73+9d7+U7J802vM/1OwcNutVpbgDzRvNwu9AIEGxBmzZwDzRPDQTbKhOdieo+998zUJCW7s0Z+JS+V9/ER8qbzqKDdaZxQEXAxRmW1tqZOvI7zVomB9YdOTr+IpbDevIZnzWmg0LHjKsHeNiX8qycX8rIZ+nFIx1VzkClPFy2vObtV11P/FU8p2vuZPJ3L1hAPUkgO13vkQNBv07w5TLVCe8pSOROPP9z9YvLh4Eh6miSnUh5y6H31wgm8Oj5TAEhl4/bFeovQXACSyr/0qVLqz4hUHLt2rXV3v69vb12+fLlM2BNjr5W0VA/lUYBgjQT6mcOpFUE3se9f1MPHdDyebW322MCUoJL15Oq3VmmyuoF8So9o/1J+uB64/mrzWlz3MZKdrRvDHS6fWafIX+c/XZ+0tkPiW/emwpy87/LhXqdbJzk6ysR/LnW2lqw0dtcupEONmR7M4hDG5LelKMAta8g4Cqb1Oc3oSkbzGC3p6X94/dcfthfGUTUgY9Vmzr/bp9TH0jPTuWdyurVZSoPpklj4qb8DBo06P5H4wyCQaXTcx7a1klI+bjTVjmeTO+/W8uOGutK0JLS81rir3KM59atArtzQPU2dN58xSeDNFNpp9JtU/4m8r7V6KJ5muMYVmVeRL93PhLYr+5Vfay61tr6QWsJcG0S+NEzvrSfNNVXUzk9+1XZj2RLqhn1VAenKlA89Zyu99qQdSFVASYGTCr7x9/n5b13fRMwlvSrKmcq36Rbc9tX5KB/jpx7bVLx6J90/kC1tWIu9Z67kQCVMuql2cZOTz1zkT7SjaIRHBg06M6lsYJgQ+KsCyOt7izMcRx717elnvPv0XbO0JycnKxm2RRdpsOiSHqqb+IhRaE5M5L49RkoOjettbWl/u4c+TJtDvrJCVL9xI+Wg7NePsOierFuVQDD31Mt/pWfzzouFou1WRufsU9vWLioIAEBkb9ab45zxDZ1Z6sCOwlg+eyZl+FggTM2LDvxXIGR8xJ50EftzSXovk1FbafzP/w6/08FVHpAmP+5SkXPprTSiQQqvF9NgUb+5owttxZQ79OH91WPS5cutf39/TW9ldy1EkFlaZm+eHBd4itE+ZpF1620msl1jn23Fyzwe2xnnynnTKbnk/JI+sDZ15SHP5v0kGcxuI3n/6r/yZ5q9lvvnPel22x3jkP8Fj9qX13jK/dch1l/3ksBcn67fDxtkp23QxX0ct0WcVxzvjWO+GoOypl1TkEC8ehpfTUZV/dwhQ/7i6/AqGS1KSVdcz2eso/UT9o//y9ZU2Z83bM+KbCTeJ57P8kp2dWpMWBOOqeLbKtBg24Hmuq/N4uH24VGgOCC6KKMbAWYt82D5AOIBvajo6PVQLi/v39mmSYdhpTPnLJZH09bgRoHyQkA+lJf33Pp31734+PjlaPAV0GxLB5aJP6SYyVS+XTkkvMth4eOohww1WNvb2/tNVyUI528tM3AnfgUtJEDKFm6zNKy5J5DUgHK3ioDtmcKIKX6MMBCZ9rbpuIrAZtqFmxKp5Ufl/SSB+ok65jaLumo95MKSDtPnifBgX+Yt74ZSKRcCdSSM5sCBNRz7mnm+R8EhTyoj4BP/HD/tfdB7aFura1eVcZ91Xzvu3jj1gIHBewLbo/YR7yfuQ6m4JmT9IXPaEvK7u7uGUCYbAvbzvOuymab0Sb02tb7UXVdz9GWqJ4MPtD+qU3YJz0woK0mDBAw4KSgatpSsrOzc+bQR6+j2+oUHGC6NHan571tGHhxfaIueEDBZZTsELfYsZ24xUNAmMFpyVLf3F6gD7e9Obns/PocP8Htj/JKW0yqNiGpH/OMJeWvdvBrkrO2czDv5O95nd2u+m9PM8fXmwpQuDwSDyybaZIsBw0adGfSCBBcADESvY1RTYNCGlynBg93RkW+N5ADMAd3zaJrxlppl8v1w3p0vQL2KU0ll6pOaRaEjkICYGkFQQKpdDaVl/777C9BnJynlLc7HNwHylkKnzESL5z5ktwkc+0z9UCNt3eaCascW13nM6enp21/f3+tbVgvgo90yri/8cBlX4GSpJdOqd4u8zRT5mlToMLrV1ECw7wnHVSQjfrpwJ/6IL4ITl0+yRGmHjsg8bqJHznBBMupztRTBrzIayWPFGQgoBGoqA7d9NcMcqaUsr58+fLa7DpnkZVO9T06Olrxof3Tqk8CWpQ7wZavHqCdZbt5ezE/L4OgiaCQ/YZvW6FsnHS9N1ZMgQE/6yQ9n+pRfatuDOS1tr6q4ejoaO2APB6GyPqofjwgT3rk+sayUt/xfuN22eXilNJKNtXzbm+pr2lcSQcZerBNefLtPfx2W61xzANhDHwpTWttdeaAAgR+7kCyIXP8oCSnpLesn/6z3yVy25z+S768JztAP2B3d3fNN/LAlb5pE13/58ok6dAcSoGXOf6XeOS3p6f+DRo06M6hESA4B82J9t7XRIBL4oCcnA+CNR/05parcqrneoNXAkXV/eqTynKiU5lm4xKw88HTZ6zp5NHR8llLdy58FocOdXo14nnIy972+SnqtYnnkxwsUQqQeDvM0ZfkiM5xnnp8e/nedu7MUuZz8neZbNpeXn4lP+fPP8mRJH9TvFUgJ+mgl62tGCybq2wEJrm0vLWzJ4+rj/EUfS/D6+a6lYKCLheXlc+eM2/qgufLNEybDt1z+SWaeoa64e1OW1blXQVHRB4403PefkrrwY4EkPlMtXIi8ePtlXSmGpvID7/9fo/YF/Sc2z7XEefNeXQdSoFZlU0dS2MYefQxygMDyT6pXr1XVvaAcM93IEBXOgY9psb/ykfwfHybgbfVXJ6r6736p3vp/+3ghw4adCvQrRDouq/L34RGgOAG00UZ8ArczKHkNDnJQdZstZwBOoRzgE1FvQHbHaMKcPN+NYvPvNNS8+Tgeho3Ig5UFov1tyA4j+7wez2Zrztb/M92o0PtZxKwbnScnJ9ECfQl0F49N5cqvakctU3zZpv1VitUPCT+XDYV0PBl6K5/zkcFMKpgnINDr3MFsL2OPUo67+W4Purjzrp+p9PQHWT4M5IbwaGDSX+Nnzv1Lj+eQcC+pllBn9X1Nxbw9xRArkizknMDKD3QoDo6eVAq6WsCcv47/VfZU9SzFYmnXt9PeuPyqWxsb9xNcmZ9Kd+qz/OZJDsHyW6bq2d1LYF35aM69oL3Pb7njAviPdmZVL85uuH1vmhgW/k52zrkyf9IsptTlykd2pZ6QYTUz+c8P2jQoEGtjQDBxpQMfbXUs5dHcgI3BWIVkCBPU0vx9ByBKZd3itd0SN4UbykNZ9BTPX2LgG8dIGBw5z2lS79Vjg/6lIXz1dr1A+W4d1UAqXK8vc5sHz/oSTObWmrLvHZ27t2LzKWPmgVNTlvPCfdr7vh4MMQ/CfhWs6o9oDN1rTfz7fJmG5A/6naaxVWaCnil+rfW1rYNuJ663iXycsQf+53rJb/dea+Wg7ssKL8UcHAw5q+Cow4I9Hh62hJ/p3pr15ewM0hA/ti/uXKA7a405IdbcbxO73//+1d1pX1judxGwNUJvlzb+0laxt5rc9ZTOkdZM1+2Efsot1XomZ7uVUEFb4PFYrE2MzxlR8gXiTw42E76mOyGthLQTvphkpRjWiVHXWCdqRu9OrGPp2dSICClqVbMJHAn+51eU6iPv5aUts3HPN7zfuz11fMpmCe589wHPs/2cNvSo55euWym+hjbexPQ7qtVPECZxoCU31QApMeT27iU3mU7N++p9HPaaNP8Bw261SjhrvuCh9uFRoDgJlDlbMn53SSa3gsKpP9TqwfokGjw393dXQFU7rlL4KhXX5LzmBw6f1+znHKfyVssFmv3Wlvf989rlaPkgJaOBfcYOthIgGuxWKw5dXTC0myUBnmeDK3f2ot7eHh4Zp+zTv1urZ05xM2BhMCGBycS4EiOu3STgIvO05xgS6UT7vykoJFvqej1EcqBOsJ243JXryv5cRm5DrnTznb2/pEc3PQ/OYRptprp2ebUV8rYy6+WTidZUa/8wNKDg4NVPXlAHFe+SJ8PDw/P6CcBB8ulvCkXlau8/UwEto/Xgf2Lcqz6OYONOghRwTldd54reacgEIntm4I81McKzJEXD9w5eOQKC7YD+4fknEB7ytvtJ9MwmMJ7FchhedIPt5E81FLPsGyuxHI7zXZg27Mt2YdZVz3HPujBAf5OQYBkr1M7cquL9FA6r2d1+KZskcuR9sOBsPic8jkY7PNxygMEKqcKQrHs85L7DpUsq2vkl78reUkXJOfj4+OuDrO8qv9U5P39RoGJAfYHDRo0RSNAcB+Tz2y2Vg8KvcEiRew3GZzkmGgWTrzRmfbZGDmlqTzdT+CTIMhnIZi2Cg4QHPhy4yo4kJzdBAw9gs9ZBDridHoIYpLjUIEHzsoQjPE1bXqeM7Y6YC3NDBEkkSrnLDn5DCb46oi5jkVylCo98UBByqMHvtwRZ1rWpXLoKr50jfKX3Pf29tZ4dl3itVS2y0S8cgYyzX462EjXnReWk/Iijx5Q6cktgRufbeQBclXQRnWXPKmLukdg7sFA6g/772KxWIFJHVJI4iys2lS/2dZ++KnLR/Jg/0nt6+Qg1m2PP88yGKT1OusZXwWmMmm/CJYrG1iR86Y20D3ym9L6dZcNA04+k01K9jXxSnlVfUfk9XAbkYIDzM8DBN4/mF/Vl8SHdFMBEJ6z4XKu8iTvyrdqE5cTdZ1tMmU3nVLQfVugWgUJEk3Z/eq/T970Ahyp/Xr9OPFVpZtTx5R+bro5QYgRUBg06M6jESC4BWnKsbyRRKfAnQh3eqb43GZQcbDqefWckW3LS7975HLgdwXQUx5zyZ3RtPyxouR0bCMnd3p1rcrL77mDvqkz48943Xv5Jd6rslI5DFL1HO+LdqLogLueVcCkl8+mNiXpeCVL2Q0HQ55HBURSsJDgJ+n7eeTN2VjnJQUwWM8eqKXNnCvvJEvxVNWx0sNNZXKecaYHQOeUUekS23mOjZviq8dPj7dkBzzoklbCVWXx/1wbuG37JDs9x/5dpJw3obk+j9u/8wQZElXtmSYe5tJF+HI30h+8L/3NQYNuJs3xA28GD7cLjQDBOagXQRf1jO9FLbmbO7ByhshJDrhmqDlT1XNYp5xY/+1BB12TA0bn33/rvs8eevm+1LbKj3n02sIDAnQUvdy07NLzSqsD3BnmLIvP5ur+wcHBakbJZwWT7D1/X2WRligrP9/zyiWvnJV0hz4tZWWf8P7BrQDOu9dhCkQk/r2OKX+1JeVS6Z7TnL7g/Om3r0ypzhVQ+gR0CHRba2t5OIAn+E48eTlKx1cGshz/+MwvtxC5PUptI+LqGeqen47OLQucaV4sFqsVH5QR66Try+W9r0FUP9Wzvh1Az+oZ76NJjqluzrPSeYDE5ZF0vtfP9Bz5mQqcpT6R0lTXU9CI92gLve5cNn98fLzqD5S58kpySG99qYJBU6tlvF4uF5H3I+8fHnTysnxFCVfi8CwObiug/GWH+UYI6pETA2TMq2dT1e/82Tmz+VP+zhRQVT18jK342Ma/ok30sdhXEXGFgcuxR5sEDqsA09y6pOBblXbQoEGDSCNAsAX5LMCmUewqsJDySQPCnPKSYySnoxo46VDov4OW1tbfR5z2WyfHQtfcwUtAlek9eMC9wO7E+HcaYNN2BYINyjbNVlB+XH7p4IVOqnhKTjmdDz+gjmXQuSS/ch51dgHbmkCQsuYp7Q6CnXzVgp5ZLpdr78x2x0z86TrbMwHbRGxfr0flzKb+42DZA1HUa+bje939ucQvvyvnzMGSrvkWA5dRFVRxeTE/OtTpfeXOm5dXAR3vd9TB09PTtfek67yMdP6Dg0hvb8ldoERnj6gdyRPrRwCzs7PT9vf3z8ibsqF90vveXdcZNNAzBBJVYI4yTddZf14nGHT5UC6eJ/sJ5UKZ0K4k3vidfouqQB7b15ekp7rzOS2pV/12du49GFbbVbx/ka/0pohqPPAAQQKXLnPKlXXWf3+7jPL3rQUuB9kb8qhnFbCXLkg+bkMUUFB/070U/OXYRRnOCRCkAzJ9y40Tx5Y5vhJtnMvT65H4rNJPlck2dr9H7aP/OgfC7TP5nxN08iBDZd+neE//q7GIZVf8DBo06M6mESDYkpLTPpW+MuKep+71BhcOKu5YV3lWSyGZhs6FHHJ3knTglw4pcyAsSjPqDhAdqNJRcWfFT4qvnBjKL133MqbAsWTk+z7ZPnIWxKPvW/bXGLre6Fn+TgfAtXYdyOr97zwwSm2TnGgCK3cIXQYOEvl6R/LgciBQckfa8yafFXkbJ/3okS9F5exampnlR4BW+3+pu9X3VD2YPgEX1zPed2BeySnl52Bsym55cMCBFEGK2lwATqDGz9ZQeemgv8qOEQj7igGlU5mcjef3YrE4c5CbyEH9crlcrZBYLBbt4OCg7excP5iRYM6DCwlMMt8kb4JH3qcMdnd3z5za3+sHHnT0vNmelY1M1wie/LoDZpXD1TteHq95wJc2UHmyrm5zvGwGVVJQgeW7jVC7qK68zjGN15QX77PP+AoC1iOR2930dhPKk3X1tFy9I0rBwl6wh20g+bD/uWxJDPqnevq9yiYxgOp9thqHqsmQilcv2wPjOjRSQRvXJ8/LfYjK9rouzx1XXBZT46E/W/FRpR006HamOQG7m8HD7UIXs8b9DqPzNvCNVJA5A4Q7xU7uQLojzzT++zz8Vo6p/04OeC+fCmRW96t8Up1dTv470ZS8nJfkLKQAioP+VIe0WqNHFZhIckjPen0rfdqEKpA8Vb7XIzl0CaRQplNlb+KgVbz69alPL8+Udq5zXOVT2YV0Pc1Sqyz/JB68z/baoKojgRwDYSm/Xj392tzyK0pt2NPN3rdTktMcINDLa1PyelV6m3hxW9bTkR7fFbntq/pTZcOVx1wbmvJKfb16vtd/9J/p03aHqXI2pTl6MUc+5yEPTtxI36qqy7Y2/2bRrc7foEGDbk0aKwi2II/8JyesF9ntRdLnlslnNnX8pgZtzapo5oKOms8OyxlJKwMq5yqBVl2vAG/1ajPml5zJtJWA9eGKBJdtz+GnY7JcXn/tlNqJs63L5fLMvuzKIdWMhXhjedQtn6VVnTRzxuXFIl/i7TJOgYUUdCAPrV3fmsKgQ9U/Enlf4XVSL4DDtu/d5yvDWK/0Sk3Po+rbvNcDbFU9/FoC2bzu9WI66U8KjlSAjddIVUDCt73oOb0elfkkIOYBSp+lY70qcCWZMY3LmHaFM6jeP8mb56k3MVy9enXF06VLl86caUD7zHxYZirH68P8/J7rZdVnvG5JX/S2Gu+niS8nbwvWlWWlbQwp/zkgUvaQK0kqGyqqrid+e/03zZbr+hxSOVwRUaVzHtjfpIscF9LSfcmEdplbg8g724fjk/LTSiGNX621tZVBXAHi9mDb4EA1HlR0enp6ZnXRFPX6p9sgjslprOzpwZz+5LRp8C793ja/QYMGDRKNAMEWlIDCVEDgPEZ6DvjoOUoiH7DT4CiSw6C9xJcuXVqBYH/Wl9vKWegN8g7ifUacgF7L+tLgnIILBMKeRyqLYKK19f3L1TJcB0la2r+zs7Ny4rSPmUEEf61hr43Em+911POej+pJIKctI3SIGRyh/PnqNG8jykp5p4ML/TleqwJc/O39qXI22f6+bJf3yYecXQacFFRxHdMzUwCi56DNAS6p3mlWrAJZ4lkAm23iOuaBAw88OI+eD88X8PrKDuiAP8qEM610ptlfPcDowDL1F7df1IWDg4MzfV6keshusX4McKmu2tet8nZ3d9tdd93VDg4O1mTPPsJ2Sm3rvLv9EnFJddpOkII+6b/bOAYQK2CfyvC8U7DA01TtJj6qcpx/bRMR3621NeBaPcu8fcxpra2BW08v2fv5LrzXG3uVN8dIleVjl/iijdYz0kPltb+/33Z3d+PWGfYVgljWmW3j4xMnCHZ3d9vBwcFaH9NYpzEgjQtT2w4S9fSEspmbT/LB3DZVfor3ZV7jeEl7W5GPfT1/LvHO/1PleD767eOp163KZ9Cg+xPNwUk3g4fbhUaAYEOaAutTz/UoAQA+nxwo8sMod1LC3j3nQUGBo6Oj1R5YXScRnInSrEZFBGt0jAju5Qg5qPVBnHm0dh0wMw+BPn0TOLtcHaB5veVUETSpXAHPNBMqBys52D4TTgfPgxHMV3UjuNDBcQ4GXU7eBomfasbEgZXS+qqSyhEjJbDsOs52SPWodE/y4Yn0ktfe3t5awID16AUA/FrloLlz2pOD2oqz7OxzrofiOW2d8H3GCQT1QDd5UTtLpwQEWmtrgMXzpRyVB/uc5J7q5sEJT+PP0T7s7e213d3d9oAHPGCtHQmE5OAzYMBT9ReLxWpFxNWrV1dl7O/vnwHz0vd0SB557AHqSufUZ6WvsvXefrQRzJt2Uh+tNOLBnS4fUZI99aKqj+t7r/9MLb9vra36LnlkHXrPV32P9rkKEPiKF1Ja2eX1U3v5wa1OaQxU/WhPGdBkEJNAX/89QJDS6/7JycmaXMWvH/DJYID4lg2i7qUzQRzo+v/eODHH9+LY7f4Bgxzkk894wLm16+fV0B9pra3OXGHeiedNAQF5n+MH6roHABj8Yb7+e27+gwYNurNoBAgugGhU00zZrUDbGHg6Dzykjk6VD0Qp0l2VnVYN+KDO/wSC7vAyrefNVQM+ez4XtFXghSe1c5AmHymaX8madfGljayfz/IRsDgw5tspPCCS2oCUZOyOZdID1snrmRwZ3qtk4zz587xO8vb3gEJaVcK2YN7OY0rTAxRVfV1+FWBK394efIbBm2rFQM+BTeUINOugrtPT07a/v18CfekVAQMBSJrBreRS2Rg+I0d/d3d3Ffxx2Xjd3HFmW/pBf4vFYhUYJE/JLroeeJlJf6SHlBeve+DN83eA4zY0las83b4n8vZIfZm8VUEPb7d0z3lsbf00eZcvn+csfSLaVweHqZ5z+GS9md5teapfRQ7ipZfK19MyfWUPXU7M33VaY4gCVAx2+Pg2pz7bEHW5ol6/65HbGtrLpF8+VswJbkyVvWkQoXq2GltF1fhV5TFo0P2JeuPazeThdqERILhAooN13nzOY6TPq4Aqn8twW7sOSumkiE86LJVj0gNN6Zo7tcq/l7c7wWkwPK/zkpzblCflpjQMtiivue3lwL4XaCC5I5xkOdf5ZZqUngDXVxJUgKyi5NywDE/jgYK0hJc89/QgAbtUBwcDc9pyyont1bu6XwUOWusD4+p58qb2ZFDK5eHvXK+CW57/VF9M/DilvBIQTs/od4+vlI/6MbdbEGAkvaz+p3u9vs2+7M9UelnVzYEX61oB54rPqXpVYIRl+e9EbtsZ4BC/6S0lPZrSLw8SuN2u/ie701oOcrueeR/z62mJvxPbyW1y1Zd7ARp+qBtsC3/7hPNyXkpy3cSebnpf1LMl5/HVLhIwTPXHVAd/5qKDO4MGDbo9aQQINqQ54D2tHnDnonLiSJsOrr08q0F1irjVQM6A73NX3n72QO9AwV59CfCmwH56Xs9pib+/GjE9TyfQ7+t3tSrEwajy0fJlzcroXtr3q+t01nwvqcrgO7ArHuksJwcyPZ8CBq6zlexZNgNLWspM8rZIuulbFHz7jDu8Xhdvc9cD31IgHrwtSZUjnQC/g6CpvuyAPoENlqs8fZZZcmE+SbZepjuq5Fk6fHR0tKbP1GXda219hpLBMO/TlL+eS8vWyU/i01eAtHZ9i0Ei6rrPxhP0cEk2Aehyee8qiitXrqy9VvTg4GC1FUrLv11XEtB24FwtdXfQ6UGCBLwpO9dDyZwrFpK9UP3TtgbymMpmHXvgo7LH4jHpprevbAT5TEGHxK/anfmk+nk/5fUEuFO9qHscs7jdJgWX9a3AlI93HG99DHHbzjrwU/kEGk+1Ukh86JuTBqw3tyIlmft4m3RU+fgYy+e8bfQ/BYo2Xd3JNqGt0RhXBeunaKofTfls1fOb8JLyu8iAxaBBg25fGgGCLahn2HtGvQcu0u8pHjQ4VeDKQWHiVdQLKGjf8c7OvQcU8b3cOg07LT0k6V3yiQTY9Fufua+Y4z0O3r1DCacCBD1iG5FXkb+tQHu2CeAqfgi8vG3oWFZbPXiAFAMlvveUjlty0lw2pDQz57OadLLpYPnyYNdRdy4pG4J3d86ZhoEhggkPFrDdHAx5e08BPAKgql/1Vn2kIEACl7rOvejkizqW9NTzZTp32MX7yclJOz4+PhMgIG+qu9p1f39/pY8uPz9ElHwzTxL54TkG1G+eDeD9PgUVvP8S5Cmdgy5tLTg8PFyBNH10cKFAFMt0cM2+yPo7mGM7uf4mIMy8vd9I1tRvP4hT20Y0C6/0DoCdqjbj/Wp8640LKb3aXLJi8EJ86z9nstlfUltTNqmfp37IPpSAp/NNYkBANorlcWuL56f97ycnJ6ttNJcvX17THQWo/fBN6Q/LUL9OwSkfn3UWhAIEHHPcHlHevTc4JErBEsrQxxtfzVDZ7G2J/UcylGxTcCX1ybnguxcAqcbnyn56X3ObnXzS6vlBg25nmuvj32gebhcaAYILpJ4TlAYrOpFzAgJTaRaLxdogPEcRCTRTkEDEU/p13V+bR6JDoby8jGogcse2FxhIz/pSyAQIlJYAj3WuykyDsKdVvnK+FCAQESRxRpty8t9JNim9zwTxID46jnT6yUfVNk5p5t55Yb3kXPlZFiTWycv39HTOnd80o+Y64AGKqt3JC0GBAzqmn5KhA1bPe+p/Ap7uGFMHHBgmnXE56K0lui8AkU6NZzvo7QH+2jPKyvs0+6HXz9uFIE/PKxgo4OJ9JMmfecrRd12RXHigqYITOoeBgQoCmjS7XAHrysFXXSmXJB8PIKQ6EgBTLqyb/nPVR0+OLJ98Tz3j9fb0FcDx9mH/5iy46knb5u1RlUG+Eqhjf1M+0glfal/Vk2dv+AoaleGBO+/bLHO5XK7eNqAyqCvKT7JgX2MQobeCQHwzKM3DLKkzfgAwy6/aeC5xEsJly7ZnGcmvmeNL8bf7akkHE02VtSmPPX8x6Uuv3Ko95jw/aNCg+z+db7P8oDuS3DFKzmtyZnU9kTtWCdBztqVyGqv/29axosoR9zpOgTwHUFPlsvwEtJIcvP4OlFmPqfpuSwn0+f2q3gmAkK8ENFK7pGen0pyX5ranP7NtWV5m9Tvda60+nX7Tfu66yGtz6pvApuu0628q87yU9InfiWcHZ5v27YouIg/mM5dc1ume/74Z5P0+BUhuJG0yvp2HUp1SoGJKP1K6yh54+VXf84Df1NiT6nUemiPvi2qTXh/Yhm6Ersyhm91PBw0adHvSWEFwDvIIbAIqjPgul8uNBxhG4v16yivN7E6VMVV2a9frJwDBswkY1W9t/bVschg8up/qpYGLryf0FQA+G6prWmbM3z6D7APjlCOVnDB3QimXNGtTBQd86SVna1M7VCDYX6smnqRrXELsM798Ld0c/fDgDbc68L7zzDpz6bLSsPxUlyoYRD5U12rVSNIllyV5SG3s6aq+KeqBBwfZvWXKLttNA04pD3+eM+NKe3x8vJopl9yq+qb2bm1dV/jaRaalXlZL8ZUHX+Wpe/5OeN8u4HJ1uaTX+Hm9qFdsK65mEF+yiT5rKnlQ/2hXlA//p+0G1Je0baUXvHD9Yv600bQr5Ik2R9dSoMl56fHk11y2U0CKdsh1hPVKdWcZqQ4p2EPb7sE0ryeXvrP/uE33sdzHcQ8Gq9/Qnl69enW1vUq8sN8ul8vVWQF8La/3uVQXr5fkqz63t7e31r8pF21DFN9cFbOpX+JbDHo0ZZt79XPdJ3kwhNfm9MWpexVfrjtVv9hEpm5nz5PXoEG3OvUCqDeTh9uFRoBgC6oc5NbmNX4VPJjKm1Sl98DBFK/VDHJVphxkbjmQ86N60Hnlx5fWt9bWHDnlISeHZwik5eJ6RuDAn0uHJCZKgCs5g0m+lKOWavI5Bz++n1J5a0+pZKw6ENyyXQhIWL/kBOu6Bzn0fmvW3WWSAjuUpYO1BAgcrKUl7/qWDpFvd8QkD54j4EEiBgs8UFLNepFXAiEHqd721f+0/UFlOpD3VwCmvLn8uwoIUFcd+Hpbkk8tF75y5cradS09JtBIwMr1Qu3GQyr1XBXESMDM2/3g4KDUB22jSeV4vn7N06p+flbF3t7e2jPs0zrn4vDwsB0dHa3pl/qzv1M+1ZXtnQIvai/qKO+LUsCmZwfZx/11qSqT5flyb+lx4sPrwW+S2oH59IJm6hPiS3LmgYs8s2JqHPDtIR4IcLvutiuRByg8SMQxkDJJAW7yKTtyenq6FhzTmQQMFjAA6FsxHHD6wZwMAnnQwm01+WLdlA/37Pu4OkVzVgRyTKl8mBQcmAoIOJ/u21TBJi+7R3P8wDTepDF3bplz6XYCNYMGDboYGgGCDWnTiGoy4Bzot43QTkWmN4lkz8mbjoIGQh3SJQeFzoOcSRFnj6slwA72/GA5DxDQ+d7b21s5RimY0Bu0nRc6Q+4wurPmzlNyJFPQQc8JmF29enXlGOu0aAYJWmtrDluSAx0z6gBXJ8ihWywWK0C1WCziYXIqc0o3KBemcYAh2bqse9dVJ3fMyHsKKFWrCqo2ZD29z/J/FSCoQKfLgQ4sAwP+NgIHkK7LzIMfBe78ftUGKufk5KSdnJys9NDrRzkxyMF7CZDSBugZHYaWgmgOIgla9/b22v7+/plVBPqwrQWgK3kQnJAX10MPMLFcP4xUvB4eHq7aVjxdvnx5FcCSXOYAhqQL+qgfeL2cqj5G3dbvFIzUb1+tUAUn0iqQysYmXlNbpLQE2HpO7bS3txeDohVV8mOwItn0ZCv8+US0J67zuk+7xWBHa+urwcgb+xsDwEp/fHy8OnSUQVU+Rx44vtEHEO8a11tbD4B735ANV5/sgdqKqv4gom0mX55O/12/Sa4HaWzzQHNq/7n1qvjQNe9LvNYLeHg+7PNz+8agQYPuTBoBggsiXxJ4HkrGem7+ydm4KOJARABJB4UDDw/Dc2eqx38aeHUvgTyCpwoMsg5V3fzjzySnJv3ugV6/R8dUKxAEpAiMXf6VvHidQCLN7FHGPjtdOa3J+UgySA6XB2oqgOA8JEpt722ddCTxlurlzjDTkfc5TmGVb9KF9IyXPZUP0/Aa+2fikeCH5TofFaV+Rpm7PvfqWuVPUJOc5gQizkPJvrSWA0WSrfquAiF660sCW5tSZZem9LCn27IRaiOuXHLdSvpQ2YhtAFPPNiQiPxoj1VYXCX6m+taNpt44pt8KAhCo+3McZ9juSkO9TnZY/yXr9NYiBg68DfjsJj6T97ebRVzlx2spqJmo1wc20ctN+9Im6UdwYNCdQjfbblc83C40AgQXRL2Zm00pOWNzBtK5QOUiBwTOEHC2rrW2ehWX0pHoxJG3FA13J8dn9Li0nE4865oi56IE1tMsmAcglJbPMD+vL8ubAp+Sp9Kozq1dX+ac2rEC63T4lRcBmy/DrWbKp4IjlW75rCRlnZ53hzMFQap6us7M6ReuE0lP/F6iOY5ZtWxZvCRQk3jpBRRSOtbTQapmFl3nmYagwNtxavlvFZRwPjzg40GsOYDP65hmo6eAKMGL6xN54itfW1t/NafLaLm8vmLE66drnl5EvfJAg6efA7JTECgFLdguaSl8Cu7QPiaA2eMp1b33nLcz+XD9YTA71aEXBKj40j0PuMzV0bTiy1cCJBlU+SsAoFU0lXyUHwMqChBV41Nr628xct1lXlyJIr0nLxc5ocK6V0v9t/F5qqBEkuMUpX4yl7c5+Z/nmTn6OmjQoDuPRoBgQ5pjTJNzz3tzjXflEMxxAOcAjFRWchanBjJuOdCMmTvkdPIJFglcWU714RJzfacgAYnOSwIKcpT8lU++R5JbGfT81atXV2Den2VbuNNVbVtYLq+/O57yYR1ba2cOo2JeJObhgMeDIMvlcm0JtOtcWjKfiDNErk/8z6W7eo5ApNoqkJaXu34kPtkGBC8JXDiQ8LMzUn90py+l4RJcleEz9wnc6Fnvx7yWwAyvKS0PxdR9vlddsndbJ560fDvpnbd56m/knXJne6t/Uyf29vZW244oU8qMdUwrIrzPJ7mlQIDan++q39/fb4vF9T3uqe8rX/Zp2UfVTzaTcufWi3QWgdLxUEmvl7dNBf6VpwdpSLI/3rYeTOWecwfivQCqtwtlSHCZ+lXSA1/27tvdnO8e6KNMfdsC7ztfvVnvJB/xn/jwA2YJvjl2tHbvIZks3/mn3Pi6Tr7GkEv0aQu8r0gn2MZuVzXj7oEz58mJ40KSTe8Zyi89V+XFvt/Lv8e35z/X5/M09BsqnpOPNlVWSuPleL8aNOj+QkOv59MIEFwgpcHIB7nKOfLnU7rqHvf1c6DwMpyXqg7pt/NAOjk5WZtdpIMn51f33HHiTDYHJQd9BH8EC/v7+2dWDiRwm+rpAM33Rjt48QCBr55QkCABueTUynlSndhGdIrluB0cHJzZx0xZiU/x5jPuCZyJdwIxP8fB66oyk76rjPR2Bc+PslL7EoSoPpIP30RQBQZYjwoAqXzyQhJYS6te6Iwnp8wDIvwtEKn2JUjh6huX1RTgdpCTgABB59HR0Wofsq9e8L5CcCDdUn9Obe+2hTJ0MO5gi+14+fLltaBMOksi2ToPuKQZ0R5gSm0gfWJwSuCIKwgkV9d98sOAAoMhXg+lE7hival/Al5+eCDbNS0DZ/9NAQHyo7Q894O2g4EZz188JgBNObM9XI/1SauQXMd0n7rqdsvPhamAKvWEZ4SkdGns6hHzoWy8LZWv+w8ewGObpCCVyFe7pD4oWavcVB+3OQzA8Owcjfse4FD53BYxh1KQq3L4KUM+W9noKf+rans+X4H8TcjtFXn2evSA/qbl9fIeAYNBg+48GgGCLagHjCqig1PlOVVma9cNeBpQ0+Ck60xf8TLFY4/cISUA9lkE8p9Agw+G6b8Ao5zW1taX7U5RAlfukPoAnWawyTedreQsu7wSINE9OrECCAT/zgPz8f+VrjIgIvmxrg5SxYeXlYAwHU6WSVlQJ905FT8Ejj0wwzyYtufYUO9Snum5TZ2vqlyfkUyvBnW+vK+k4EDi3QMECg4cHx/HMwdYNsGCeBN/DCyxb/d4aO1s33egulgszhw4qcP4xKM7/6QENp2vKYeXus0PZcFZdcmJZ3l44EL1VJoE6FP/UBDV7VqyDW7DRFxF5XVkfj0Z6DdtOflWOSzPx4EeVfrNMuaAb/JJkFut/umB/h5/btt64Iy2W+Ttw2/mq7S9tiN/Wq1S2Uy3P2pLrmhJ+bMN2d4qy4M4PgZIjynHSl4uy7ntTprjz6Q2q+Ts7bENaJ4C8JV+9cY85y3xW5GP17y2ST6DBg26/9EIEGxB24CEqYFqm0izO13b5HHRROeDjlcCbAlIV3LibCIdPg8OJNCq+2kWw3nmM+TbHS0PCBD0bEKVE0MHm/VRGXScfQmoy8af1/80C8Uy0jNT15PjnMr3a0nGKX0F3DYBD3OoAudTDl7Ft+u933PnOzmmHhSo+PayPHCV0swFXeSvml0kJbBBMEF99ZVAXq/0m3VO96pnetTTM13rPZdkwmvsv5IBr3m6FKzx9Dfb7s/pdw44Ktvsv1MgoQcke0T7mewhxw+34anfJUryd37nBOjJcxUQ8rxpd1O/r8qpAjZTdU52ivbAV0P4/WQz+Cyv3Qzq9eVtAgCtzQP02+S5zb1BgwZdp2379EXzcLvQCBBcMLkjlGZcL0JBfMbBHZ7KKZ+T55wId5WOsxj678sj5ez6LGrlWPPdzvo+ODhYzeApXXJW3cl2cM2l3j7rprz0ykHuOdbsu5532SSZVOQzSZKP9Mf3vzPQcXp6fYuAp3O5+DW1DQMuXEKt17TpmQq8sY4MoLAc7xdqV/Ll2xu0UsLBmYPJtO2AdSWP7INJVwhmqK8JvPE5lufP8VrSBcrD24e6lVbdpNee8SwNtWNrbbUFRt+bDJbJ2dfSePHkeun9mvX0mVJe50cynwKNHgghiKkCJt5vk55xa8HOzs7K3jCoQ/0W37u7u+3y5ctn2kvlqm9JbpSrtiloebwHFyRf5l3VwcnBS7K5qa+2llf0UN6UqXiUnKjTtP+sg6+qSvyxvgkU+38n9jO+XYJL3b0+CSy7nFm3SvYk12cGf/Sb2444Nrs9Efm2Gp/V9xVirV0PvEsftWVEzyfbxrb37W6+aoSy8D6i8ng+RxXE79Fc0J0CLJ6H64zblNSXt11NwLJ7vFX1SNenfDeW5Tww76l+OGjQoPs/jQDBBVFleDnIJkfMn03XKqfDr1cDBwd2UTW7UDmMc0nOLw/soxMhx0fOiwOJNPOtgMD+/n47ODhoOzs7K7Du71lPDiWXxnNJ9+np6drhbGlQvHTp0uod5gcHByuHRvuNq4MNK0Dn+dMpltPEtpETRkDN4AS3WvB91r5nOy1dVVm+PJygRXwlQM/0CWzRIUkzS36mAB1HT+tgjc9WgYIUEHD585v8e1DDgWAPVHkZKQ/noQokUpfceeZ93+MuHWUgQAeSUU/nkAcG2B7iQ/y5/Kij3k56T7u3tduB6pViDKYROHO/OGVP8JKCeq6HHhjgf+XJukpvvS8ykMhDBb2tGVTTuOFbiaqxgPJS3+IbE1weXmcn2mMPPtCeENSqrVgX2X/VReOQgGgvQKsyPRBDebkup4AB82ntOigWb+JZYwB12W2693/J2u2F2oO66O3tv2X3U8BccnGwT3mJf453DLg6fyKOieJTW2cYpHIdcP3R4YgKcFE/2I/Y9oeHh6u6+zkPcyYsnHpAm+NR0vtekCAF5NL4Ptem9nw75pF8kl5+c8tNY5AHECqfdtCgQXcGjQDBTaA0EFWAMRnuKr9qgJviZVOj7wNnL+ChwZ7/6ejKUejN4pHkqO/t7bWDg4PV4WWcWe4NtpyJJ5++giCBED2nAxE14yRHX3u4q9PLWZ6Ty8CBUXI2CZjEL99mcHp6ugqgeB1IupcOjfRZZzmKBE3Kw51mDzT0fhNsJWDWA9vpWT6/iUNZOWaSJ0Eon2FgatMykq6nYJ0DWjnW1HkCcZH0Q68uVF4Cp3zO61wFOsQvdTSBHf33GVjVke3Ew8wSUOc1gR4Hq6xDBfxdTuQrlcuVLAyOcdXEYrFYW4mhawzw8YA8f40kA3x+Sr/sZXW4oH8TXFaAX/Kpgny9dN53qQNqE312dnbWgB7ve35JH/03y/X71YfkoF5tJPBL4M128b7ntq6SS/pPG0++mIcHCZKes9yk5+rrPARTxPbyIIEHCBTAkf6moEhaHcD0DFJQNzQ5oPbnW0FYn03tuAdWKqruu48jmacxndeSLUll9NqeaZJepDqkND1gv0kAYRO5Dxp0O1EaI+4LHm4X2u5EukFdmqMAmxrhW8Voz6kbwTcdYt1TPtXyzUR08PjRvZSO/ys+WaeKF3eseg7pHOo5KBX/vTr0nOuKRwfXlTyn+K9Abk/+qW6Jj6myeW3b/rFp+6V27+Vx0f22KjfpAPveJn2tIpfznBm+VFYCma6PidwxV15z5N9L40EC8ph4qvj0Zx2wJ5DAuiWbWPXvG+3obDKGzenHvTRTdXG7O8XfnDQp/1uFPNjcC4zwepUmgVzK34OTc+XXa38PUvN66us9QH1fUxX434Q26aub2tNBgwYNuhE0VhDcR5QG4SpaPOUE3wzq8dYjzSpzPyUdIC5VVhq9yk+zUSka7lH0HsCkE+TLh9PyetaNwQ6ewpycIfLCGSkHVZzdoQzFF2dc/NnkrCyXy9XsslY1cEbRD3hMs9Vcknp6ero2U+rLURPoYh08nXgQ+faHqu28/twO4TP6up94cVkxP8pU93wvvRPbV8+xHefMAqU+XemhbwdIAID9hOcMMEg3Z1bJ+041K+28en9S3gkopLZPdnDK5iWZVM68ymBZ5CvpMtOlfk4Z0SYkvfN73KqQ9K61tlqqfXR0dKZsrrxgvefY5N6Y4nbPy/S0/GZdPVjodtWDB7I7rV23HekZ6vFc4NYDss6z2wfW3fv5tpTySflyjKStclm4DdBzWrGiZf1p9YhvWUj2Vve4dYA8q+9726TtJqqD0ussIa14Urpqa0ZFrgvJHl9E27V2/cDjqRU7LNt/94h8Jrtb5TPFy1Tdq/u3UrBm0KBBN49GgGALmuNYTz2vgZNOIv+znMqZ2HTWheWQeuWmpfkprfPGvOWo0EnRcn2BWR0EqP27WnqoZaDV7InqSgfeic6nHBw5IBxUVT8CTYJSgm8CHQcH1bYGf1c5ZaQ0WqbZWgbI/o518n10dLR6Ts4WnRjJ+ODg4Izzy3SJR4IGBgF820FybJJT6lsE2DapHbnHnu3KYIGWr7J/sB1cZzzQNAfI+1Ju71vUJQaJUtnkPYHlBOp5fbm8fpaG9v9KX+Vwc7l0Bc68vj0gz+ept1pST6BAPWY+vtyZ/cbBsgME1z9+V+3mOsDyWGeW4/KizrreVKBL+bAcBd4I1nyVAPVC5Xp/4dYipdfzzJuBBMqTz3mwQfXm6++8jmlcUZ7cRkZ58SBADyipjjwkj3LzPpiCEuLZ6yk5eLDW7zMoynotFtcD3Kx3D7ymMap6vrK3IsqN5CuDKBfd04d1Y5tyq56fB+Gv4nT77OOf2lTbabztZSfEC/uxnrly5cratqhNqAqypPasnnfyIANl6ONntcVhjr/YA/1zKfE6lU8aE+YGMgYNut2o8qluNg+3C40AwYbk4LwyylPOA51bOqt0qvjfy5gbDfeDqiqiA5CeS4GF5ADxOh0Xd8Z5QJ7K39vba9euXVu981yglo6Pgw8Bbx+wlac7/go8cP8925S8apbA93c7gKejJPKVAmzHnZ3rh3Q5iPQ80gy3t8FyeX0FgQcv6AyqnIODg7U8mJ5807FTHVx36WBQ1q7/DGyk4ADlmYIMHiBgW7O92DbSDc66JYcx9eUEiFk3B5wJAFRluA1J9UrPO4hT/zk5OVkdtslDM/18Deq6yvKgBCkFBpIzqTx5KJ+n90ADzx/wdvH+TpkluVSA3fUw1Te1L/OX3LjqhTaitevndIhvDwSq/kqrPFlXBnIkFwbguKqKdVA6B5cM3CV9oi657HUvnXPieu5t4vL3fpJmwikXzjYLtHr+UyA9jdG0F6mvcRacB9aqLN9f7zy4Hnl7eH5Vu3h+PWdSfT/1ARGD7aonxyHpFYE9Dxvk+OQH17qdlJzU7joUVW3I56XnshnHx8ft6Ohorf2rgAnlRb1lOre3qY0qmpI79Yd9Mj07BQZcN6qytgEVqR5zdcupp7eDBg26f9IIEGxB5zGUCWift8y5wYLzliNKs8jkwQfI5EzKkdZKAi2JFqBLgDnx6vWuVhFUYCXl6c4cHWl3NhxcKH862rxPPtMMGZ16OnPML8nZgxoOjBXokBPMvBLfdAxZ1pTzk5xvl5WvOqgAuTsy3h5V2+i/6sPT9hOl63Jgq+s9gOKymEupvpWt8PI56+ezh+4863cljx7om+JdVK2k0b05ec61sw6sNqU5znKP36S3U/nwLQOuw8xD//2Vd56e+aQyRcleO7k8U7494EFZuN2a8xHP3tdY1tQY6s/QvrlMeN/tYGXPNvUBUmCjGn/SN/XB+zz7uK9eWSzuDbJoJR7HbtZb+uiTEZRXagve03OUI9P7ipfWrgeOFUhwwE1i+21CXueLoJRfNT57H70oX60qP5Ux18ZVzw8adH+gWyHQdV+XvwmNAMFNJILANKDf1zRXcTfluXKuE5Dh4OR71cVjAt3JgUuz7w4se7yyTDq6VfCil19amsxv3vfVFu7csizW1WXi5Sjv9Bq4KcCW0qUASSrfQaI7gJ5fKqMqiw5NLxjlfPm9iqoAj8qoAhApgME0vXzn5MWZ5yposiklGc91FD044K9W83y83bz+ntZBrt+v0npd5oD3avWNtwFXP3ka5skVCAlwVQGGBDRof9infdVFWnnmNiK1SXVvjnwrmU61bwoMuBz0UfmVPUzfqd9QJv4GG7dZ5K/if4qqcau6n+rlgREPDuhaWrXmwQkfxyhXnxF3ez1lY/yZNF64D+H9hEEL1q1HlW766pcpYnDEdZer6Fx+Lg/qazUGnQcsTAH5TfPujZODBg2682gECLagZOSnjKobax905fD4YJYGtzQQVffmUAL84of5pQh+b/CdIxMtj27t+oC8s3PvPsX9/f3VJ82k+0ykL2MWeKMjf3p6ulqtkAIT3GahfLl8n68BdPmoTny+chC8LLY/AxIOrt0pSWVSFq21NbB27dq1dvXq1TMAiHyorsxvuVxfOu3p3RnkMlYuJXV+yDcPU+wFCgjaWmurtmjt+nJv5ku58lv1mgJD6dvBCdvMHcw0U+xymgL51DmuFKAeVocSVoEV1tHBUK8tkv1xgKetQVpWzDQOqFn/ilwWbAuvZwXEElDhPeqqPnt7e6u+6cvvaT/cBns/1BJ1rgRw3tjveM31bWdn/XVxHmhI44i3n8vA61DpTALyTul6WjKe+rP+syzX5xQcqECv7vvqGtcR54eHtaaAcCUrt8mpDr30fo1jF/XA61rJP9Wbz7CPcmVXa+tbtqiHbPtkP2lDlM7HDv+t/uHb38SHk9uNnk3Sf35XRD2iDFgGba+/6tQp+QAqZw64nwooVDJl+el3z2b2yhs0aNCdQyNAsCUlR5vX/XdK445XtWxtLnHQT+/Q7tUlDQQ+40Rg1eMxOaiJVx9YT05OVs/u7e21u+66q911113t4ODgzLJuyjI5eLqn/Pz95+44MS9fpqkAgb+2sXJOkmwTiOb15MzSIWZ9KmDi8ia4o1N95cqVNcech5rt7+/HOpAPOn3872UzMLC3txeBJp/l/tW0LF3pKDPpEfNNqxUcnLDNe85aBQp6QEC/k3Op9iW4a+3sgWNJx6rzBRT0ot5UgMTrpk8K9HA2sRccoLx5xsfp6Wn3Xfe9GUEGE/Rfv1NgzvuRiO2fAgMsS/XVYakKDrTWVvupWQ+CKz3v39J/yUX7rNl3ZVv0DA9Qpax8FQrLkc3n8x7s5Col71/iJ838iliu27QKMEr2lBn7cOLRg6N8jraBgTfXewZi9LzAnJPz62On2qca2xlM9/7ueuzPe1rvH8pXZ4zMHXOcRz9PQDxTHnqjgM4AOjo6WjuUl/XgWzicd9oE2iDXlTQJQb7Ta5L5fLqXJlgoj8oGONB2e8z/0iWd2cAAddUWVTkpjdfRn/P/1fOVrdsU9E8FMwYNul1oynbeLB5uFxoBgi1oU2M5J7IrI5wcrE0Uao7T7UtdUzkXNbj0SI4dAY4cXTkqu7u7a7PC7hD4gJ/+p/IchLsTo2utnZ1d07U02JMqR5t8pjSSs+pZBWqqgbuaPVT9FfCQM6yZMh4OmZxWOvBMV4E1OvSckZa8HCQRkKYl2Z6/O8uciaxAspzjBOidem2aHLfkxCU9SU6zP+N59oIECXRPDYRVm7V2diVO1S8cJLF9OevOfuRAUflVAYgkhxTUYz6pTau6+H3poAIFSitgTz4cGLBNU9BBYFmBEwY99TzbkH2PwRHK3g/MYz5ODsgckCb5e7C0Z9MqSkBOedCm8Jrbg7Syinl7X/M6MpjW493tE4MFlVy9b3g6123aL5eTyFcKcHzU9RSkYB1UTgqsUWYcS/imDsmKQb60ciMR24wBLD3jq8gYbFY9r169Gu0Ofyd/p+rfU2lSGUmv6D+4jatkUfW5bYB30vEqnffX5O94O7pd4nODBg26c2gECG4DSuB9U4N9K0aAfYC8KB63GXh76TcBWpuUR2DbWjvjJFf89Zz03tJi5zuBaXe4eg4g808Bjx7IpHPi93zbA8ubI286PHOc9fNS5bD5jK/zMJWX/+7dS+Rg2eXfe+48ckm6eqMczItsx14ZCfhVlPQ89Q/X/Sq40ePJf/M/V6pcNM0BJ/yuKAUJqnRTv6uyp9ottUG6ru+0xYHfvJ4AmPPksqz6fY/ID9s95ZXk4/Jg/StbXLV9CoDMyUOyZXCIq9u28Xs2oRSA2OSZ+zPdaNkPGjTo1qMRILgA2tR49hzAuY5uFSWvlu0xzSa83qhBITmv4t9n+bmEvOd0Oc90lH32JTlFlQOl+15GcuCSY6SIvJYZM3/OenuggMttW7u+j9PTT1E1Y6WyFot73/N99erVM8v16SRq+4HucbZ4sVh/p7bvYWe9/Xk+w/ySg87fCXx6kENyouN5HuCk9iY/y+Vybamuz9glXWPdXI+or+wHnEV0/XPZJrCZZOmy4W+vYwV8+Z+kmXO1yWKxWLNN1StYp5ZjJ2A1Zad6ID/p+nJ5fWsRbUgFIgh09e2vctT1JE/l4TPcDvR9+w1l4a+zpL1w2U/ppCgtL0/pXNaUeWV7KQ/OZLMsD3DRTvA76QbL77WbZOb75MWD3gCg9LKRPB8g1d/578mHxP6trRIpwED+/b6vshPPyo9jrerv54VQf93uuQ6m/lfZHqVlHtQz2Yz9/f0V75cuXVrZP46BIt8Kla7N8a1cb/w6bbLXO8mgF4yp+JmyZXN9xB4fbmOYd2UfBw263amHG24mD7cLjQDBhuSOtxva5BBU1FOUTfJJRJA55dCdt/xNHPUpUh48AEj7J+XkssyKlzSgp4HdQUFyotOg6mXQ6amW0iZd4R5ckZzlBAad11TvaibOAyvK79q1a+3w8HAVJKDOCJAcHByceQ0VAb4cbILMpA+sg5fD8siz5OrPO6luCjAxf/Hme2dbW1/emvJ1ufk9fdN5bS0frpWCA66b+s1zBaplrb7EPIFH51XpHLj6VpAk5xQQSGkpd/F6dHS0kpMAge8R9v5LHn1LEPWc4DIFfzxA4H3A9fb09HTFb2tt7X3zqT1VLuXoAYLW1g/oZFns56onAxQehKOuUD8pA9bJ299l659Kfgks6j7b0PU6Herqeqa0KagoAMs6qU2oYx6IcPvpJJnyFbCsB/lWu0ovevrochMxEOK86sOgAPnnuODPeRtQZuK9tXWbRPt97dq11Tkb2uK3v7/flsvl2isSXb+8nZQfdUNyZZCFAS/JmbzpGZ2DoHqo3b0OVcA36T7lUwUBVB/qFc8xSmNzIm8b56FKn2xiVbceTflxPX+NbbuNDzlo0KDbm0aA4AKJztGcGcoKeE49M5W+t1wz7S+b4q+19RmJ88y+kvfT0+t7POkscqDmXusEcJ0nXusN5pVDw7KdUr2T0+uUXoOn/NOJ/mo/zlQxX82wOAClE6n8Ekj1Z1q7FwDR8eJqgP39/bXDqxx8EHwzgECw4+V5UIEOUZpl5UyjO30OLKkrXtcEYh0U8D55ZvnJkSPwpezdWfaZswReqbcCQtVp5NTn5AiTHMy6LNjuldxIvgrE8xO40LvYVZdqlcCcAKD3f8qgqv+UI+8A2ferJz128M8glwIErmOSly+dpq5xFZhAMYNvkpPLgnLVjKueVT7kR2DQ6886ep+QTLwPMq3rb3VYZ6q3eE19UXLxcwGcJwfVyQ6Qd9obglg+xzNRlsvlmX35FRAkKW/XcQ8OJXmRL6/HHBsgW8TDNtnXpfMqi/ZeARgPllQBIpcfxyPXG8mUdl92SGUfHh624+PjlcyTbrh9qgJjU8BclPRGcpwTGOjlPeW/ed+Y4nmuH0kb2Qs8eF4jMDBo0J1JI0CwJTl4qQaU3vO3Em3Lz9RAs2ledDIrMDDFb+UQVv9Vdi8/AUBRL0hS5cXrdIySo6X0dIw9H854VXkRUPTqV8lTDrs7z/7NT1oBMOWMzHXmEhBN9enVsQc+e06vg6AEQNP/OQ5WejYBwF7f8LKq6/7fnenkQLK+c9rA86JuzOnDnkdF29qeyl5X8psCA1OykTyTrleAu7X8VgMnb2cCY34UPNyWpp6f0ycSv+R7qm5JVx2spmen9MTHcr9XtW/VDx3YV3Krxji2WfWc5+GrBqsAwhyb4nV13XVeejYgBQd6cuSqgJTW859Dc9NVq0DStU2CAz1bvC3N9b1uNV9z0KD7iub22xvNw+1CI0BwDkrAsbXayUzUi+YSkFR5JRBSDXLO6xzwlmjK6UmUyvBl5RUg8plTX4rNelWzsz6TlfhzR6snF5exp6XT6iCd1xOgSGBM8uFvn03v1a1aVdJzolkHzgayPAY62HYODJl/Wv5cOZkpcFCl4f/qOTruXjZlXJVZAR7qpdfXy2I7pddv9la89ECt3+sFBQis2AcrcNva2f7OmVevt8vEn0sySf1A9ysbyTyoh+wPbkO8f/sJ6tVy+FS227AEaDw4wPucMSdP3s97qxVcRgkwToFIUQ/kVm3lz1POvtKhKsvlnOTntpl9RunYFny2t4LMeU/kstJqB6+L8ylynfN24uqCKo8pmfVsfFWut5fy4NhKPVMeVdDEdTTZ05ReZXC1i/5zJQP7x1zfqrLnSa8pY+p/kpc/l+Tu/GxKbgNT3ucNOKTxo9fHBw0adGfQCBBcIFVgpOeEVcSl4tVgkAz6lFNROftTs0O9bQteTm+2xHnQUty9vb3WWls7iEiOvc4hYN4Cqtxj6dsn3OHnb91PDi3vM4CTwGxyECrAxfsuKzozBAXuBDOPSheSk0nZz9VTttXp6emZNuB74nWdS5wXi8XqYEYnysf1gnJ3+aRVDAQtPaewAgi+3J7XPY/0u3rdlYOxxWJxZomqnuPS+7SMNQGi5MT1HGdvewZqfLlx0vWew0iAzv+8r3y5XFsySfVg2/aW9tKRd/um5/iaQn5cj3wvdFoNo99c9r+zs9P29vbKAAHzYx93+Sn9zs7OantGAmnqV7R5rh88i8PlqmeVP4OYvp3HbZM+DhqppzyzIdmXqg0lV/YNlyffPa9yKDfVzbdjpGBcxUvSM8qQfYZbgJh/AndePtORT5eXqLqntvGgq9eJAXWuTpHM2B9PTk7WztJQ/q67lc2da4vctitIIHnqcFz5CCmAxzqwLmm8I1H2yjfZc75a1g+LrfL0+vr91E49W1v5kZWP0Xu+apeerzrHbx006FamyqbfbB5uFxoBgg0pOeWkCnzR8XIwU+XNQXjObL0bc8+L5ZM4e+HluHObnPlEPvh5mQQmChDQQaITJUdFzktr1x0ld/rdkdWA7zOIKUjgTm5yupTO5eQAXI5uCiS4s8/n5LQzOOTOZuW8np6enpFTCkZUznlyOAiCj4+P1xx2HeylMllfnjDeA0ziuwKkDvhYB15L8hf5qhLWe7m8fiiXy8v7kPSfIM/bN4FitovrEQ+k8xlX8pH00+W5SXCAbcY2dB3wZ8QPKYFQpeMBo7rH0/XVP6n/vuKGcnJnOvV91uP4+Lhdu3atHR0dlXqe2oR9NOmvB1c00+l6UYGmZD98Jry1esm7z5BTL2ijpLOUEWe/3S7N6XvJfrGdBKKmHKHK3nB1RAIsPLzW5ZZWwVDHaNclJ/+fPt6GDOAQ1LMtk43mmOT5O/hPvkYPfCYQ6vwwKEffRHZwZ2dntddfh2R6mzAww/s9fvy/2023jTs7O6sy1K+uXLmykrXsZSLnuaI0rqYgDycXeHBs1b7pd1W+vqvxscpjKu8qfS+YUNUl6eGgQYPu/zQCBDeBqln9uZHfRDTm1ex/BSDPS1MDRnVPfLoT6kCa6TlA+6BNMM3ZWjo+/kwaWP1+GvidNzqWSTYO+Cvn22UmefirHVm+HzxI0MEZQZ9td3CVZOAgkc9WoJRypew4i5Nm43vOVAWwUj16jmia5eR/1yPm706VB9JScIAy5PMuWwa4/MNnk2wrx5j17/VRbxc6/ykA6G2X+obbIOe5Ag3pWaVzcFuBIy+LZdK5J6m/JF4U+PJ29nITeFKZFbk9SMEHpnVdpGxcBg5S+alsgV/3spRmCrQQYHkA1u2Y949EbgO9rDT7n2xsarseqJtKK/KyKnvg5P2caXp+gutBApW98cifZaCEQRRfvaF+klZ7VeNJZbtdZqpz4pvpdSiv+w6Jeu3ulHyNdL3yI9KYlfKo0jgvm/p+1TjNsipeeuVN+T6DBg26M2gECG4CpVmg8xIHmuTobgPgNym74qVHHOB9CWACkJVzngCT8vHZaDmtCcD6714d3dHqgdIp2ScHxmfD/QDCxEcvbzpSPaDK55guzcSl32yDytmtVr/MceYr2kQHN+0LFSgjeUDBnUZ3ICvnvwd+K+rZEw8OpGCJA9uq/3m+VVnKey4om6tX+k5ydZlV4KeiqqxeugrwpDpX/dvlzr7H4MGUPUo0tZKGfd/BaZKll+3tkGyt07agJ/UjBgWmaKptGLhgnh5Enju2MXjo+aW69uSf0m9Kbgd6eaegAm26+PQ3b1QBrIqHyk+hzvKbq3RUnlbr0P5u41tNAfmeXKrnttEbpr+ZNDUm9oIfgwbdrrSpr3WjeLhdaAQINqRtQIxHv7fJK6V352Yqv2pZ/LY80Lmd65AvFvfOCOijV+hpyaa2HHB/r/ZAkn++tintmdX/tK+Q+xurZd0kzrK5I52czfSsnufeVZdLa3kbAHmtnHWWwfzJawJpFZDh6wf9VYTOp7+XmjPye3t7K37SUuWq7pU8k/4pmDJXnysA6859LwixWCzWQEGlP3SkCT74bDUj5fk6sCevaXUH5e2Aqde3kry8r/Oen19AHip7Ib789Xte/zSD5+DKn0lA238nW0J5OnlwhVsz/BWELnfeEx9VHyWf1YqUOfz19GSxuL7EPPUFgjIPhlBv+cpOX3bd67tVECAFffy6t3sC+ZR9speuh5Svlten1WaJt1Qf/faVFLyeZDU1fiZ+es9SB2jDXSbsTxwj9X18fLz2yk6dBeDPJVlT97l6kdspmA/HAKXf399vi8WiXb58eW1VkdKlwFiiSt+8Tfhb2wr02eQ1h95mbhPn+G2pfd0O9/Kb6xvO4eNmBzEGDRp039IIEGxBvUE5GeTKkPee6TnsFT90fKuyfPBIkfjKGSFfvuw05e9OWGttBf739/fb3t7eKlCgwIB+pw/zTvtqnScN5BzUPWDgew6d3LHk9ST3HhGUJUCVBnbdUztVDrTaToeXCbS7Y0q9kJOfzglIKzx037eEaJ83T5/W3vPT09NVuzIf5p8c9SQHyoPf284kubx9n7LynrNNoTej7+n4fG8W0Z1QBhuo+3KSWSZlRCDHAJUHq3pyolOanFMPICWQyGcob9cvgqq0JNtl6EG1k5OTtcMxHUip3sqDAS7yyf+pP9Be0Qa4vfDndc23PbAODugrgKz6MGiR2sIBmPqnLx1Xfn6PfDPI4NsqKntJufC3nuPhsUkWFSij7WeZSQa6zzGjKk9pfCx0e+pgX+T3kk6zDnqmNw4k8n7mvz1IlfL3Oqk/+KG0i8ViFdBXm+tcmrQdhP2Etkv30qor8qXnxIMCBOyvveX+lbzSdgE//4EHTzJAoCBBKjMFA3rjF/Wsop5PMBWcqMqs0nu/TXZ+0KBBdw6NAME56LxR2damHQAfCKqBwZ3vNCA4L72AQMVLAiRVWs9bTgqDAe5gu0NDEMPy3REVgPY0cl5ECXT4rICTO9dVXZWmNxPt9fGADvn08t1hTo4hQTx5JtBw8Os8Obmz7TKm/FQnBgvIO5/3ukt27jT2dNgB/HmDBAl8u+OaQEJVLgEUAYPKlW6m2V53ZlP9yZfuO/jx2UMGqOjsiw/nwYESdS0B/MpRpn5Rfyu9Uzr2YV9N0OvvPnPvfOg5BhxYjxR0oRzVb3oHcaaAmNcv6Zc+KXjradXGrBdlollx5sNZ2GR73A4yMOX2rDd+uNy9fmw38kcw6WAugUHnwfWRfYK8eN0FAAl43Q4477pG+enbD9WlzSSvqnsaD+aMzU7k3VessQ968JOBOB1SeHx8vBqzlZ/yUpoKoKcAAcvxtlMaL2exWLSDg4O2XN4bONB5CakPV5R0znWPOsbgACcVfIxIsufviq8ev1XeVTlT170vsPw0tm9S3qBBtwtVPv7N5uF2ofnT1INuKt0uxniTlQ4kB7QOQudS5Wy6Qznl4FV59/47+RLjRO7E6xrvVemYx1SwonISeuBuTtmJKic5tUkld69PAlvb9omeLHp5Vnrjvz1tBRamgA7/9wIdSW+quiVdS3W/UfZmjrNZpZkj4zny9nJ74KvXx6t+26vbVF5M32uvlHelv3PbcgrcJtnz9xwb6vlvmi5d45iRrlf9wdMkuXte2/Ds96rvbfPdJm2qTzWGEDRXtm9bnlzHPQjHNCk9n0vjVlXnKZCe+gBpjs2uaO44eivT7c7/oEGDNqexguAcNBXlTRHaXro59y7C2Zpr7NMMg+edloUqap6i5z3w4mUTUFWOACP5vhzXZ7ZbW3+Hts8YVODD5ZAcyall7pyt9+XKTsnR0cFM7qTMASsqk/XiTF1alkz5+nXmk+rAdtBMnLYh6JWVfL82Z42qOqke3hbOI1dwpLwqeVNf/TdnpyrA39tioHR8N7zLMvWj3hLcSkaSE9vFXz/ZCxLMtS+953vglv/VjpxN9f7IfuqBP+eZ930ZcJXeVyMorfLxWUzKdxNi+fosl/fOhmoW1t/Y4K+VpC10XUj1pJyrVVBpfKG9dVvr9U6rNMiXy7S1/GYOfthnmMbbwMcYt0vkqXrG6y67JD41rvi45vaBM8xpG4zrNHmkTUsreZLNc3lv0m9bWz8PoGffVS9uSeGbTvg628o/EP+UHVcuLZfrB3S6TJT//v7+akzRGKJxheONU2WzySPTVj5Bqp+Xod9z7MMmNqRq37llTeUxlbePW4MGDbr/0wgQnJMqh6Ny2LY1tBXYTnxMORw+qFS8J3Jw2aOUD53GBJh9uTj3ubbW1vYlsj6+x1POgjvSXC7I9O7UbbJUfW5wYG9vL26joKzceWntuvNVgSHVjfmoXG9r8qp7vjWD5Pww0CBKYEKyFyh+//vfv3IKFRjQflbJRe+7VjnMj8tUVaYDDeefciav/p1AVQ+w8L4vjWYbsIwK7Lt+Km1vq4WDntauA/9U53RAWQUAyUtq5wp8+TW2k9scXWPggvrCvqnl3uq3Hhxg2b7dg7bD5UIw5/k5sa8KPE4treezLls+L7B0enrvfm7qnfqa7DmBlmTEuovYr1UuAx1MR1Dm7UTg5mWwHtyi5HX3vJP+V7pejR8Eo8zD60IeVZeUP3VUNkj1lt611tZ+Mx+lk66mpehpnOq1X+8/6+WySf9VlnTOt8SkAIHqxDZRvWSzF4vrBxa2th6QZ524rUrlsx9KNjoQ0Xmm3mtb4uHhYTs6OmpXrlxpx8fH7ejo6Exg2tsptYHrYTrMmIcaJ7ud9LSyC8nW+Bg2Jx9/Lj0/xaPz08tzys4NGnQ7UDWu3GwebhcaAYILICqdg0XOQvUGEoLuaqBnuiptj/xZp3TNI/nJEfW0aaBjGXQoK8DiAzoHfA5YPrDTkeHeW8kqvVedDgHr5k5KcrK9DRLYlMMpYOyAzcFumvFLQJHAIYFYOmTuGLrTmUACf6f3yPfApvhLb2Dgq6oEuPjmCgIyPsNyyZ/3PVICs/7NPL2O7lSybvzts1/ix51TEWcpXYbpwDalJfAm8PW29nS85jKkPOZSBTB6AQJ/lvx4gEDp06GiIukEbS0de19xIv1iuuQwVMC0Wv1T2bu0+op56TmCSa0m0PMEM24ndJ31Z59N/ZM6Sr1Mdtf7rfcZydTLUT4eRPGZc287PeP9JdkPyoB9SDLnQXYqk/ykNpc98nZlIMntIO8pwEOQ6flPOaisq7eJtwHHW95zcvlQTi438uAre/TZ2dlpd91119pbiHxMcb2kPFtra+cZeACGfdbbbnd3t+3t7bW9vb129erV1tp1O8s3DyS5uk4lHj1oqDTeXzzvSv7uq/CZKeC9CTh3HfF+vU0ZyS4MGjTozqERILjJtK2R3TSKu8kM+NTzHiQ4LyWHcgqgJZDhg30KFnh9fPBnWX6tx/sUOa+pju60e97uxFXpeuSrM1IeyZFIQQ+RZLnJMtXkRHFpaNLXXp0d7GwSHEj3nT/qmwMvv++6mZzQyqlM+ubpXdeTDhGQc2VKa2dfK1nVfS7N1T8vzx1YtqHAcHLwKccqyJnkyQAadbWyKV6m1yUB7TmUyuDzDPJ5MDbZDH1XTj2d/upZT0s+NwFC4tH7oPeP9O3lVrJySv26J5c57UZ9VDsQgF+6dGnt8EsGsXxMqYIPLoMeoPfgSrIHm+ig05S9TwEjBq882FMFNLzOra2/RpP18WC7tzODUQoUcLLBV0lV5U/1+dQPUrtuAsQrqvR1rj8yN03vufPq0qBBtwvdCoGu+7r8TWgECM5BcwzreYD11EBxI416msWe80zii6DFZ+A4o95bEUHHhI5IbylnclLSLI4D1KmBMzmbi8VizYlM6SvHSWnoOE/J3J1YBxOciauCBOQjyZeOP9OkfdmJv941Aj6+Vovgls6XzyhRBj5b3nMA5/SZBFyYh+sLVxB4n01ASc/wu7X1ZesOorz9EuipZrj57BTQmJJPAmcsowfA2Aera8l2kHfvP5QtZ/oq4MKZUK9TCrL4qwOTXEke1OvJxuWe6un8p+dT/58DMJINS4CoKtd1nUECtqe3MakCXxW//E275PXm+JXqSeoF08UbV5ukgJ/z6ffJD/NO5fnvXlkpOJp0MtkL6o/bkSk74HbQ7QrTTNWB/PgZEK5ftIH0HXSWh9ffy69sD+tTbRWZ4r93f1NQkOowJ/9NfELXg0GDBg0ijQDBFpQG+94g3XNOZNwrcO1OfW+m1MFUa+sOhD+beJ4qay6lemhJoqL/+/v7q+WCfO0hn3eHJjlZXDLMpcPuDPjyQfKYVhbQYaYD7zPnlDnbi84qAW5aVs7PcrlcLaOlbngAITk/3mYO7MkLyyCvlIk72i63HkhKTimJwRQtL6XDlwAveUjL9FnfFBDoBX0oy4p8lpt65fVMgQJvMweDnEn3fptmytI97vHl89KZHiBKWwOSbihNL2Dg9XY9crCucnjmBuVOuTpoc9n6dhXlwWcoQ4ETXVNgYG9vby1IkPp+Alq9wIHLUHXmlgnl4VslUuBIdVFayqkKSnjQz8E+t7lQfg4mpac8uI7t7fk6LxUAc51hEIQydUDN1U0Mtrgs2Nf4PGWkOrPPTwHG1P7JBqXg+yar9pzH1J6SAz/OH/Xat6Kx/7hdU186Pj6OwVtPWwUd3J5Ln3Z3d1eyPz4+XpXH8VH9c7m8vrpBryVk2Wozn0xQcJptq+d1poFveZpqC5U713eqAiuuP+6TTPFQgf+p/+TJ7fsIJAwadGfRLfWaw1e84hXtkz/5k9vdd9/dHvawh7Uv+IIvaL/zO7/TfeaNb3xj+9RP/dT2kIc8pN11113toz/6o9srX/nKM+ne9a53tRe84AXtEY94RLt8+XL7mI/5mPa6173uQviuBr4po+rGtwJeFView08Ca4nHxEu6z5UAc8vXrAD3D/Kzv7+/Chw4uPF668AyDv7VR2mOj49XBxnpt/7LIfBDyyon0Fc8iD+vJ50yOUcMQjCg4QGDtAQzfTx/8pDkLL7SdQ/SEBzJYVPeqW4OkqoVIXSC5GAeHh62q1evrr6vXr3arly50q5cudIODw/b8fHxKoDANmFdyDt5dNCi31Vfc/0liWcenHdycrKmU3Jmk37yWaVNefgWGW9bl787+dRDBVr4HNvGgw2eJu0x9/Z1YOwglXVXfdmeDuKYZ9WmAsQnJyft8PBw9VGfZlCDtkNptF/c+7TLTvaJPLiOU6fUL2knPVCh9NTjXn9OfSm1RToo0ANQfL56o4Xrq+toej+8H9LHZ2hj2f58pgr0sB+4TF3/qYdJ10XeVypbzz48d0Y5jb3sw5Sv2wjPN6122YRUpnTX7ZzbC7cvHhzwYIbrgcrUp5KR2zbq+v7+frt8+fLaRxMJ7H+qF/0HjVci2p7kF+gjPZVdUIBAtqS3YmRbAD0nbRo7e+XMAf8pv/Pw2KP/8l/+S3vWs57VHvnIR7bFYtF++qd/ukz7/Oc/vy0Wi/Y93/M9a9cPDw/bi170ovYhH/Ih7YEPfGD7vM/7vPa///f/Phdfg+5c8nHmvvrcLnRLrSD4lV/5lfaCF7ygffInf3I7OTlpL3/5y9vTn/709pa3vKU98IEPjM888IEPbC984Qvbk570pPbABz6wvfGNb2zPf/7z2wMf+MD2D//hP2yttXZ0dNQ+53M+pz3sYQ9rP/7jP94e9ahHtbe+9a3t7rvvvlD+fUaiok0Mb8pzjlGfinjPUVJPNzdvUXLY3Hl259+BseebltL6rED6ZmCBzrwozeio/kzvZbuDoPZimyV+Wa6DbJd9b+BPAZzWzh7k5YCC8hTRMed3a9dn+8krZe6UAkgVeJEM+NFqAg8o+Mw4D8hy3tPy1zTLlagXJEiOpr9tww8m7QWeKAOSzxgnIO4gMQXw+IzPwlIers/U/UpuSRf9ee+bnibZN6XjzChnken8M2DImWPy5LrKMhLQ5m8FWZIck430QECyN2xj2UfOwvObMphqC83mt9afha5AXGoTtxWsi68yEq+9cZBt47Lze8kGujzTSievH7d/sb2nxkHX3d5sMvWzVzfyzHJ6M+09/iogqd/UsSnboXr09Ey8LhbXD/31cTCNIYnS+LlcXj/zgf1b99Qv1d+Xy+VqxYHqSV717WOCB3/oJ9CmJJ6TXzSVbhPaRAd6z1W89nTzouj9739/+/iP//j23Oc+t33RF31Rme6nf/qn23/7b/+tPfKRjzxz78UvfnH7uZ/7ufba1762PeQhD2kvfelL2+d+7ue2e+65Z62dBw0adPF0SwUIXv/616/9/6Ef+qH2sIc9rN1zzz3tr//1vx6f+cRP/MT2iZ/4iav/j3vc49pP/uRPtje84Q2rAMG//tf/uv2///f/2pve9KbVa3ke+9jH3qBaXCxxQNt20NiWLnLQqIBND/wmYJeAoAOvuXwnByAB+4qnHjlwSmXrns9QuHPcy9959P8OgqZ4JX/eZsw/UQp0pDzT99SHzmACnfdF/0j1E/VO0va0VeCgyrtHPRmkPByUXRTN4bfXZ5Mjy+vb8ON6koIb6ZNoqn9XPPTSJmBbpevJ5TwOf3ou2VoRAzbJFs8t0wGpP++y6wVJ/Ft5ebDd9S/1SdXRae5EQG98Y1nb0Jzn0vjV48kDi+k685oz9s7Ri17AK40/U7KdO1lD8uBPxesm/oXzNyf/G003q9xnPvOZ7ZnPfGY3zZ/+6Z+2F77whe3nf/7n29/8m39z7d673/3u9upXv7r9yI/8SPvsz/7s1lpr//bf/tv26Ec/uv3n//yf2zOe8YwbxvugQYNusQCB07vf/e7WWmsPfvCDZz/zG7/xG+1Nb3pT+/Zv//bVtZ/92Z9tT3nKU9oLXvCC9jM/8zPtoQ99aPs7f+fvtK//+q8vo5Basip6z3ves/rtA48G3bkDUm/gmetAuFNfOTop702j+xUvU8+fnp6uLQvkty8ZdJCr51Pk3+vpS7nJX7Uk1GcSmW+aCU7PJrlsAowIWLSHkjLwpZj65lJVn9GnI6WyktMscucrOXMpCEE5VLOUPXmkmez02jnJgTNKWm0i/VI+XvcpcOd1rNJxVrYKTvi9VH+XL68pLeUi+aqd+QxnBaul/hVxpjPV3dss6RTTVgEtyojP9wBlxUsF7vgcZ0hZfmtttaWAq1VEDIJx5UBasu/PeL2mgmPk3fPwJehpFr+aoWff977V44m8MF/aH320SsZ5b62t+mUPCPp2DLfhDqCmbLevNvP/br989ZnPHqv+XB2UXovr/GiMcDuYVjSIT+23d6pWC+p6WhnmJPn6toJkZ9LzLsfUD9ivfJWPnpPMuOXn9PR0NUnjvkGqw7Vr11ZbBzRO6v7JycnaSgLlvVyuv3XC7XVaLcCtM70tBUnWvbaY81x1n+M6ryd7Wt1LNnlTXphfa629973vXfOHDw4O2sHBwWQeTqenp+05z3lOe9nLXtY+7uM+7sz9e+65px0fH7enP/3pq2uPfOQj2xOe8IT2pje9aQQIBm1M1dh0s3m4XeiWDRAsl8v2kpe8pH3ap31ae8ITnjCZ/lGPelT7sz/7s3ZyctK+5Vu+pf2Df/APVvf+1//6X+0Xf/EX29/9u3+3ve51r2u/93u/117wghe0k5OT9k3f9E0xv1e84hXtW7/1W7v88VvkBp3X/VkHgymPyhn3vPifefkyxqlAhqd33kUELV43j+TLWUn739N+fpbhWwXEE/c9qlzOAPB/GvAd6DEAwX33rV1/Z714cmedsiJVzpvXRW1agTsu/aQzRIebaby8ihcviyBMPBKQuMOSHE+XRZI7HWVe97cYkK+rV6+uBZmqsxIoS192nHhzMOXlJvmxDalbla5KjnSCpZseHKOc2RbiwbdYaPk77ydATyBIIMm8SAmwOTnoVb1UNstNdpJAOPUH8k7QUuWbVrBo/zHPhqgCSR4cYPCJdfRnKPseSHDw64EF6QcPK3SZSSerdhH/1QqWSo+r/8vlchVc0RYI39oj/hUkSGW1dt2OVmOG2/5qLHM7w+0ZbANuixLYp67xzAQfC3jgLdMkeXNZvNdDgN7HDdXRA0Hku7Xreubypgy9b1CfeKaPeKgCutVWA1+y7/ZPbc8zT3RN+iMZCsB7vTjGkh/2Bdk7yZTnWDBAoDGSMuE5BNRn5XF4eNhOT0/j2ShOaXxzXU+2Uemqvuv9gP99PFFelY+ReJpLyT8lfezHfuza/2/+5m9u3/It37JxOd/5nd/Zdnd321d/9VfH++94xzva/v5+++AP/uC16x/6oR/a3vGOd2xc3qBBgzajWzZA8MIXvrD95m/+ZnvjG984K/0b3vCG9r73va/96q/+avuGb/iG9hEf8RHtS77kS1pr9w4uD3vYw9oP/uAPtkuXLrUnP/nJ7W1ve1v77u/+7jJA8I3f+I3tJS95yer/e97znvboRz+6tTYvCtsbFAjuSBrYmMeUE5+uJeesKjPxkPaUVkGC1vIsu0gOhs/O8XRwH4gIluhAka/kALPu7uT6oO8BBJ7ared8n6auU0Y9h7hH3rYEhr2ZYMlQDhjl1dr63vfKKXVd9b2prbW18xoILAXsKjn3nB/KNd3zt094etWZ4JIOMN+AkUBH4olOM9NWwNAdNf/vTmaqg+rKFRA+M+j5e1kEAT6D57rj/HtdPSiTwDyBaXJA3XlN6cl36pNMUznDtA3OSwqMOChQ3kxLuTFAkAC/nvVAjadJskkBDuehtXbmrI1Kdqk89Q1fcZHqQV4YIHVe/TBV2j62i49zHgDxMj09r1X2Xd/ex7kX3W2etwfPaPAAFYFvCipU9eOqnN51/ff28bbh2JqCL1W7kqpgQGWjSWllH5+nrGiXxSP1R6vj2KYe2GSAwOu3v7+/Fuxp7d5zpZJf4eccMT9vU9nqdGCmg/RE1OceUO89O5V31W+rZ+eUyWd7dXC7ot9vectb2od92Iet0m2zeuCee+5p3/u939v++3//7xsHMjb1tQYNGrQd3VJvMRC96EUvaj/7sz/bfumXfqk96lGPmvXM4x//+PbEJz6xfcVXfEX72q/92rWI5iMe8Yj2kR/5kWtA9mM+5mPaO97xjnZ0dBTzOzg4aB/4gR+49ulRmgmYSn8RtGk+c5yDi+ItkTtQ/PbfPb4q8JTq17uWHOQpGfVA8Bz5JsDpQHOqLCcGDhxw9MCMk7dF71OlmUtJXpVsPFhUyW2uvBIv26RPz6VgVKqPX6vK6d3fRPapX/dmE5U/v/238zrnmt9PaRxMz6U5znzv2eQQT4EwT1/RnHpM2cdU1hSfPb5SsMHvV/Yp2d6k+1M67HluSz05+L3EkwdJNtEZ1wNfpl/xk6gXOJhKQ6oCXImmeHWdmxrDeD0FWHp9fo48/f+ccYi8bKKn59HJqo43Ir+bNfbdfffda37xNgGCN7zhDe2d73xne8xjHrNaefLHf/zH7aUvfWl73OMe11pr7eEPf3g7Ojpqf/EXf7H27Dvf+c72oR/6oRuXOWhQr8/fzM829H3f933t8Y9/fLt8+XJ78pOf3N7whjd00//oj/5o+/iP//j2gAc8oD3iEY9oz33uc9uf//mfb1TmLRUgWC6X7YUvfGH7yZ/8yfaLv/iL7fGPf/zW+fD8gE/91E9tv//7v782qP7u7/5ue8QjHtH29/fPzbdozgy90k0tT29t3fhPOfLpubn83EjaxrmnY5FeQejgKs0MsNzKkfBZQ/5nOpXBpZLcx5iWpE4tU+zJi3XyPAmSOWNSfTRTw5kV/52CCy4PvvYqfar8+almtHpycFmkmR+9KtFfX5leb+V60Qt4VPz08kj6Q71We/J34nEKOIuSbKo80sqBlKf/95U0SW9ch6q82J5p4JxqCy8/bVHyJdfMdwpYOK/89jr4NQdHPaCv9H7uhsu5skkVz3zel1n7x4Paqb5JpymD6rWFyQ6n9k9UXac8XI5er55MKx1NY3Il+961ZPe877A+XAXF66wrV2+l8c/7UAoOVJRAputy7xmlkT3zVx/6WUPUfb6pwPuCrwrw1/H6Kw79nu6n8w04dqexwXWnN4ZvA/qrIEai5Muke5uUzWfTGJh42BbYJHrOc57TfvM3f7O9+c1vXn0e+chHtpe97GXt53/+51trrT35yU9ue3t77Rd+4RdWz7397W9vv/3bv92e+tSnXhgvgwbd6vTv//2/by9+8Yvby1/+8vYbv/Eb7dM//dPbM5/5zPYnf/InMf0b3/jG9vf//t9vz3ve89r/+B//o/2H//Af2q/92q+tbb2fQ7fUFoMXvOAF7cd+7Mfaz/zMz7S77757tc/oQQ96ULvrrrtaa/cu/f/TP/3T9sM//MOttdb+xb/4F+0xj3lM++iP/ujW2r2C+af/9J+2F73oRat8/9E/+kftVa96Vfuar/ma9qIXvaj93u/9Xvv//r//r9z7NJdoaB34aBmhG93kMDmg1zUOlEzP/J24hFHlJv6YXvl5Hj1iGtahqiOfS7JIy3TlcBweHq4BVN1PTraXTecsLbl1pzc5baynlv9KxjwPgK+6o5PGgZj19v8JJKl8/qfT5M5qkk9qi+RAp/ZKSz9Vhg6MSu2Wflf8pD7iIEwy0OFeXLqr5c6Uk+QjSmCtah8CBQ/+0EF3eXPFxmJxdgsI9ZQHaHHpNvNNYMfbSzwlIO2UnMBKJxeL9W0PknHlrFZBiQqgMlBSARC3K75Hf29vb+3gPIIjkeRX6UIC4syP9Zvj0Ou5KvjCfAiWGeTgfnPJyckPBGQ/c/5Zj+qMCOef8tEr5JiX8+ZAmZ/W8njhej8FQFxnfYzyeru994PuHOBTlq43yptyT6A+2RPyy3rrHl9v6eN6T48oP/724AL5oY3s6bP7EOSXdeS3dMFf16lDCZm32kBb2Tzg19r1fuBjLGW4WCza8fFxa62tzhlx2ys7c/Xq1bWAOwP+yc5OUeXTpWsuw8rmTfmLqc08Pz47VW6VZiooMofe9773td///d9f/f/DP/zD9uY3v7k9+MEPbo95zGPaQx7ykLX0e3t77eEPf3j7qI/6qNbavX7/8573vPbSl760PeQhD2kPfvCD29d93de1Jz7xiau3GgwatAlddKBrWx42pX/2z/5Ze97znrcC+N/zPd/Tfv7nf759//d/f3vFK15xJv2v/uqvtsc97nErjPv4xz++Pf/5z2/f9V3ftVG5t1SA4Pu///tba6097WlPW7v+Qz/0Q+3LvuzLWmv3RhAZNTk9PW3f+I3f2P7wD/+w7e7utg//8A9v3/Ed39Ge//znr9I8+tGPbv/pP/2n9rVf+7XtSU96UvuwD/uw9jVf8zXt67/+68/Fb2VM5xh1kjsUJAf6rZ11fLwsj5hXxt4dEQ8SbEssy524KnKeQKrPrqZZMYI3HyTpnFYAKwUmfPaczjCv6Ztg0519B1wqwx0tlu86lRw0OV6USS9A4PUn+PTrCUSrbilwRP4c0LAMnzlMAQoHT5QF+XAHmM7jYrFYzSKpjRk48PIqg+16nGY9qVsOMJlPWuWi56k7WvFB0F8FA8UXZZj4cxn7fweF/BYJJCpQQNmxfR2wqi4OZucEP5xUF+0z1zdX81QBAl5jHdlmyQbNCQy4jiZ5pvFBMnIwRhvXC9R6sIr1cz5SMIHySWOY2xQCXD0noEd7qW8FF1PAQr89oD1VZ6+ry0P33X6oHD+Rn/acdfcggPqt64nai+dGsO0TcHMZSKYqL5Xjz7gO0VZIrj7hQOqtMKh03nnx31o1IF78sE8GiHQugUC99IXt5EGXnZ2dVTCAslPQ+NKlSyt95Bh09erVtf7EVQ6+4sVl0GtDlw1tgPfLBMQrefN/ZRuTbZqyU1P8V7QtoPr1X//19pmf+Zmr/zrT60u/9Evba17zmll5vPKVr2y7u7vti7/4i9uVK1faZ33WZ7XXvOY13XOvBg26HYhvAmmtfhvI0dFRu+eee9o3fMM3rF1/+tOf3t70pjfFvJ/61Ke2l7/85e11r3tde+Yzn9ne+c53th//8R8/8yrRKbqlAgRzDJEblhe96EVrqwUqespTntJ+9Vd/dVvWzlBvcJ3znA/w1Yyf59dznhzczeGH5VxUUGCqrPRccj5UH85IpFmNBEp6A2Ea8B2U0dklwEuOO2eVNhmw0/3kqLrz4YDUv8UfQYLzlQIR5Mll4CDdAyTUN57c7bO7Pb2sHFDVh86zB7MIOMSznEwHIB6YSIGS1C4Orlye3veSrvOjeuleahcHBImvVIbLzetWtUNyjFOfSPXj6fmefwXAenYj2T/nxdslOdGJV8/LQd8UqUwP+vX0Ot2rgiSp3zjY8OBUVVe2AUGz30t8e6DAbSD7jtuOXvtuCzqqvum2I/XT3vjmOpPqRLvj8khBaH1zjFkul2uBTB93lI7/va7+2wOmbrOpm3N0m/lXz1W8pdVVvoqEfHvQycvwAIEClQo8KDio/7rG4ARXJbht7K0c2FRec6lnJ7btFxfFQ+/eprw97WlP2+iZP/qjPzpz7fLly+1Vr3pVe9WrXrVR2YMG3eqkQ+9F1dtA/u///b/t2rVrZ87d6L3N46lPfWr70R/90fbsZz+7Xb16tZ2cnLTP+7zP27gf3VIBgvsDVYBL5AbTwU4vbSqrRzdrsHEiX5wJ0EwCHRg6Eny+54BwVj8BN782BUa9TF+i6Wkc4PDk4+QcT4E8L6NyWCq5TOXXCwIkSg53AlGJH+ozXz/mgEROIfmYkg/b1VfWJMDts/C672XPcYbcoXf5pd9VvZIcp8r3a1Pgl0QAUTn91bUevz0ns9J/to/fr/jxeidgn3TMyW2OL8eu9Luy4S6zXmCH357+RpDbqMST1ydd47NuT3v2KOlqKn8b0Nr77+OAviu9c95EyWZSd6o+nQIqHK8Wi+tbd3idK6B6+st6sRz/7bLg8/5sj7wP0s66XvhqpdR/kuyY7yb60LMDlV3otfl9TTeTn7m+SO//oEG3G90K/V7lv/Wtb107/H7qsM/kh1R98i1veUv76q/+6vZN3/RN7RnPeEZ7+9vf3l72spe1r/zKr2yvfvWrZ/M6AgRbUGoUH3x7S6BSkKBKUynAnNmQXnnJkepRSpOCGxyQ9TpDLZ3RgUHpdUS9Wf/W8vvhdd158FcVpYGuV5YvQ5czp98KCvDVS3K2uF+Sz1VgMpGDjOQIkhd/VjwxLyctZ0/OsstY6VnXiuj4ugHzVQ1paS/TefstFos1J9r1wWfj9dv30vt2BMpYdXTZSkf52rHW1t9zrnx0LYFb1o/l6j9n4HtbFShrykjXKX/KyIF3BYpFDiK8XyVQzjZ2gKm+k3Q35Z0ACeXMshkEIS9qJ9VFs4o63ExLm/nKSa+f17Oy4ak/petVP07y5D0PgKXnfQuHll3zGvOu2kLks74sK60i4nM+RlS2I6UVH943XJ7MO113PUyHvvo4wvZM9t37sJ7xlSy+usnHMQYs2T4OqtMKGdabS/S5LcL7U3Uobcrb7YjLvVo9QlvJMxzSWETbTXmkfuP1ZTke8JMsWEdtLdDZA74CJlEFKKaubQqufbzo5V+1ibfdXOrlM2jQoBtDc96O11prH/IhH9IuXbp0ZrVA720er3jFK9qnfuqntpe97GWttdae9KQntQc+8IHt0z/909u3f/u3t0c84hGzeBwBgnNQzwhvY2RTRMjBoi8X7g0o6bqe4VL0BDJ6eXrZieSEHxwctMuXL7fLly+vThV2Z7xaHkmqVgMQOHCgoyPmSxxZTnKUWH93hgVudLgS24XgQ2Wm8yCmgjvulNAh4m/ymfJJ4E7fHvCollomkMwyPE0CSA6MHWywbLYdyQ8HU3vLYW+trfa1JhkmYEMZUa5eB11z4O8AgCsn9JxvRXHg631PAMaXc7t8dC3ZGabxLQYqk896cIT89AIETKd7XEbsPOtTBQhcrgRRXncGa9gm1VJl6YqWIe/u7raDg4PVOR5qH7c/FWgiT97OnBnWM/zutVeSa0qffvM55ck3rnhfZHo/vJB5s+0q29rj0W10CixVesz7FWjkvXSg4+np6Wp/vPqXZMNvypD619r6uOuBFz6j+8xDZYo/6S7LZZ9MM/JJx9hn09iTzuQgoE76TrmmlY2uR2xT5aV+KX5UB51JsVgsVuNnFSDw9mZbM1jjgQJNSpycnJypG996o2AB2491998ug3StsouJ0hiV8nI/q3om5V/xPodPl/8IGgwadN/Q/v5+e/KTn9x+4Rd+oX3hF37h6vov/MIvtM///M+Pz/zlX/7l2gHjrbUzEypzaAQIzknu4GxiSHsge65RpkNRkYMEdworfhzMtZZXLnj+dGzkjO/v78eZuiogQD69rNbOOolpEHXg4wOjnIrW1mcY9Txn3tyB0j2fOaaj4YcH0vlJg7SDQV1zByylS7LrBQhICcAnx6Tiu5p5c+CTnA6vAx1QpnensbV8kjt51F5UB6UuUw98+Gywyme61N8ZDHIw5rpYASOChJ5sUlslIMvymXcKEni7MnDieaY2repDQO2zdpUcKGfXd/LHNBXoZNsxSKDVA3o2HWBZ1SfpXJI3+Ul9NaXrOe1Kl2y+y4n8eNvpmnTWAwbMJwV82H8qG+zfXi/X2944luyC677XWzymQElaOdDTY/aDFCh1+5j6k+sHnxWgVf6JD40hXr7S+asEaf88P/aZynepbE8aF3zVDVcJinc/fNMDVwqYVK8lTO2h+nHlHvu614m64Ha554+lPnle4Nxz1N02pzE76ehUvtWz6bqPv4MG3R9oqn/civSSl7ykPec5z2mf9Emf1J7ylKe0H/zBH2x/8id/0r7yK7+ytXb27X7Petaz2ld8xVe07//+719tMXjxi1/c/upf/avtkY985OxyR4DgfkrsBL0Z6+qZTSg5NGkZ4zaDDAetNEgmnntOKfl0IHQeHltbnxGXYypHxmeKEihITtDNIncMNim75/g7CEgBiCmQ6eQALS3pd4c2yTyl81n7qToncN4jXxmwCSUAlFYZkL8epXarwMI2NCW/FKCY0j32WerYVD9PH+a3DfVsE9Ok+64z53VaUrv78ukpHqd4rij16bk86novEMMynC8PElT1SL/PS7Tt1Cef7Z9j1xnAnpKj51MFFLwcD/g5uT737Ol5aKrvpTL93iZ5J/swZWfm9pVBgwYNutH07Gc/u/35n/95+7Zv+7b29re/vT3hCU9or3vd69pjH/vY1trZt/t92Zd9WXvve9/b/vk//+ftpS99afugD/qg9jf+xt9o3/md37lRuSNAcE6acnamwMMUwJjrcG0yiG5DvVmNdF2OSFoaP9cpp5OSHIXkcFYOjmYXOKPBWQbOHnJlxRSvft9fu6ilpDxzQbz0AAtnZHyWm78Jajmbp2cT8Ha5TQEVpud+fpHP/JE38pRmG8V/b8Y4EZ87Pj5ekxEddN8KQhLA5nLiqv2VB9tD99MqDeU35VRzWbL++0qRtBWDwIS8cdk9+WN+vrKl158rsJLAG3ms9vZST5MTX60oSqDGV/14OYvFYrVqaW9vrzzV3G1GAhPJ1vZsA/d/u8xcp1KAKgU/eu3A9uDS9V6AYrlcrm2ZquRMeSqNyynJcI6tnwoCVEEBf4462Nq6TfLzBpLM5oBfX3Egvatklmbu+VvPSY8ZWHbZiCh7X9LvZaS9+T37mrZn8HryU1IZaZx33fftQbLDPBuGZwmxf6TtSqw35as+v7+/3w4ODtpyuWxHR0dntpVs4z9N+X4pr974nKi67/2tSluN9ZUNm8pv0KBB9w191Vd9Vfuqr/qqeC+9NnTuG/56NAIEW9CmhjM5r4nc2U/35pTVSzsnGNF7Pjk6/lv/04GE7hylZ70eDjyc19bWHQ46fQloMDDA/0wjh6Xah+kzR9zLKh4EXHU4o/Y7M2Dihzg5f3QAkyNIUOHycCfaKS1TTXV1WbrT7nudSO4ku44zL+3PdcCkfFwneY0OsZaNE0y7c8w91+5we7CCclJe3E9LfeBvX05PPr1dUhkMXFBGvpRYjrW+qS+si+dNmYif1C8dSCQwlYIDrieUNdvC24B56j7bxg+I1P5y8q30CgwcHByswALrzeAUZeDt43WoAhlKu1gs1paNiwgufaXR3NUrTg58ub87tUOyp5VddV4pA1IFgFPwxnmnPXB7y4ADbS159/tePy4p9+BAChZ4+bRFBNF+pkjq+wq8uF1mYJJ1YJCS29ioNyxfH+qk7rGP8+wf5kEZprY6PT1tx8fHZ+rs41UVIKiCBOKbbXLt2rW1stweiJ+Tk5MzQbBkV1Tfvb29du3atXbXXXe11lo7PDxcnUPg/SPpgNdhimhPp57d1lebw0t6tuKtynsECQbdn6jq4zebh9uFRoDgHOQAR9e2eb4id0zdKaeDkYz6Ng5nej6lcVDq5A6ED+Asi44VHR06D63Vp5kn0Ol1OT09XQEGB+l7e3tnQOnctiSvXEEggHB6eroClD67IseN8kwBDNXTy2O9KXNvp+RsuHPKvFIbJWe6AnX6nVYceJ5qG95TO4uvNNvj+ao8ylcON8+9EIiiHBJIdfk76FYa1zHyk+SV2oByJ/Bg/dU3BEQS6Jcep77Wc+JTgCDVg/+5h5ft6H3U6+sBGMpdPFVAgWXrLRxpplrP8LwBBQhSOzBvBnsS/0rrz/p/B7wEYGxL1ikFaLy/O78OiD0wlQAw07rNSx8PElRyUT3Zlj2w4X3bbS91mTpA0KwyUxBhzuoBlyf/u/wYWPSVKMkWq1yXWwpKebt5QIKyZqDS99pzvNBYom8/B4C8cPWKeNM4prrt7e2t7CllXtmVCqQqjfLm+M5VBH6uj/jx1RzMm/LX20qWy2U7ODhYsxvHx8flKq/eOMiy/Hryx0hpHOazlZ+2TSChN+70aBNfcdCgQfdfGgGC+4gqoHBR5M7mjXqmojmOwhxKwES/mWYuuePL6+n3przScamCHO5E9JyCiv9e/SmjKjhQlUHQ6Xmk+vIZd47T8+THr/uz7rB62e6g9fSDfFTggI4y+fDv9Lung5vqp769fr4E2QGmO4RTgQkPQjCd5zOHZz3X0+mqfL/WK8Pl0+vLc0FLKq9XB2+fykEnP2k1kqc9j3POQIHnm8rS76q95thEyolBBG+bHrjxfut208uv+rjzmPqGl9drk1RGslfkz/mYq2v8TgGv6jkC9FQX3q9038d9t6cE4smes5yq3q5jCUizPP5OQRjdI7+pfNY9veLxRhDHuBsJtisbfaPqNWjQ7U5zfJObwcPtQiNAsCFVzuCmRvlmKMnp6dkTgXtUzR5uUt+5zs0mPCSe3HFLy+zlHFT18rRzjYeD6MrJpCOjpd+6TgeFWzDcCZoDPBLwcVDJcj2vOYESB9cV8EyyUhnuxOoa+U111exX1T50MLmst7Xr+si9qpUzpfyr4Ig7yokPOrh0zpkf0zoo6DmuKQ2DKHSok9PNfHzGeErXvI5+rZpxJ7k+SS4O4smj9085+q5H/nq3FBSYAgUus4p3pk99a27fUNoU+OkFRPhcb7VGSiuqZk57RHvns87+Nhjx7Lx7YIX6ST2mfvuKjrSKTPl5fdPKAa9TWjHG/pv0h/lRV/VbZ8/42OO2fbm8HjimnfDVLr6qyVeTkTjuzdX93hg2FdhSPdiGXJlS+SCSla+gEz+y2a4bbEdfOcP2lZ3QCiKtILh8+XJbLK5vAeLbiub2hTl2ZE4em9gKf24Tv6xKP/XsjQ5yDBo06NalESC4YEqOXQ/8pIHbHR6m793n4OzPbMq/A3DeqwYaf9VRAqx0/AiYq1kMp+TsMr0vz672Qnp9q/vunCaAlojOn5YyMk/loaWaly9fXjvE0JeWuqPpfPj5BL3ltw58U550SPntTj1lVrVZpd98+wB5ZkBB4N4dT6V3UECHknXXb5bBJdDkv3LaXKdICbD5dgfmnfS358AJhCV7IfmwXxBw+uvEJIs0m5aCKOTR2zk568l2iCfK0c9KIEBKh/wxH5azv7+/+paz78uqU11Tu1Cvq6BA9T/dq/qR5OXPimfx6UBVz2npvJZoJ15UFy7JZtkJ/KXyxDcDOrxeXav6isqvVlvpWemB50Hb6AFG1cnl09NNgnrXZwfmtJvklQGT9Hpbvk6SbeOBApedwLPSep9x2+lL/avAo9tC2i/yMGXTlcfJyclafXWNdUh2lTrlfDBworzdzqqNeS6B5CTZMmCzv7/frl271q5cudIWi0U7OjpqR0dHqzMJfKynrvTsQeWTebpKjr0ymLbnz035kVUbTNEmaQcNGnT/oREguCDaxrDLAenNmjtwprOxjeFWfu7UuBNGnp0HpxTooFPi9U9A1Z2SnvOenD0ecEfHKIE0r8/cJYd0KJmX14npl8vrh6h5PReL67MYatO9vb2VczTFE/lmHR1I02Hy+iT5Vw6l15lO2tzggOuRg/nEP4M0PtvDTzptmzOalDMdUz+sKukeyc8hIM8eIGB+clYp9znkARNe9z5Kpzq1kwMZz5tBOy+j93/ubLa3hYN45cNVEHqOoGS5vPc08tbu7TOtnQWOfkBq1c9ZnvdT5zv1oQQSUvoeUCYQ1f8UcKWu68O8Em++z5v56OMAn+3EgI7XmX3UdZM65cDagxspIEqdklxYT80QU1eUngEC8pzalsCfs9VpFQvthddf3x44cFknu8m6qe31m2CZZ9M4cVznp3dAMHkSSJ4zHnqAQO3DmX/l76tKmC91vApmqU5cicB21kdBAtVR584cHBysVmMoiCiboUDBlI1LVIHt5L94Hu4reX698XRuUCI9U/Hb439OGYMG3Q405Z/cLB5uFxoBgi3pvFHVKSXZ1OhvQ1UeHhzYhKYCCdW1TeuSwBEHToKeChRssv3CyZ1GlxMdJvHLZ5wPOsOsXzV4p0+SD53r1DYJhKXggAMIyr7nTFZAS6SZHd6jDHwZqgPHVGefdfT2cV1JsuA1n+mt+K0AsgejCDqqeiRyx17f5COBkQSiPJiQghZJ97xMr3evH7sOOZDZ3d1dgUa2O5/Rx9uTp6J7EDTpZ+qzXk/KI+ld73/VPlW7cwY4Bev0X/kQILXWoi1LesDgQMUnZeR2zutYgU5/jvwzkJeCGpIHATuDa7rGYJfLhh/m7cHwZOsoJ44lbuvchlT5sC10TVvOlsvl2mG2yc76mxP07fKrxoTEnwc7VM7JycmZIISPpyTVx20AZZXAsY/NTEf9pi1IttqDLqkMtePBwcHq+/T0tB0cHLSTk5N2fHwc+diGNn02gXzXmWQzpvzP6n4V1NA15+N2AjODBg26WBoBgi2p5+zdLjQVGU/Xp+rcW20wx1E+D22SZ5oB9k+VtzsqvRl0L4MOS3K46MTyu7WzjvAc6oH3i6DkaM9p37n1SA45r1fgj5RAMwM4ldPkusC2o/M2J6jD510GvbqzTkm+c9qWdSaP/t+Bo4NIz3NbB7ICMildesaBmgMYBh8SUHKq7FUvWLIJbdLmSf7874BXxFPg5wZsSHNtRC+d30tt2+Mn9bUkg1SWB0Jcf7exgVPArNL/9JzXi3bdgw+8zxUISstyqpUf6b7k4Drk+W86ZjCoU91LNnhqMsHtT9J97xOiynaojr66wl8/ycD+jaDz2M/z0u3utw4aNOjm0AgQXDAlB6YCDO70J/Jl11Weorkz/r1BPZXvz/rg1ot2t5aDA3SAzjNoOThQOfwmDwQPnIXyVyil55SWdWY5adB3R48OC2fntcSSy51PT0/X3l1NnfGZ8uQU6TeXmSbnp5LbHBDLpeo9wDkF6JPMJSMuvZVsfAk/l7aKxIOWHDM/12OfufE+t1gs1vJxffMl0QRtet7L6q1iYVp39n0G3YEAyyRp2a0vZfaD/ygH8uLXqlUTJOmIfvtSaOk3ZyzTiiB9tP2Gstvd3V2dRaB73F6Q+kgK0LGu5H8K2Hrefm9OkIDt4MEPLaN2IMy+zD3U+u/7qtkPaXcTT+LHdT2Bd18lIJBbyUT3VQ7LpF5xq1U1tiqdy0U2XfylPpFsFdP0bCpl4UQ7k+6xLv4qP31L/qxfNVaSN44XqZ7kIQF2Xzmga8mnoa3RigT2X91nv23t7PkzXEmWbE1r7cz91tra9j3m4wEY3dvb22v7+/vt9PS0PeABD1jVs7W22rKkcbhn16rryS9Kz1b+4Y0G7ymwVtF9EbwYNOhG0pSvcrN4uF1oBAjOQds6jSKfHXCHrTc4TQUWEnEm2p0XOghzyk48a9mkA98E2vz/VD2mAIg7qKqTg0gHJwTNChBo36rnSafLHdKpOqQZIvGh9zKfnp6uljsS3PA0bIE6ysXBhDv0BEkJoCfeqb9pSTwBGh1Ml4WDdndcHVA4ICdQ5PfOzs7qYCzKwWfKxY/aVPXnmQyuC2zb1HYub5EHDzzIQPmrTQTYEwByB5dycWff246BCpbPPCXbalk1wVpr14MZadl2tYrG8yQgki5rP7CDd8qM7aNDP/V+c4IQffb29s4cFpd4S3qtekk2BGYOEBMYSGCvAgFsd182zvwI9tPH92C3dvZwStpur3vSoSQbAl+vU5KnKNkGpneg31o7UwaBHmUnQEcZibhayOvKcvjtS9pdThzXku10YN0LfIoYJBAvsqm0ScfHx6v7DuiZL7/Jq4Bv0mMPNJI3lwNlp+u0sZQDAwTkhX2aeeo3Azy0acnG0pZ7mbq2u7vbTk9PV1sNaIOWy+tnxvBgSw/wuG+U9L3n87n8+Huu7+e/e75mGldcJ9Jz6frtBGwGDRp0fhoBggumavCgwU1gPAHuqXI83dzVA1Np54D1NIjNBfp0UqeWGvqz7jxz8Jtahu1LkAlA6WS7w8E8klObgCD/k3+SwBKBNk/s5z5VzoimetGZpPPlAZGKn6pNe8Ty07JMl0FPt5Pj5QBNZTF/zhYlBzM5ej47TZDuTjqfSf3Zg0beDq4XusfTyCuw5q8/I6V2opx6QR0Hagn8SqbMx1/b5s551b7ed6iT0mm2r9tHbyPJRQ6/rwxR8MDbOfFVBQhYv+Rk99rB7ydQnMBWa2eDL6yz7xdPAQKtQGqtnQGDzNPrm0BakhPbsLJnbvcqu5Nk6QfcJYBGPlR/nmQvu+H18XpXdlo8p5UcSRYeAPAxgvVzebfWzgBUlq/D9ajr1AuOaS5v58EDBKk+VSDNefa2T8EVvhWCNtgDjkkfpQuttbXgiAdO2I58nnwwELq7u7uSKetxdHS0FoDhAZredkk+m4ybzutcn6+Xn8vB+Uu/Ny1j0KBBdxaNAMEF0q1mROcC7xtByfkWnUdOabZT5VU0BVx6/J0nkFItMe3x4GDLgxAehHGAtq2z0ZNFD2CkPNg27rxVDszUdXemHKBzeeuUwyYHsxfQmrru31O/2ZbunFcBggTeek66l5euy1knKE98O1AVHyno1ZMjqaqzAxmXhYMBtV3Kw4Nifjr+XKra8jz5zClnKgCRZN2zDT1K/aRnOyh/BuRSG8wNVlftNKVTye5toosXSXMB4hzZpvRaNp/sRG+cJVWBkLk8zx1TXP8YjKT987bq2c6UjwdiE89VfWgj3L64rXE/Y1vaNIjA5y6StuVj0KD7A90X40Pi4XahESDYgpKRTUDGnxFVUXofiLyctIye5em+z8q748Z0FT+JP5XTA9uaOeg5L3Odmuo555d7mHsOjWZkUh6ckatmR+Y6otQFypw87u7unpGTgxzWgw4e9YJgKc3qsb0qh175nCeoI57SzJvP+ieQzfxd76u8vA0dOHqggvLQfy5j1fW0FJpBBT3nPLB9XDb68JV7virB01b1ZFkV9drRwb+3PeWc9KfXbv475ctZUa+b93HKKqVJQQLlrXZzchAwR3bJrldjAP9PpfFrSVdba2uvc5PO0l5VwRXn3evdS+M8petzyFcW9erOFV28T/78QEbKIwHOVGZlv6uxcI79S/85Bng9euO77kuPRXt7e6W++EoppkurHJxPlu118XQJSPP1rwTxXBXCvszVPxwLXb/5mk5/80riNdlN8cLtCWob2aS9vb2VbVJAxlc9JEo2sKcvc/tNaoteflP+yHloW59t0KBBty+NAMGWNGW8K1Cmaz1Hrnpuqiw9l4CH0qWledUA4zxO8a0lw1rG5++/TkR+OCuQeGcQhMsEVW561mcuHKS11taW5/r+1dbW91bSOe0BADq7KleASN90qJITTmdruVyuHWAoXpRXcow0U0y+KHMvN5EDYubP5xMwTzPVaUaJ5AEGXlf7e7BEeXOPPPNJTrPKdrBBHpw3X/6ceJdD7DLicnrqQHLQK+DLNla9qj6bAnnUI+XPQ8UkB/73es0BvcnO0BnX8n8/oJG2i4E01j1tSSKYkqPvOsYgnfPo9oHleZ/q1d+DBwnIpTRevuuFZH9yctKOjo7a6em9Z5VIf1N/4G8Gtiqgn1ZleJCmApU98vGFZVQA3W0OeVoury81Z55pi5GeTf14irwP0G5pDKFe+XjtdfTgLW2mrvvrBSk72g+vD8cpjlEk8k7+2IZVcMT7ML/98FHyzqCN0iqdxjICdNoZnqnBrQVJZ7xOXh/6DeJD2/dkL3TAqfwAjifHx8dnth663ZhDVbpkpzf1+6rrU0GD3tg/aND9jdL4fV/wcLvQCBBsSBrgPCLvDkKKKlf/p8pTfmkgcR7ceUuBhmpAVfrkhCe+3YHhh+DX8+AzmwxQTMu9+FMzgskBd+DMGQvlIYeEpy/TIU1BgjTw8tT1S5cutf39/TPOlki/fX8mnWDpng435DkG7oiy7nRW3ekTJSfM5ed7SMmnfrNMnw2slqmL6HwzL3e66aRJDgwi8DyHFBigTFUvgtJkyP3gN+qLDtujffA+oQ/31FNu1coCzze1V2VnXB8cQLhzrzagzD2ww/wrXqnj0n8GCNROCsDpOZXP1QZsK+bNttfBhLu7u+3o6GgVqCG/3tcEqFjX5GCzL+t6zx6nAIGnczsi8uCn2oygiYDFxyL/zTb0Oqb0TslWMKDkNHd1S5JPmhlmW7d2/eR67RcnjwSFXifvz17fCiBX/OsZr28lU+fFbZn0UXZE6ch34pHjQm8LkAeAqvGSfLFM9mXatJSX21z1s2QPJEPZxipAkMbW6ltlsn3I++7u7ipIoDG5tXt169KlS2vBFvoB3m6J0hjl98Vjusb6TZVDcptE+bvcqjFjk2uDBg26f9MIENwgmhpEtsnvIsqkI9Zz5OaWl6gCOL08NhmA6AhWjr1TihwSPNLJcv7P247Ooztaif80+HPAV/txtjw5116HCkReFCXHxmen5/aNTZxv/dc130rD60rLtueKg5783OFOdUrg0XXAwSrrwz7qPE/JhLzynjuLlfzdmefMsgcIKMc59U3ggkt5mY/LyMEtHWn1Bx6K5nw7v85rkkfl6KcgSep3U/3Q+zSDStRX11UGa6bAeKpHBapIlW6mPOdSD5R4OZU9pwwYuE2z7ufho/dcxfeUDk0R+4bIbZIfsKfrvuoq2Ssva4pOT0/XytNzqY2STUvbGtQ3fUUSA5Lk2bfSJHtWjQnu61Q2Km370qGQ3h4ViZ+5QSbnw/OiXM/jf2yie1XabXy0QYMG3f40AgQXQBcZCOjlP9fxuagyKwdNNHfA6C0r74EqlkMQzLLnBgfckffAAHmp0vJamq1xuSQe58hsauWFfyeeNAOi61xx4eDZl3p7uT0wqTz8Gp+ZKye/PjXL4brozqHrDIEjAyoeEGKwiE6v620FuumYps9cfU2zgSk4UAGTKT49bznkdNQJWntO+Ry7wPonAJpm9xMl+RFceQBOPFe2g79Zd5fPJuS64kDP7Q/tUAK+PXtTUdWv0r2pushOMICa8nBbMCdIUvVvlpHssL6r9mL+mwYF2CYpuJKop6++Koq6TnCZ+kUCxl6m2oRBstbqrXBTVPXRitJYIPLAl/hZLK4HIltrq9U/0vWpwCjLTrqu6+zjlU3m6i4GBnSPW50qHd8WQM8Jam1LSX96ffJm8zdo0M2kbWzhjeDhdqERINiQkpPu93v/595LaTZRrB4Y4CBHB6pysqp8eN9Bp4Msf0cylxVygK2CAFoWWDmTc2XiM0+np6fx9Vitrb9eyfNweSXQIRLffE0hnZUUPPDfnobOlupE3dzb21ul11YEOn0sOzlSXm5yEjYBLMmx9RUPmxjv5PSz7ViHBMpc1whAKEs6h54H8/J+IsdSeuvnciQgWvW31C8TcKHjzeem8mptvc9Sfq21tTMLKNd0yKCT+hQdbW4/8u0Cyj8Frai/rou+P3tvby+uIEl6rucqO9IDAWlmku3j4L8K+jggUl1TP1Gaqt+kfsx859hLgjrtF3f7MSUv58nHmWTz2JeXy+Xaazl5WF0VlEzA2+2b30+2wmeuOV6x74tXyozktoE2m0FbytRlQnkmuyf9PTg4WONRPLm98ryqdmQbV+OU85RsDYMB5JsyU//V9gqW03vjCgO9vO980r7InnNVgnwCjfX0EWS7Dw8PV1tb2F8rG06aAtl+vzcOej4+jkyl712fymvQoEF3Do0AwZbUA+CttTiIVnkkozzXUFcAvgf2qzrQwSF4Svl52e780enlcng5eDzAUJ9q5ry16w4EZ4DJL88USI4aHT8SAwQqj/XiHkQCcfJH55llc2bEZzf9P+vq3+44+vkEqgMdOM4E7+/vr5xtOlU86d0PyCJIURniJc2gJP11+Xu9+NtB1VR+6V6a8UpAytuSS5ZPT0/b0dHRqs4EmiSClArACUBrbzyDNgmUUFbpm0TgUsnHZZnkyvro222K+KWOOMivALTLww8vTaBDZXndqY/UJwYflBeBO88NcJ56PLs9dD49oOJAgeXyzAACNPFH+6h80ttZXGbexhXAnKprRQRBbGfxp3v+TAqcOCXQngIJkiX7quuy6pjaiXm7PvFZEt8Yobr7mK68uBLJZeYgl4eCzgmwVXKkHvj4qWB8GrcODw/P5EHZeSCAeuNjHfNhvcl7uk4brH6hPi9bqXMBGFSvxgiXURo/VR5lT13RSgbZfv2/dOlSOzo6WtkWnX/h/EzpOttrDqX+XPlgbEd/vsq3R0nPR+Bg0KA7j0aAYAvaxlAmx8RnIOaWUYH3NFA5YK2AWwVCeDI8eeU95VM5inQIqsHMHVknDxDIIaJTU9WfIIpOGnnkTIbXiWnc+dVsjc94skw6Ve5wJWeG9/13clRba2sBAc8/la26exp3ZBgQqHSOQEnkzlACkM5rmpFJVOmIA1XvZ/rNNNRJ1ofBrV7f1e/kxBFI8y0bSS6kCtBzhtnl0XMiPS+vr9fHZUUgIkeeYCwFR5ykX5RDmlF0nfDZ4krHBaSXy+uHdjqISDaqctopK16r7GdFbvucD/UvAVICGd3np1dOkqP/Vp6SyRxSX+BBqKnsSm/dNqd7kgPTsu+xT6Z2ZLkOmqpAQK/tfFxgvb2NvIwUKPbABftDJTuCfh64SqrGCB+r1F91r+czpDzTfz3v8qcM+U1AzYCFntHhgHrdIFceKZ+pdk910Ldswu7u7uowQhFfn6hAJp9v7XpALI2TlUxSmyWZVWNCz7ZU7Zaer/SGZfbKGjTo/kDV2HGzebhdaAQIbkOamnW4qGc2ze+8A8yUozIHMPf4TBH23moDOjSbUAoE8LcDxarec8id4Iq8Lvw9BXBEHpiaohvldJBvr0NyyKaoB1DnULUKJF3bhpID6W15UTQVsHCHswoOOHj3PrwJzw5op/pT4qW63uOJgZEp8rZIoMCDpQyuVPKcK6dNdHVbqoImve9bHXQkG1UB0YrcDvE3V9lUM91VHul+Fexgfg5ee8CZv5MdIzmY9d/Sa0/vAYL0u7UcxPMyPZhS8ep1TWmr36IqOL7J2HAj6aLH1xEkGDRoEGkECM5JVdS2GpT0X/c4++15iipnZS6w7C1Drsgdycqx5KDCWX6fLSSPvZl0zpZxyTCXNydHizLvOcECuVz+y2foyPvsJcvy+vvWBd+/mbYXsF4V6NE1b4MqYFI5djwt3tNTzg4G/bVu1ayjl5+CLD0wlnTcnc2qXLYd5ZH6UQr4sE00w6QZU18Zomd5LgGfl976thIPVFXgIDndPXkRNHvQpwI6bm96IE/8uPPfWlvbbpMCAlz6r+XC1CFfvdHa2YAe9YozyrznfUv9md++osDLchmmvlXpjsvLVwu01tbOOdE9rqTwWV3Jh3x7kIE8zCHfquAz3VPk+khe5gQ5PF0P2Hneui6bObV6JX1X5el5307mK1d6QYMKbDJ45TrhPDGd22PxyXp7HSr5kw8t4U/jmv9OK0Xc7riN9pVVlGnqJ25DuLqPM/5pfHK+K0qy4GGEkreu+2tPaddbu27709ksVdnVuJeoGg+qsT097/em5JRs3yYyHjRo0P2PRoBgC0oDNAd2XuO3G2wHfFVZospg9wDH1PYFT+tOUY8flq0BNIHhBGYdSBAs88AiDtDOswPPNLi5U6LggKfjsszj4+O1Jb8E/+InzYq4Q0Gng3X0vdzUhcrZSCslXK78ZhtzfznPLxBw8rzkNLlz6sGspI+c7XVgU9UtObR+Py0zd53q6S75EH8ut97Sac+PS1Dp0LKNuVy1chCTvWC5fMa/U35skwTAnVy2yZFXHgn46gBM6jn1f3d3tx0cHLSDg4O15dIsNwXD2C8TkPI0DPDQJjF45HVVuxD0JD1LwMj5kJ3gN9PqgDPfRkPgmNqJ2zB8iX3Sz6q91T4JLFVBAl+54cEA1jOd80DbzHs9UCNKS/zZR30ZfSK3D+TL07EeDmqrZ3vjo9uVFICe4pe6SXu9yQoHD6izrqlOaUuF0iR7Tzvq+i056lC/9DyX9rMs8Xzt2rW1LQfue1HHqj7gesfgIYNNPnb7NfGgwMDR0dHqvo9hU/3R5d6jqj7JH+j9n8rbdW3QoPsbTfmaN4uH24VGgGBD8oGWvysA5M/6Nc8rpamcQZGX70Z+zmDRozT4MH8fRNOyYq8zf/vH81Idk5ymAASBiJwBd4Q4yF+7dm11GFFyPhNwkPy5IoBvL2itrQUK0moC8VLVg9dcXqwL60yHlDNHLNOdJK+XqAIxSfYiBxXJ+Z0KDtChTQ64X+tRVRb1zh3g5Eyn1TFyOPlJwIx9eMp59AHNQUsKEBAEqN0rcv1mW6X8KhvHABeDYbu7u21vb291UOZyuVz1LdeHygkmMGRa12V+PPClNmA/V/s44Eqzq75CKMlMv9NZArIpqS/oP+vosqctc8BQ6YLXgXV1vaW9qPqz88H8XIb+HOtRjZVVcNHz5UoSluH11bfbGyeWwwNrq7S9gISXxZl71U35exDCbX8veMM2T3JyYp9kHdzOsH9UwTXWkbJi3Vprq36ucwb4fAL7Pmbpvt6ikWxzFdR1SjokWfj5MNQxtYH8kdPT07W3AlGP3TZ7e/XuM02PUj5uS7Yl9lPPd9CgQXcejQDBOWnKeN5uxtVnHBLdyDrRefDBWkTw4AO/30sORQWq9Nsdom3InX39TvVjcKAHwM8r9+SoJyCanM2eY9Mrr3r+PI7MFLnj1OOrtb7O95y5dD+1t37PqfOmck55zs1jbhuktqOu+DWR6zjB5SbkTqr3mxRgqO6xLsn59fby755svV+5/lfAjPd7eV9E/zkviCAvySZXMjtPWSK3764D/N6kHlNlTlEah6p8EvCfsjGe5yZ19PFG1LN5c8ro6bj/VyBEbwbQvVSW95/qDSTnIbdLPXug6/ydxu8bNZ5t096b2PXzljdo0O1E5x2PLoqH24VGgGBLqhy6NOC5w5CeSfnPSXdeSnmmbQn+TOKNDkHaP6t0mhHwsgiguVzZiU6W3/cB2x0WzjqSuLTUZ0JS/acMTeKtR1U9vQ5zHLeUR5VvmtGSfJ2/5fLs675SntV9d7TcGVws1vcep+f8GuvrqwzIT5Wfykz5pbKYD1eetLb+OkvWr7ekeJs+nXhNAR2VzT6xaXkObPTbgbTK0Sy5aG9v78xr/BK/m/LCb9aZDrzbDy9bz6sNpQtKU82Kp0CA6sitSV5maiPvB6SeDdlUd2j7eG2OvUjP6Dmf7fd6VXymfumydp3z7UHMayr/SveZLvXTXh9jv0ogM9kpXvMtMQ7g+T1nu5DzRqLdFi8snzP2yU9he/MadZ1n9nBscX1JAX/VjeOutgIeHR2ttWOyabqe+ovLnmOZfA2tDtBKD70q0km+i1ZGsc+zrFR2apeUVum2sZEu1155VWCrl+egQYPuHBoBgg2pcvLmpKkcFJGnmfO7x0sFlKuARW9ASWmdJw3oGmQ5mGsAPT4+Xr3OSK8bYkRegzVfNZTIlyjSOXCngU5sCjrIiTk5OWnHx8ft+Pi4K+PK2UzAms6PtwGdtuRAOAhLqxK8LH+2R2qTo6OjFS/Hx8ettbOHLPqS+R4PSdfdcWZ6B450YMlDa2e3i+ia9M/LSjJnfgxKVKtLyKPK8LMjWmurwwn56jJ3HKsAi9e9+k+eec2d8PR8kkePKtCi394mbBuCBm7ZmSq/cqhTcCLlIxtCnnZ2dlZ9nKDC289txunp6QoouK3xA0xlP65du7bqQ6le/jsFTRwsJSDqeSVg0LP9TpRDCrRRPpQlt1M4cPeZVm378Ff2sS0kb9e1FHDm2OE8Tm0boTwczHp6jjXJ/ricfBm/8qPNZxrXQ8qM/FAHdJiet09lZ3vBararzqlJ9lt88MO292AA8yX5VgW/xrqcnp62v/zLv2y7u7vt8PBw5RcwOKuyKTcfX1N/p2xk/09PT9vR0dHKTzk+Pj7jMxwcHKx0WT7D0dHRqh5Vn3SaCgJ4wIby8XRVGVX5PX+jV9agQYPuHBoBgi2ITkhvf6/SunORHAjOYqU8qjxbOxsISM6FO8JTkeVUTq+O7jRQRgQ0+k3nkeBpZ2dnddKyZEuHz53lBPy9TDoRDDpQJhroefZA2hPcmw2unJKenH2ATv/ZzhX4dafE80pOBp39xBcde+0hT+9C9zr6DE+ql9LpO/UHytP7EMvywyS93Vh+ytfLdz2j88w6+L5YP4BSOiTQoxmqNCtatZVTSudOOPtfpSMJlKSyfIVEakeWz74oAKm+VdUt2bEKMLFNKTuCfoJRt0FuM1KQgIAnAV/V1wNLDDC6zvvKGAdRrgfe//is22TWkW3CZ2g/KwDo/Cai/ZNMfcUVy6ZddBn2gA/7qGTs8qIOOH8JPKf6sh28rQlSE9iuwCbtngcIXYd7K8fcbrGNqXMuv/SbQUs+7yB+sVisDuFzvlu7HvDzwJAO9k2yTnzRF/JyqBs7OzvtypUrbbFYtIODg7a3t9fuuuuulZxdH/VMtUKRsmB5Sitdu3r16lqwirJTHpcuXWpHR0er/uQBEq9Xst1uu5xXtxdJplP+WaLkm1R5TfkxgwbdLuT9877i4XahESC4YOqBdk+zSX6t5Rm6KaocvUQ+iE3xk8qqlpzSmeCgWDlunCFwByANWNUg5mCpGgC5RJh1SA63X6/K7fHmDicdlpTGAVJKk8pyxybx2HNifdbPQSP1vKfzPX4JkFJ6X7KfKIGsVB7r4ICKeVVgi30wgWwPGiRwWekvy3aevA6eXyWLBEp9mW/VTq5v6X/iQ+W70+ygcYqqtpt6xj8OrqbqqDpU5bF+BI9+bW49Eymf3szvnDz4e7lcP7DSdXkb3igLL0synGszp/ptKnuxWJwJ0qc+l/LRfx8bUhDYbdTcPiPd42SC28wKjE+NBYkEcEm+kkPXaNMEctlfUj05jut3evOD16PHr48b7K8Mwinw5m3hNtB9jCRHBnBV/8VisZogkDy4pUC2TO2obQnKRyuVxHeiOYB+E/+ml8c25Py5Dzdo0KA7h0aA4AZSD5y11n/FVJV+qqxNnkm06UB0XvKAwBwQrDSbDFju8HCG0wGUaE7+np9/Ev/K2wFb5XROAcU5oKaiqfZ2B4EHTals8ZgCB1MydBCX6jfXSenJe4oHf4716t13J3iu/KtA1SbPzXE0E1WAmNcSqKry4LUkA4JI6okcbTrkFb9TfaPqJ9TNKYA3p24k18sK4J3HrvhzDpS97DnkAGsuJfltEsSqglnpd8pD19gve+1e5evlJ95SvlPj9dRYnwB64tfzrOowZ6ysxlTPt7JHDCK4zjlIT99V8CPx0iPnocezxvUpm+DBAtoubgVhvrwvu0L/hUGCTfpkFQyaI5cqv4sA9G5jBw0adOfQCBBcEM0xnmnJOmcYessNNzX2lbOVHILKsdkUsIq43UD1S0CLg60O/dE+7jQzm7ZkVEu0WU93bH11gs+CJMenIvK/s3P9cEWWQ54lH8oqLYN0oFXNhPB/up/aq+cUJjo9PV0dPpdmY/01USw/le28+zJTpklLiFMgQbKn8+ZpROTVt6UkIMIZS21RoUOotP7qQ4Le3qymU3LIkk7Pbdckiwow6L4HrNIsZNJN7wOqu96FrjS0hXKqfSUN+eiBoUrnPGBRrUgST+K1Kiv1JepjWu48B8C7vFN9fNWHgyXW2wMJLCcFB7gKogJgrn98ltdcb/iMbwFKcvGZXbeBqpvbTOdNr6LzvsL2cbBbBSh9q0OyzZWMZBdclz0Nn/f8UpvR5vVWNTH/xGsF/NVe3EKi7UL+us7KtrG9evZGvPs9tb/ORdA4pJUE3jZ6RnXWFgG+etjHSG9XvppV9/SMXlusa9JTHlio8n07WlVv8pH0OOWR8twUvG+SflsfdNCgW42mxuKbxcPtQiNAcA6aMzufnFA6BnMAlOdTRXTd0eA1DmyVY1KB0U3q6HWpytRvHkioAIFAmAMPPutR+soBoWPq8tAgL6eDWwwSeYBHzthUgIArBOikc9mpy9M/LLcHcFh/b3teFw/JYSIRAPjSXjpVBOiVE+x66bM0CcD4e8kTCPIyfekznVR+GIiqVjBIz7zt6fSzHj0H1OXKfKcApNJMBRzouKd+nvSKz6U2cRknPRHxMEul8SXI6iuu21yqS9lWwCfprwNil7E/09rZwzAT6E5t5eAyBSbcIUkAMsnZ20Xy4bUKnDmw4W+fKXV74PLVt/cnL9OBIAPDalf2pQoIsT04DrDt9IzSeZCC9SZgo447OJZ+us6QKntDHvmfz6WAoo+71CP28wQWyR/7qtsq11XKhWOj2w2Ni6en9x7aJxkle5ze+OOyqNo92RLnmQcyLhaLdnh4uHpOEwqsF8ukjrMNUtkaj3d3d9v+/v7qWZ6fojr4Gxv87Qc+KVLJhny4PiVKOs58UpopeU+V43Z10KBBdwaNAMEWNMdYzjWqPkD1gg5pUJhDCSj2aE6AYIpXBym65nwJjPDtBWmm3UEnZ5icX3d2fMDkgU3uFFWzZwQwzIuOBw+pc8BYOQBVexBA99L0/utacuj9d6+9PUggZ41txXw4c87rdOB8Ft+dOV8+7fkRzFYyTnVPZVZ1d4BF59sDBF4Hl7df77WJl1npquTIZ7Z15NzRpEySzlcOanK+CUYckHJWPz1PGXs7se60BVWbt5ZXdSQgkcpKYJxgwQEf00zRVF+m3FwPEuBMbcQ03m8dWKV6+ixzZf8ZGBV5v2fZCeSkfpnGBV2nfKoVCqmPyZ5521W2NH33+rLXh8EujTe9OlPuVX6Ug+5733C+KtvqYyEPJWSAoGoLEu8xOEBb6LKjXjHNYnE9WCs+0luOGBBKq3IoG7evuqex3Pu221zaM/GilQ5VWyaqxqyp9HNtfUrn9mLQoEGDnEaAYFCkmzVw9MqYG9iYG/jYJM+5RIdsCmhWVA3Um7TBzWgrBwUpECMHzh3IBLCYTwqeiCqg7+SOFp+9KPnM0Vf+9+BAev4i9HAO9YDIReSdwElrdcDO9aa1esvNefhKARqnBPKmbE4PMM7he45d8Pxulq4kHlKQrtdvL4K8/1a//T+fq2z+RfFb9fvq/kWUwXKqoMYU2PStFx4EmgqwbEqpH+patSKqanfy3wvQVEG7qbHaAzr8MNjRWn7jSsp3jvxuZB+q7g0adKfQ1Lh+s3i4XWgECLagOc7aJtHdqeXhulYNbFMOKQfm3kCRnLGKHCjyGc7MJV5YJstOPFX5ME1yYv2/L1VOoIWOR+JZjowvv950q4nzrpkK/U6zbN4+PvPR041UD/Iwx0lIjpzamntVJV9/zp0oXy7M2WSfzUzynQPC6Mj5agPPK+VLnaDe0HFMy1b9WW9D8lDtVWU612uVW6148ee9n00FV5IcesEOd6bTMmrXG2474KobX4ac6p7qW8mgkgnTVkukCZgIplhPvvbTl22zHAbKKjmmupAPnxnvgb8p4DQnTdpawDLTFildp25Ur5VLda/sVXpmalba7bW3aa/+tLM94n3fYpTGcbWjb0txvkUeePY+VY093t+83nw1rO7po+12x8fHqzRp60OSA1f2pb6WfrstT4Fo9y+4qsFlJmI/TFsPOLbwmlYCLpfL1cpGtofqp/xPT09XaXT2hV4V6WOIy4DU87c2obnBiBvJw6BBg25/GgGCLSgZ4OScTD1fOUA9qgbbKg2vVY5ZAhNz+PE6cnmfO0R0yFLenHGuQKU/586IOzEO7jTYkx93ftJSYXdkeI/7qV0uSa6exkEIQUf1vnL/PxcoJGCX8qzycIfXz4Eg2OOzOzs7qwOeEkj1wIK3W2vXHa+qTsqntbz0nNtKUv2Yb2ob51l5+v74HqhJINj1PQWH0hJjydVBRtJDlk/nl9tFHHxKF3u2iUEAyWJvb28tYMKlylyau1gs2tHRUVssFqsDwSjTBBp8rzUddPLOulf9TpTsMINeTEdbRmDs9k3AyongmbbE+XIb39tKlchBXO9Z13k+RxBLPmhr1dbKz99ywgCal1PZncQTZeWrk9w+e/CReRH4qk7K3/u9BxVdV5Itc169Lb09ky2jPnkAhjrKPsAykiyrgIBvHzg9vX4grb/6lwFJJx+LyUcKmDm57U5bDdgO2uvv5VJeHriWviovvaaQ16SrGq9Uhuym6iI5eoDm4OCg7ezsrMmz5/dQXq7zidJ9Hy/mpHFKfkY1rgwadLtS1Q9vNg+3C40AwYaUjGblDEwZ1d4MwDZ8JefLlTGV2XPUqsEmOSJ0WjQApzxdhmkFBUGGyzXxQ8cplcVB/tKlS2dOYiYYdB6nANJUGyZwKZ5aO+vI6161P7WnWz0Q0ZNdr568p7ahrOmEauaEpHoSALNedPDorMlBdgDuH/KVHP7Wzp47kWbvkk5TpsxTQNZXpaRn+TwDAAToLhPnq3Lg+PHnXQYKZu3t7a05uNQzUi9I4EBA/cuDHAQYlJM+rhtTg2cFGnsOePqf+j1tiK/OoIyp/x7ES6Car3P0FQRTfTmVXdnf9HySVRUoYDq1G++zDZPOpPoItLH8BCTdttGOe37Ub9ohtynMi8E02f4Edl0vvSzn1/lJPgHLquSW6sdyfEY9Pc8yXA7UadlqBQN0rsDx8fHayh7lzeBCRa4XrENafZC2qknG1fil/7SbfLuOy4+2x+2MeGV/pI1mgID31N8lM7fDCnYeHh6u0onv1G+devbA04m385KPc9vyNGjQoPsXXQw6vQPpIg2mD6itbRZlqqL6F0Gb8NFL38unAtkJMDltu7yffCUnpMdv5bxuW76XOVV+BXo8z5tFBFl0RN0pnfq0tg6wWL/qwzSt1ftBUx8T71Pgysvg7yrfXpunAMAmaeY8n3jwAIUHZUgp2FHdT460p/P8Urs7mKqokvmcNBWora715JC2VPB3z65N8Z/K3aRfzwEiVd3cDqV26eldutdrj6Q3KV3KSzJOgL5qkzllVDQVuJhTzpz+tOmnV07qewm0V/a64tlpE333Pp7yr+wAeeOKiKqOyivZHZZd6QqDCh7k7o1HrqdT1JP1zR7TBw0aNGisINiSGPXWf1IF2lIUeQoQbspX4qe1zQIJGmDTrN4Ur5yl4PuoK+ffB3NdmwLJU3z0BmiVmZyXnsN1IyLpFXiqVhD0eOyRP98DQRWY1nelx9X1k5OT1eyL6kJ5ej19iWnqX8vl8kxAgPxXDrTfc0dZ1+gsO79T1OMjOanpWfKb+G+tnemfTMvZ5hQcIPlqlqr8KTvG+qXf7OeVjtHxd3k4Lw50nBfPN83wc3nzVJtUvPA3t3B4erb93EBBkrnrUGqjXp4+blVtNvde0tk0S5x48ecom57N8z7ps8Icb9zmiD+uLnDS6g/2GW4r2gYEVtTThd54lNrGP9xGx20D/O9lJbDrckp62bMfbKdk95lvpc9un32c5PZGz0+8cZuA+En+ieqscUb6rP6tFZK0KX4WQWVXp/qoyt+kL29yb9CgO5GmcMXN4uF2oREguGCqAgP6PUc5qqWoKQ2XFfre6x71HP05z3H5MeuswfLatWurPXsEJ76P2HlNYFXkYIfgLZHP7Pm+aOeD5aRvl0OvPZNsPB/KUHnSiXHnp+eY9gC9l83nvA7eJp6m55TyOd1z55E6yu0DrKP+q50qGXLZaAJP5N/rzHLpcLIdfKm588o6JlmkdnMATHAq8r5LB5Z14HPeH5OOuJwqEDYFkskj+xXTOAh3XWb5rIcf2sgzE7Rn2HW01xcdJPG979ojrGvcCtCzj2zzdEifvmmj9fozX649Z0yoABJ54X/Kz3lOdWGdUxv7YW9sewb+VGY1Bla23W2464XrOvtwlQ+37rjMOB4kXvVJPLndqOrrH9a5steep3jwdnTw72WrjbiVgrqeVglQXv4qUAZqk61UutSWXq9KDn5P4NrH6cVi/dwF32LgMuN2IPpVAvJ61oMWPAeIZYsf3Zf+a4vVYrFox8fH7fj4uLXWzpzvUMloipJM5+hV6nM+PqUyKvsyaNCgO4dGgGAL6oFYUTKqc2bwHfCn/Kt8Etio0qX9/T0+fAAn6T73Beq6nHrlt7e3FwdIOuUV0CLRieJ/3pdTnu4rf3cS3WGZop5DOZccZMqh8yADgyzuSCbgOrdOCbi5U808/TsBNW875eeHSMnh9n3KDmbJjwN17a2n/Pit5xMwTnrN2TYH8RUI7bU36+yg2fNxfUoghM4zT9GnXNIsnfjvnXvQ64Nud3wFTurDfCb1ReeVwEVl8n3jVTAitQProHxkm1pbd94pgzTz72WyHi47yjkFBvjGkiR3Uk/fvH34v0pPufA+A7uqgygFC/WbgQ49x3ZKALmiZMM9EEy9Se1Ne7hcXj9Nnrqqe2qbNJ4me+52uGdXky2s6snyyB/TJttb2Q+149HR0eq/3kxA/XOeKHOWr4Mn2Z+TrdJ19z/mjKlJf9m/3fbShqmfsVyeI0D9Vn6sB8cfPs+6+bkFGrtSgODSpUurA1h5BoH4rsZVynDTAAKfT7TJuDXVTwcNGnRn0AgQbEk9I5qM7pzgQHqGy1Vby+DfDf02ZW3yrKfpAS3OViTqybE3UCYnK6VxeRF4TFGq07aDd0U+q04HkMA9Oc6bkD9fOZp+r3Jm+N/vOyiQvJ3nakVBD1Qkp50zQN6+FWhKwJvlOZBPzjDrV5GXkWbWEw8E/yn/xDvlkZ6t8unVYdN+m3QhUeKLQM7T+FLoqoxKZzlzKnLb1AN1FVGP9BxnPgVenNd0mOc2sq4CBHPbk/UVeJxaSq42UrrKRjmPc+ul51MwgG071S+4gsMDZv4R6HO+WG76OB+V/k/pU+rLXp+UV+q7DPYwYMADCBkw6QVdWmtr+pD6VhpPHGwnSn6E6523pa7TL3L5eLDCA70p4EE90H/qt9eLtkp9xw9/1VuTdN/1N9EUkE/Pb2u/5/BS6fagQbcjbTK230gebhcaAYJbgOYqzFxQWO2pvJHPTtUhAZ45IN9palCrKIHwiof0352PiwwSOE+Jx5Q+Dd49RyEFPPwZOg7b1LEX0PH7PQe7F1hI9SAYSPWbAspV3pVDloCZg8tK3qk8zz+l6+kgHdwKvHhdKr2/rwawSueoEw4g0oA/N0hB2sauVACV3wlEs60cqIhnb+8pWzkFLNL1Teu7SfpNZJ76pwdeKp1mWW5HKNdk89UGHgRIq2+2IfanqTFmipKNcf1nwIuByMRXJUP/XdXL5dPTp2TDU54up4pPD0ikelAm/qx+M0jizyXZpTrqea1Gke7s7u6urUy6CD1K9U00t+9tmuaifZ5Bgwbd2jQCBFtSz2hv4khx8GTUurV1UFv9dl7Svso55ZLvqSAB7ys67vxoANYgyeX+PsPp+5iVbwV6U4AhOXVyCLgk3wd+OoUc1J0XOge+1J/pEv+UiZNAMCm1b3LgOKvBWb30bAKYVdCgcr5SPVN9qqX4bGd3BH1Js/jlDGBr68v11XZcRkwema/zxN+8xxmlNPuodFw+rv9sD+abwIaveNC93vJ21/uUjgGCyinn8lnn2akCAwRSlHVyuNkuc+2TSPz5KzR7jrwHjvS8ryCYG8hJoCDJpkqXVs5ILmwL7VOmDjKvZAfJO9uyClS5vBKQ9N+JH6ZTP2W53uapPukadagKEjh/SfZp5Q/L4PPcrqNZ9nRWTqJ0z+XuabjiSXaLbcdrys/1WK8l5DkDSqPtBK7vqS9ThuS9qit12mf1ma//n/JpGERzWblcKROV4YE4ycjHPclwsbj3rADKNm2L8fpzrJC/sLe3t+JV+egMguPj47azs35WB8eapNNzqffcVHtM5atnRlBg0KA7l0aA4BxEx2UOaQByQOgR9imASAPuYN4dGpZZlZ8GhKmIf29GXtcYINjd3V0dOKYAAfdPJxCWZOt148wxHQXKgk5ROrWZTqMOL5KcfIkhy3Ynj+DVefB66Vl3nOj4cGmyO3RJTj1AMeX4eZoKpOpepfcMAniaxWL9DAKRby2g7OTMeTCGdWT9/eNBCTrTrdWzWwwMcHko68/l2AQiqY5Vv3TnNQE7zyOBFgZCPK3nm07ZT+DWnfZKruTB7QLl7Hkm/Uy65subKwCqcqoAwRRgTDxMBQd6zjTBP8EDbRbf8nJ4eBgDlJVcXCbJLjCNrjlIoXz4HAMZ5MPzc/5o05KNSO2v3w7MKcPKTnmQgHX0AIjy9LGCy/Kr8ZF8VfVwXpNusfwkN8+rtesByJOTkxWPOgyPQQN9M79kRyhX8tez6wxoqa1cXmmc6YHT1O7V88lWiV+XJcdXvyc5qs3ddraWt1ryPttX4F+27dKlS6szhI6Pj9tisWhHR0erfN3uVv6j89yTH9NVwY30v0rr4/82AYxBg241qvrHzebhdqERINiCaKwr4znHSG+ynJ/l+MCRAI7nXQF+OkruCE2BSjovrbUIkOmkEcTz4862g20vl3WnI1mB5Aq0sP6pvBSA8eeqwZ0yEAhgvskZ9zYWAPV6uaPm8tDz7jj3nAI+43n5754T4iCRz0nOqk86EC3lTWeMgN3rqw/LUJk+O6QZntQG5MkDCKnd5JQ7CEiOrH9SfqxzFSRIh2pV+q86e6CDPPbk7nkS4PhzFYirVmKk31WQQE69l8l8BVhoS/RdAWk+27OTzhtnzb0uPYdcfSStIHD7lPJK5dDeehp/jnbBZcl7LmuONel5ysJnRyt5JN3Sb+8nboMSD/z2oJCXsVwu12Z11f7pOfI01Tae3m0w7ZL++2w/20PfHgTgKgL1D+pPKtvH+mpcYl2VB5/1N1cwsFW1lerpzyZ5ed31ScFC5au+pP9c2ZjGGAbiBfKVtvLLfOVEa20tyCf5aHzRuQQ6rHnKvqTrm5KPi7rGPHv+XSpzGz4GDRp0e9MIEGxIyUm46Px7wPwiaCowcZE8VKDD/ydQMEVVO8zlP6XrDdSbOIcV0dnZps69fD0okMBLNfhXoH8b/qYcjAocVPm786/f/ow7pT1KK2+m+Eg8pTK9/J5jyPLn9hV/xsFUlZ7XeK/XB3p9zJ3PKu0cAF2lT/cSqHXA6Hl5nlUZc9qqR712nNMH/NpF0pzgwdSzlQ3xNFP5tdbXralr55FR9ayv8rgIOg+fCSATiPb+Ow8XBT5vBFU2a1M/JOnolJ5zNU+1wjLxqzw8EMwAUC8YcBF0M3zFQYPubzT6zHwaAYJz0hwnSE7HReTHNNsoegKNaWnjtkQAkPZBktKsZ49vfjvQqGbdekBI9xOwopPhWxh82brXxZ1on7FJy61JCXxyRi49S3DkoLGq1yaUnM6Uf29VRbW6gN8OuNm+mt2r+tLe3t4ZfpgfZeT7V5fL5Zml95R5JROuHmC/TNuIWlvfNsJv55my9BkhrYhIaVPQyfW4OgGcdXdeyJ+X5dtKVN8qAJN+k98kF+Up3a8CbVw2fJEAiH2K5O3jAbpewMBXtaRl1inwlIKAvb7N1QUOIrkc3e/5f+eLdsi3jlRjCHWqB/qnxoUeeCZ4S+AzBTK8j6kO6c0GzsdU/6hIMuPMP/uPVgssl9eXxPN1hdpewHTKJ61gEjEA0rNtLqdqK0FV10oPqmtJh70vcfVBypO66gGUtN2E93TGSc/ueZ2dX60M0RsMDg4OVluJeIZKZfc2oW39v6ln/d62PsOgQYNubxoBgnPQpgY6pedg7QPx1N5oXmN+BCh+T4NaWjbtvznAp0Ej1Y/PcABmfehEEewkYMz/U2C3Si9gmZZHEgQqnZ51ECS5kWeXrSgtcyYJ6KZlylXb6p6WpiawzGWVqQ5+PTmCLs/qv4NUylG8Uy6q71S7siwCkQq08z+XDNNZdmDOsqkPAgVpZikBi3T4nZbyO0DWnl0PLqU6cAkyeZbzybS6rjRuR+hgU1/4jIIcfCVYz1nmNf5nO/n71pm+AlFTtk/fAk0JWC2Xy7a3t7cmw7Q0PtmOKeKWAAfE1N1q2wztL3VssVi0/f39FZhgnalj3qbOB79ZNsEu5VS92q9HnpZbV7jMu6KkU359CrhSpuk6gwRehgcG9FvBM9ddjmE9kh1xG+gy4/XW2tq2AfYdgv+jo6NVgIABA/94/mkrmq77apnkM6S6u21mfm5f/TnZiGQDK/LxS/2F5adtFUrn9tifY9vr3u7u7pnJAOdH7cyxXvbm4OCgtdbaAx7wgNZaW50vorMJ2H+r/tYLhFTy9XvJPlR5zyl30KBBdw6NAME5aI4jpO+egU2DtH5Xe/Gr/Ka2DiR+fGA5zzJbd76q5ZoaXKv6pfTVwMdymb6arfW90wnwMB0HcgK0CjS5o1TN1qQVBElXHGjSufLZoiTrtF+dIKanC7qWgB73ovO/6kA5EUBIPkmGJA84Vc6U8q32mdKZZJCIQDXJnvxS3sxfIDU5qyTxxjcfOMBWOumY9NeDfOwzdGITKHEn3vuN660/r+dSO6UgQS/QkMpkedRHD1AoncBTa20FmtgGrIOAtgcjGDhKNqUXpGAe/F+l03d604vbF/HLdjs5OVnNFIuqlRneJpQF5SZ+UsCBfSDZJtZdee/s7Kzt4U7pyJu3K8ueCg6Q2I/Y/slWtXbWDiZ9l0zU7xP4ZpluC2kPvRyvB20Iy9FBhFwlcHR0tHqTh9JUskl1FJE35zMFTLwelf5XdrzyfZKPkWwTSXml1REp+NDa+rkiXh8PDEt3lF5BAvaLJGcFfvV7Z2en7e/vr/qv3nTg+Xndp2xKT1abpPVxoeqvvDa3rEGDbmXqBeRuJg+3C40AwYZUgZht89pEWebMYtwo2iRowLS95yqHahPqyd6dOA7+fLbnlFYOkAPuirY1SByYCf7dOapAKQGWz/i4TPi9KdFBdtm6E8JPChB4niTnkzJhIMid3Op5L4vBgCmgwjy9zFRG4i0BVPI0RycpQw8aqIz0HEk8uG5VwbMqH/KUZNKrB6nnpCYAI9Dk5QlsKd3cQOQUTdmMCmB7f0jPiUfNeLaWT4r3/KaceMrBgy1pTKnAJu8TMDkfc8ntwFxg5DwmvpV/WhbuYIn93rd9+LNT9dmEPKjhq0W4ikBbC9KrMKv2qvStp6NTwZmqjbcFq5tQGrP8Wgq6+4qI9Izyr3ysJOcqANba9fFQWw18W9hFUAL51f055EGQERQYNOjOphEg2IK2cYa2IQee1Wz8zaAeyJ+Tlo6QPlxCuclKgqlrvpS+B0Y5izcHCFWgjvXk9xyQ6U6dnksOCGfI6NwmHkRcPunXEw9OyYmUM81vOisu0zmy9TJ7zi0BFNNKz3zpp+uC0miGyfWTVC13Zx0re+Dglu3rwbMEXqYc9kReZ3eIq7T+DJ1dUjWz7jKe4rOqn2yDr+4gqE3BIA/SCGSpncUfVzekgKFojq2t+m6VhtccZIt8ZpOrRrREmWcHVH3FwWcVxOoBfK/T3HHP7cGmQYAk16k+NmVfejaI53IwUKbT53t5ppUoIsqfebBNfAuJnylwHl8j9bFKDyqaM8aIfAzgNf6eCqq7HUlleHneFj098mCABx59dc2U7UzjDVeD7e3trT4KaPqqIq/beakKHnhfnxtoHDRo0J1FI0BwDtomOttafp9uukeaul/ly2c94jzHOeil88G+Fyygo6Rld7u7u2vOURVY6M0yJRCqD5dou+NA/k5PT9ve3t4ZeYnSuQQJzHGgrWY5/LnK+eyBDS0vVR0rufEZl2NPhk7ueEmuvkw/OSQJgLpcnOdeQCfJhLPgqit/t3YdWCmtgJf4F+hyZ5COJ7dH6P3WyXF2QFMt89Xz/lpG1a/qE2nGy/s2+wBlnnTT28RB0hxgRx2YAmqUFdMQFCl4yHw8iKPVA2w35cVVBQwQsF4OfHoB2F6f0f+kC94m/juBXw9UKW8PkJyenq5tP2D7LpfXl67TxiaAmsCC15UgtycT71OyT+x7yQ6zfNaF1zi7n8omr2n8S7bX07Fv6r9kKJ7SNgaXq/L3NmMaP2cgnUVQvdqzkr/X2X/3gl6SG7eMkWhrkmy51N75qnhNbcU29H7gefr2NufL+9BU3ZWXxtidnZ3V1h8v0/Vnsbh+3oGe0bkiyk/Xr1692l3FU5HLbcq3q/pyNfYOGnR/pvMGXC+Kh9uFRoBgS6IR9uu9Z6bu0RlKzmNVbrVPWL/T4F4NEu4YJIduDnhzx8SdIYG2/f391UDsIEn5OIils5aAEQdygp7k5PreXwf75KNaJkhAKr7mLikkEEzOgvLhYUuUQzr93OvoQIhl0XnnwXiUK518P1vAV2yw3Ion1+Hk/Pp2Ct5L3952vCZe9KYDLikWiJFjzlUlko/2j3KA0futxQOBK3mhw+888Xm2g8jbzQc4ghE+L54dFPIZ5uMHrDEIMacNKyDcsxlsAwdYFSii/Ljc2ttZ13RyuB/86Lqt3wQ5bMMeJXDq/KSAS1W3tMKBdkWy8xlQPkdw2TsnQ3WlTZhaJZXGDV9N5IEC1+0K+LkN1jXKzfmgnJmP59kLrvuz7GuSrcYuyTURAwjSP14jKFRwi9sHWrseIGrt+lkRU8EBXq/8BpdlZVupc7qmj8ag3rNVIGlqAmPqv9eHvPoKRB8L2CerMth/ybP/1v/d3d0YgFgulytfxm3s3t5eOz4+bq21VXsnkF8B/Oq6E8tO9aKMPK/k7w0aNOjOoxEgOAdVA+Wc51qbt0yPDqGfaj6Vf6I0IMylnmPAby63o0NKB8mDBQRKzm8FRBzEcZZQzn5r1/f0ukOpfATUUrAhlZ+ADgGAgzavjw/SqT2SM59ABj+JHLQ4fwTLSfaUr88KinwFSQKLyo/3vRx3lDhjn4BBlT8dVDrXrIPzLhDAayyDy7zZ3j7jSDBAYhv2+tGcvpnklfLxdhF/AsHJMfR+VfFUgdseiKued73wIEElA5+Bq5x17wNqS7ZjD7R7XVwuHlCp5EOZVsEv1o3tmHRbh9dRFiJfOeC6UumnfqdVYRWI8jrq4/uu2a8qcOKBEPKb7EAaG/hbupDaONkrz5s6wyBikqH3/xQY4CGeajt98x4DNr1gmcu+IrcZIh/zenKkTU5l98BmNYFR2ZGpOnGcp255EMDtDHUr8SnZ++oPBiB6/o73a38jyXK5XDuwMMm/R3P8P6bdxtfbpIxBgwbdf2kECAaVdJ5gglNv9qZHmwxy7vz1gJg/w3Ju1ABZBQcqp6Unfz47x6Ga4sEpAcQUjPD7c/nYlnq8ttaf9ZCsCDbofLtjmWQ8pU+8loDRlBOfytAzXKXC68kJ7uXT2vR5JpWjX/G9TXsnvU1tMfWs/6+AG9vSP1M0VT+XZ5Jfrz38evW8t3nVF0VJlnPq0qMqCNTr/94GN4Mqe+6ynALG+vZPa2cDGB4cYICAQZ4p/U6rfO5LSm1e6bMDX5Hr77ZjxNRzHtxReZXNSDbVaa6N6PVxBjWmVhcOkD5o0MXT3PH+RvNwu9AIEJyDek7qps+KKgC5Sf5Tg+9FOPQpP4Iu0WJxdnlva2f3Z6ZZkt4g6un8lXA+o9ADdvze3d1dLUuu0k+RHCRfqkkHUflNzaCwrXxWNAES3yKwXF5f/jsX3Oq6HBm+ds+XCtPZmSLnYa7TNRdIzQEqSc8ScFkur8/kqX6Uv2b7KHcBAS09VVncAuIrGDw/BqvocOs3t0Ew+JBWWrjTm5zVxEcCVKRqb7LkwMBLFfhy3RU/aduAky+z94AOeVTeus/tA1yeXK22qGTAe74sX3xwxUrP5qayvX+pPN++4ryx7Thr3aPUf6l/CSRXWwqYn4No9h/X9Soo4WX30lTXmH/VF1L9E7ikHeCWAMpaZ+xwe0cKHHD7QKXvHsiqlu+nZ6dAJutXAfeki4vFIq5A8lVS6dWcaWVK4snrPzW+eBq3A5Rdr//4dkO1k9tbDypMBUU0ju7u7ra77rqrLZfLdvXq1ZU+9VY1VPLZ1P9Mz7JtN/UzBw0adP+mESC4IHLj2nPUkyFO6Xvl9O6n7Qhe9rVr19aWzfXA/7a8EFzu7u6u7cvTFgO+85mDcgKjHNTdyUzbLzjAUw5J7goO6Ll0QJp+92ZfCcpFTEunODl0ScYVOGHggMGXFKBIDrGDAKbhAYRqP9/DrU/a/9mbnU71q3SpB/Z7gMsdSwcp1AkPoPBbTp/OyxA5KCbYrMCxA33Pi+WpftRttjeDYgLW1Cs68w7CCOD9P8G0O/xKm9qb/LM/i1+2Fbe2iMSjn9eQyPs15U0ZOYDlCgx+q/3Uj/wtAuJvijwN+6QHMJkmBUK5LcrtHwFmFUiQDatmq6ULCfhUdWJa59mv+atHWXcHpskGzZG30iWg6/w7AGZZaRx0faXMlIcHAXRg5MnJSTs6Olo7QNPHALUPv6eCA359avsa5TPHv0jlU76sPwOTfDYFNJgvt/Xwud6Wm179nHy8cH7Ik/sErkse+PGgg+uWy8T50hkED3jAA9rOzs4qQHB8fHymfX1ygb/nAviUbhO/w/+PwMGg251uBT2+r8vfhEaAYEvyRnYn4qLyd0clRbATH8qj5/B4WdsQeVJePkjv7Oys3gUsovOaDmJy594dJa9bCiTwVWBVUEAkB1f7s33WrQdinTxtchg4s+i86dObFeZ/n6HmDCvLc8Dsjo3XQe0muRCU8ll3sB0QVDTH4XHg5Pc2IXcO9d+3ADgQSFsEEnh3x1GANL1JQO3rs+Gt5TcCOF9+OCJXpbR2PVBRgbo04+V9S4A9BQiq5+Ts+r7cZJdSAIWBBcrc7Vdavs0+n15/yW/yIR3XNXfOqetJZnNANeVHvWO7OA88E0P1rWwGy1MevZUYDpRTMCLVizxT31MwynWeZVMW3seSLJ0Xr38FhlzulJF0JAUz/n/23j3Ytqyq75/73vO43QhIg/ISfCAobwmUilYQAoECFY1RsIxIEK0oKSwERFEJL39YhYoYDJRWtXaApDBVRKOJD9BEDJLEgFhEKWOIFC3YSPEIj+57zzn3nvP7o+u772d/z3fMtdY+5z5O9xpVu/bea80155hjjjnm+I75WAoSpXz5Vhs9x5UD58+fbzs7O8vfreVVY94P0rhcjXki9i32W9d7J+bZG9s8v2o1DG2+67hkIFIgzkk2UeWNGW+9L7oeyYbpvgI6vbx87FaAwF8V7LJJPPGanj9z5kxbLBZte3v7UCBwjF6PIW/foeuulzPNNNNMc4DgmMkBR0XrGuEp+U8FUFPKXZd/H6yGBqWqDkOAf13ejpJHNeBWVDmgyZknJeAvpys5fAQ1dCLH1MWdbK+nP8Nyeyst1iV34tZ1qirH3GeaWZYHVby99e1pPKinsis5Vn2tAgpsU4KK5Li6I5ralDL24IgDSSfKr1c/EgMmrFuv7ye74UEI5u3Xmd6BWCrvUlMFZj1A5G9Y8DyS7UjgPAGEHjCr2jPpTVV+arMx9nasTWadhvjS9VQvty20Y56euqN+Xf12XiibscFU/305qDdeJF31e0P9meVcTmK9ekGP9L+yrxV5P04rJMfyPCVtap85ADDTTDONoTlAsCZx9qO1w8u6U9opeVbp3WGfCqxJ1cA/hl9PMzYg4c4UtxpomTRnwap8BYx78vaZLubpxNlbzZxXMw29uo0l6UqaRWV+1KnkRPo1d5B7s9+SNb/9nj/LegrUOaCeSpUOujPec1LJ19j8Kf+08qICunq2Wnngck6zqXQQK530ejmgWCxuXebMma1Kf9hffHm5O/IecPAVBGkVk9K7LnHG0Xnkqgk+n3jotWnVn92OJHJ7JJvkpBUZLK8KBJFH/3BVEPXI29rlIN74SjzxmgIrXP3Ts2Ouy1WQIPUh7zssX3pZlZlsUS+o5Dz4+Otpkh30bSe870EifrNuaQsN5eHpnXzMZPCgl47587qviKJsWEbKt6Iq8DSmL/INKW4DSHxbgK+CGOJtCqBOlFYCKW++Stjth+TtY2vSQbeXrCd9jK2trba9vb3MS/05yWIogOFEHqYG5Zh2DijMdFuhni9wOXk4KTQHCCZSz9D2ZvaHHNqh8npLMHlvzOoCBxEeRU9R5ymkfHwpcHJ2F4tF29nZaQcHB217e7sdHNz6GiCmT/LyZcDJEeK+Xw78BETenovFxbMIEvitHDrSmNkg8cL/6dlUnteZS8n5qkcupU0BEz9PwJcPJ6edMlMa7c8fcvArosNFYJjy8jRDeSbnKIFaEcFX1Y6LxcV969RnbaPh+Q3sn3SE/SBD5uMghbrLuknHfXZTTrrKV9sLMG5ubi75FF8i8uLtLHn1bIxkQhk4eBT/Aq5+KCjrSr56+qU6EoBzWX7aGuArCLj8ONnBBAiGZgG9L1JnNJNY1bm1i6Bwb29vubd9f3+/7ezsrAQ0vL02Njba9vb2Ui9ZBtP6MvtKtglQSz7qL1yqzzSsO2XL3x6sSnJ0Yn4M5jFPpUvtl4IDHiTgGQIct9L5DgocKIiTdNjH2yoNf6eVMZSTA8pqvOj1HfJU3e8BYV7zusp+cfUL//uBhwwqpqBQ8lm8rvztfZi2ItVV4xnvM3AovlKQ3wNR1EEGBg4ODpZnEZw/f355HoHOrki8V3J2+aT0KY3Xu5f/umP7TDPNdHJpDhAcE1XG2Qe6IYNOR9zTk5LT5r97vPbyFtHp0386w5xprUBDChDougZEDdo7OzsrfPEZryPLI0BKwJHvIvYZ2wSudM1n3nryUtljl4qm7wRePf9KLl4PgVUCEu619iBACg6kIAHrmPh1oFHNDhEMeICgklsCED1drpwqlpue4yytt4V+S74EdpKX7ulQTsrYAQD7kFbSOEjnXnTyzwCWrp86derQqdsEzDxLwgNE7tAn+0I+VDZ1nkEH5UmnmWW57IecfQfiPV1xOVEOSuMAjOl5cKHqIx4oaw8QOH+ehgEMBggqO9BaW4LO3d3dlUAB+XeQslgslgECAjABW+m2g5Y09qR2Im+UZ2urOpCCAy4vt0XUfZcpyfNg+7jNT7aFeuhlsl/qHle6SY4MICtA0AsO+KoLl6f3izHjhPPsAT/nw+vu+jbW53BdSeVq3KEtdb5pF2hPqkOUe/5GJbvKX2ptVV4E/d4+bov9nBcSbb6PndLNM2fOLO218mLQrzemVWOY81G1ZTX2pTzmwMBMM90+aQ4QHDNNNabJUPeM90khdx7SzKgGbgEaLq9juipfghg63g446SBW7UNnxdMmh4z5jFm14fVO5SbnSfeq531WmXVIM/IJ+Fcfl3GqS6pDrw/0nJKhclwefi0BCneiKieR5E5aqhMBl5xaActKzt4e0k3/X80AOrjwulTfXFXisvBZ3eQ8u/6xf5EP6hnryhk1D0Z4O/F/Ak5j7GIFElI/8t/OhwPgnh55AITXXI4qpwqKOViu3vqSZOU20K/purdXsiU9+SaZsb0JQr1v9OxLsrtVn0//HbBVui3i2KT/rCvrwE8C31WAIJWpZ5xY52rcdF1Kz3teU8j1Kf13Ges72SGN76Jk49IKnR5/Y8aLqX6U+yq8TjudAhbel/g7jQUKIm9tbS1XLVSrkaoxbEw7VXlV92ea6bZKY32IS83DSaE5QHCJ6CjG9yjPTXUEplA1ePUActUh0yBLJ0xBA3fKxziW/J+cQ3de+axf457K46bkyPl916MUJHDqge0h3UpOX+V0JX1Lyy49jwSgek7PEJ9D9XE5VvlXADvl5TImiJdzSKdPMuk5sJ6v9D/NVDlvCUSQH86KcTY0vR5UlMobK/chXaOj7PYjzfiOAUGe/1Tq2c9efZKdmSonglAGBRyQVnz0ALSDF4ExfXOWP82aktcx9U+faoyo7FQCob3nquDAEO+UaQoGufzZDl4+Z5U1bgxRz08YMz5M8RXGtKXzNUWPK5vkeab8h9qspydD5ffqmoISbtu5YoF5jqmzE/sEdWSxWKxsUfMg1KUAFScJqMw000yXn+YAwRo0BsCMve9gqxoQfFnd1IHpqINBb9liBZa8/GrPn+qmvcjnzp1rm5ubcfaLgCvxxv++TFRgS+QDsDuBBE+VY+COQ6rfVHDjTtQYB1LpU1vQ2VU63wrgzrw7Xr0gAcHoYrE45BhXgIbL4Fsbfo904jU5nT1KMmM9CU490JGcWZWpZdvKX46elm+7vlSz+RsbG4fAYNIxl7s7q5zFVXnUXQYO2A48O8BnvVKdvV+7vrqtpG6pj1f21MGYB6xcr1N5nqfb1xRA0v2kx5Rrmjlkn/VrLh8CUJXHZepaLcAzMXx2mm3jcmKAiekJQjirn2xgkg3lqt/avuSvRfXfVbt426V28wCMr0hRX3GZJNvFvsNAjB/6yFVtbBvXu8Vi0TY3N5d87e7uR0qPNAABAABJREFUtsVisbQJlW32FTiVjlTpe+OHX0u+SBVo4e8KyKe+nlZGuF0d64t4UJT63QsopDLcpjp/3odpc10ODLgqbfLP3La577KxsdEuXLjQNjc324ULF9rW1taKrmg7yxTfLQVeevpPuVXynGmmmW6fNAcIJlIPCKfB1h1SUjLSKR2Bbhowmc6BX9qX2KMpg7eIg6TnJafhwoULy32uqUzts22ttXPnzq3s1XMnnIOs8qNcHITRofMZUwYJtGyXTu8QCKkoOXgJhIzJk7x6XZWv111Eh/L8+fMre3P9eQeGKttBml8j70NLa72s1i7uNa3AbCrDwUKSX3U9OVBef9bFl/MnZ1+ATrpOILa1tbVMK/1j0MAdUwcwOrTTgYsDOrc3BKcqk+Bzb29vySPPVGCgwEE9+7qc16EAgTv2bPdkl8T7/v7+EmjxHvOt2r0XHEiUbCnbme2RtgVIZkpDPthnvEwCTgUEdBAhtxMoHbcWuE7SFlZ1VACKPLZ28WyC06dPrxzCxzTSIwdC1HUFfWhHeBaHP1fJv3fP7XsCtXzWZU/AzzbQGORBALZ9WgWk+m9tbS3loDQ89DLVa7E4HFBVWSqf/cvH82Rv2T66z1fgVuQ8UqcS/6oDf7MM7wfJR0jkefhYXwUHKp1h0IK6kIJ7HiB14O9BAuWva0mWvlpHZciua0JEZxKwrVIwipT0qWpjH7N7uuBtOdNMtwWaEqC8lDycFJoDBGuQD4pHNaLudPqgNDaPMfdVztBAz99D9SO4cT7SAJ94k6O0WNz6VgP9d8BE59MHMZ+JFnGJtoNRkhxGOgkc2FmHSi6+TJeDe08OlaPnjofSpqW0lIM7DinQ4dQLEDAv/nYAn2aznT8Hit5erPOQjHtOJ8ExHS7ed/DjsvA6e4DAAyYEljp8ijOn1CcH3i5z/y+wkWZ5E3DwQIjfV9DOHWBvI19JoP882yDN0FWgz/NhnxJxRlflVMGe9Jt1rdIn8vycR11POuGAoQIyno/XVYdkenCAASsvm7pI+yg5uI6ynR04qAwfM5S365XsKg++5JsTkj0i/y6foeCBeHK5M7/KbrkMXM48hNDtJfN0u0FwuVhcnP2t6ul1YYBvKCChexWle2P9lF6wJbWVB79l8/y55B/42OF5sz7Uux4Adr54r7KVziPzT75YChL0xjv+F/iXn7GxsbEM2m1ubi7T7uzsrJzNdBQSr5W8pwReZpppptsPzQGC2xgdl0EfE+lvbfzKhDHkjmoCDk4Ef/rP6+tQWonB8o5CCWAfJaLo/KTAQY+XKlDUcyJ6AYOpVPF6HDo8hR8HWMmRZbqh2Rd9J6BCRzUtZU28tbYKJFzPPQjR2uHAo4N3AZAU5KBupkDQGHmm9MleeB8mEPAAxKWmIVBUUQqIVHJLgZTUNkP2z0F6CkxU9nConuwP/nwFhhywJz1dh9Z5tgroECD25O/P9fInn6xzAo+XQ4d7dFz+wRCor8gD6K0dTTem0phypsjHx/Cxz1b9rbX6tZwzzTTT0ahn0y8nDyeF5gDBEelSGO8e6PalbT3qKeJRwZwGen2qmVxf7lh1UJ8F0xJbzYb5kmz/7uXp+afZAn/e33/tddFzVRtU4JDf66wUaa2tzFQN1c2X4fqSVT2vuvq7ngU+xwRufAaM1/3jsvI25bOprNb6YLO6PtRfHWhLLg5etTKg0kU+t7e3tyJ/gjm+irJyGt1xVP24DJZy9+CGX5du046QJweb2lstvfP2IH98bZ8HKHw1hb5TQEbPVitllC+X3VfLvyugqmtcMeTPpdUeIrdTyje9JtIBv/Osa8meUL5J56mLrkcMAPkqD8qDeq1tAtQT6nOyNb582mf4Kd+hQEXV3p7e9dqDWpKp0lRBGL5elOlSe/eIeUsWW1tbSx1hHtX4UOlxr8yxPoiD2dbW81/c/qexM624Y3BGZVMPve0932r89HRpxR2f8wBWGktdZyseE5+9MSs9731FuqPVBbQL6wCcIR1xG1DV5SQBm5lmmunodHzTv8dEf/RHf9S++Zu/ud3rXvdqi8Wi/cZv/EY3/R/+4R9Gp+Uv//Ivl2ke+9jHxjTf+I3fOJm/o4DuZGSrJc/pfu8a76VyEnjo5eFEvuiwKu9UbhqUEm8JxO7t7bVz584t3/3NdMpbA2larq1vH+zd4Xegp/K1F5h7UiugwHrRCaocQJXBAIQ7r8wn8c1lvf7bl4U7z2lfM/nxd30zPV/91+Pd6+5tnOTnOpYcOLY9yZ085lmBGndGdW9jY6Ntbm62ra2ttrW11ba3t9v29nY7c+ZM297eXl7joWSUOeWjd9bv7Oy0vb29trOz086ePdtuueWWdsstt7Rz5861nZ2d5UfvuWebqE5yGskb+RNPOk/A+6f42dvba7u7u0u+dnZ22rlz59q5c+eWfN18883tlltuaWfPnm1nz549xJvvhedZBuSRvIo376t6trW2zIOBQb4ObHNz89DHt0m4jaDuJT0Qz+SR9RBg9mcPDg6W8lTb6iPbkWS9u7u7lDc/sjXUSa8HeRN/+s0l/gwKCACr/fzDoODp06fb9vZ2u+aaa5afM2fOrOg+z6xg2eQr2aN03oUHE/Tx5xmcol6zjrTZ/Ei/pctnz55dkfvu7u6yn6b3z/fAkfd39Vm1Fful8z00XjhV2x3GADe31V7PsXmlAAfHEFE6xyH5BpU95j0vn/lxkiKNR36d+frY4mNUz2YoqMnxsFemU8pPPJw6dWrFfrrNHNNOVXmVXMfIfir1fPm9vb32oz/6o+2hD31ou8Md7tDuda97te/5nu9pf/u3f7uSx87OTnvuc5/b7na3u7U73OEO7alPfWr78Ic/fCS+ZppppnF01a0guPnmm9vDH/7w9qxnPav943/8j0c/97//9/9ud7rTnZb/v+ALvmD5+9//+3/fdnd3l/8/8YlPtIc//OHtO77jO9biMRnTCpCvm//Q80NBAgdQY2caxm4tII/JsUkDu/JPexQ5OGumigep9cCez0wwXw7++igvzj5wFpUHuTGfHrhV+QSnvWCQnukN/A54XVZsY18xUK0gEB+uD5wlb+3iuQ0uz/Sfebmj6bKrnD6vI9ubebmMesQ8qmsub4ET50lylE7ogCmtDvA60TnkjLLLTGCCOukzxQxmsY+wL3E2VGVw9tT/K43P6vOARQGz/f395Qoe6qu3sfJL/SS1uZ4ncGIfZR+hPKvfeguK8kkgwHlaLBYrJ+9TPronebPdWLbkzrb3NnTgsru7e+i5KvhI/XBZui1w8NTaakCQ8qcMlAf1wXn2oBXL9zMImLfS6FwC6mkK9LHOXl8nrogieNQ9nivgq6f8t9twL0d8JXLgyj7lgDwFUNO1VD7Ti2gvh8jrXNXHyW0oZaxr3i/IZxqjpwJQ2kxfzVLJzeWaxqI0pia7QRtcBVcSP0MTLiybwaXW2vJb55KwTswrjbv872VWlOzMlEAUqefL33LLLe1P//RP20te8pL28Ic/vH3qU59qz3ve89pTn/rU9u53v3uZ7nnPe177rd/6rfaWt7yl3fWud20veMEL2jd90ze197znPeU20JlmqqhnYy8nDyeFrroAwZOf/OT25Cc/efJzX/iFX9g+//M/P9677rrrVv6/5S1vaddee+3aAYKj0NhBuTforUsy/uRh6iCdyAfAsU5HRXRwhzo0naNetN7/J2e74oMDeHLU9EmD8pQ27D3n9UvOyxAQ97wTb5Wjka65U9p7dgxo5LUUGPB0vfYe0oUkT/9dBWD0v1ouS/JVIHSsCci5XDbpvINd8sIggwcj3JEXLy5blc/lwSJd86W6zh/z9DLG9k/n3fVZdWWQI/XvXhmsA2VJIO6gwfs480lAj/wl4MoPaczZJ5W8kpypT0P2xWWhZff+vIPCyu6kexWR77FjUwXS+OEstgIcKsufnwKYnY9kUxloqeozNiB/OYjj6FgweZT769CYPtjaYdDsbTs0NvHekE54oH8KoK7Ga1+VdlRKNpI27VL4mz1f/s53vnN7+9vfvnLtda97Xfvqr/7qduONN7b73ve+7dOf/nS7/vrr25ve9Kb2hCc8obXW2pvf/OZ2n/vcp/3+7/9+e9KTnnSs/M4000yrdNUFCNalRzziEe3cuXPtQQ96UPvJn/zJ9rjHPa5Me/3117fv/M7vbHe4wx3KNFoOKvrMZz4zyMMYQ74ueE7gdApxACIPPihMLcfTj6lfzznlfx9002yAvj1IkJzABLCYnssCfRbEo/eprasgwViqgE2Si6f39vW6Vvk7oHFnQXVKwDG1o/Pjjk/lqFR59sBocmqG7pEI/Mhz0uGqLpW+e19L9SY4T0tj+Xxa+eK6zUCBz4QlPtnGnOHkrD1nlDnDPBaUJ7klnUt9muV4uzqY5QqA1trKCgjO5rMfV6tsEr/+O83Us/1of9L1JDfWlyt4UnrdI+BNS5uTnqQ2SjZDK2kIcD2oQdn7ayurMYd5656vYEq8+wosfXtb+D1fXp5sSgU8Wc8xlPS0tYuvGUx9twriJPn1gg1TSW0+VPf0f93y1vFhhsad6noKHLR22Mbod9LVRGkcYfljwbYDdPY7t0fe/qkuvXE0lc3npwQzPvvZz674w9pGc1T69Kc/3RaLxXKi7z3veU/b29trT3ziE5dp7nWve7WHPOQh7V3vetccIJhppktMJz5AcM973rP98i//cnvkIx/ZdnZ22pve9Kb2+Mc/vv3hH/5he8xjHnMo/Z/8yZ+0P//zP2/XX399N9+f/umfbi9/+ctH8TB18KRRHho0hwarsffXBf0cqCrANXZFRLpG55L56bqcUi0VTUudPX/yy0GYeerwn4ODW183pOW33JvvIDkFKCpQkORVUXLgxaODl9baIdBDWVZBhCSfNKvpoIwfAjo69RXoSOBLlEDm0FJMrw8BBp8fCg44aGV7ao90a23l4DKRvyaTh/KJB+eRTqAHI5Q3X4mm+qidtX9ZfHFmyWWddNNX4jhwoty0TJ/gW/1O3+7UUg8Z2PB86AA70KR+Ma8KKHNGMDnUkh3PM5AdUV66LpuS9FQ8EZDzHsGV7+teLBYrr2lsrR3asuD92seG1H6677rJtq340Tf11+0p28zzdhBOe+pBmtYO6yr5YLt533DdZH14L+kxKQVNKA+3507OmwcNPPjg39JhyYX650GcHpgVqf9VgZNEHM/TLLrXj+MDy+/ZVH/WbTDHdm+LJPcqSOvt4EE359FtTNLxNEal//7bbb9+jw0OeN3YfxRQ4laDdHCy55HyHirb86iCVPp+0IMetPLMS1/60vayl72sW+YQnTt3rv3Yj/1Y+67v+q7lVuGPfvSjbWtrq93lLndZSXv3u9+9ffSjHz1SeTPdPmls/7zUPJwUOvEBgq/4iq9oX/EVX7H8/+hHP7r9zd/8TfvZn/3ZGCC4/vrr20Me8pD21V/91d18X/ziF7fnP//5y/+f+cxn2n3uc5+VNO7UOFUDqp5zY5wMc5rFcCc8DbaJL3cOeg5Jb1Yngc4UvU8OtwMk/eZsXpqR0knhfmBYlac7sqy/AIRkyVm4dBBfIgKy5LSIestWK/1xWTgYpDPvMyAJtJEczDEftRlBcHLu/XyCBDJ8dtZ59Ton2SWnrHLiWSfyXs3SiG/VRYGiU6dOta2trZXgXTq4TGXoHdYOFKiHXiflLX4JENi/JDut3tChiCrXD6XztqRMErDiIXXpXduSh84BOX/+/MrBjOTDSffVX6nHkrmCItzCkAJwLkvXcw+YeVBF5e7v33r4qYNb9gkCc/+QB8mRK2uYt9Lq4EHxp/y9T+g3y1bgMtkJlc8y3R5WoNj7sutOBZwIqF2G1AGmT7aI+XpbU8beN/xQVektt0J4X0jA12koQOD8MT8F0Hw8Jw/7+/srQI918fqlsp0Pr5fK6JG3gcsp5Sm+kh1VmjTB4f4NeWeAhMQxxccJJ1/BUgVLerbfx1fajuS3eFukdlh3hSf7CWXOoLDsbs/XcEr3eteSvJMf9/73v7/d+973Xv4/6uqBvb299p3f+Z1tf3+/vf71rx9M3+vLM8000/HRiQ8QJPrar/3a9uY3v/nQ9VtuuaW95S1vaa94xSsG86iWTfWAyhRyh2MobWv9gMPQs2nm4Dh4S88JFFd5cECiI8p83LH0Zdjr8ssy3XlIIKoi5yOVP9VhoAwcYFe/9Vz67ZRmBPUtXgVKCGDZFg5wUn7OSwIJ1fPu/FVpq3yc78ST0tExZICA1/RN0NbaxZlA6lHiScDU5eOgl6DIndgKyBGYVbogXhnwcAfeATDbQs/wcK7t7e3IE8vXfQ/4JbBJGREkMJDCWXh39pNzz5P1xYOftO4HKqb+7Nc8OEAQng6i08n4XNGgspOu6MN+17OjtIseME5L8lkm+yVnQ9l+lLNvOaAMPVjqoIx18nb0IAHLSDaZh8jqQ2CVdNJl3SPqo+cxNM4kIOpg1HVuzJjmdXC5JaDuz6o85zGVx77pz46hakxO+aVgQ483Eu2FB8RSHZh3NTbxnvOS7q/jK3mbe5+k3WTAwP2VKb5PovR81c66dsc73nHlQPCj0N7eXnva057WPvjBD7b//J//80q+97jHPdru7m771Kc+tbKK4GMf+1j7uq/7umMpf6aZZqrpqnvN4XHQe9/73nbPe97z0PV/9+/+XdvZ2Wnf/d3ffQW4Wp+OMgAcpbxqFvooeboD7ZQcIX07mKqcq5TnmLq4U5AA9djypwQsEvDTPU8zBSyPpQogjvn4887HVJ4I9sbyzm+n5Oi5o+WftCqjR9X9yjGdQimA4GDJX1vpM5OJB9aV3706OyBlef7R/aqfJLmn63SUyWtymP2Zql69Nq3AW+ojY9qu155V+7L9CHqm2DyvU6/eveBx6jM+8+rtkVYeJBlU9a9++0qYqe3g4HEo/XGQ8kpL3XuB1nV4YHCT16byOzSeXSr5MEg4tbx1g/FJ38fY6eOQQTUukY/e51LRpcybpODA//k//6f9/u//frvrXe+6cv+Rj3xk29zcXDnM8Kabbmp//ud/PgcIZlqLxvq1l/pzUuiqW0Hwuc99rn3gAx9Y/v/gBz/Y/uzP/qxdd9117b73vW978Ytf3D7ykY+0N77xja211l772te2L/mSL2kPfvCD2+7ubnvzm9/c3vrWt7a3vvWth/K+/vrr27d+67ceMkRT6OCgf9LvFKdlipPC/2nQPy6HZ0y99DsBQQfWmj3TDKBm9BxQqF6LxWIFDOi/SKBIr5cjmKt4HDvgsSzxpZlHOaYkbh/oOSicDXMHgPVmfSoQ1Fo7tJx3qtNAp8xXUvC+ynJHhrLwMjkzyns+M8wye+De+fF6pHs9Z5zy1ay28vGlpj2j7vtPvf1IXudUT7cplIvrluTPWfm01aD3GijVX7+VL1+F6H1L986dO7eUp84lEKl/S566Rt69/VUGZ8v5rdli/eYMsgNH5eOv3Usy8bb2rUW+dcTrQNlUYF5pRN5vuDLC7UkKuiRAVdlr77dM52Ce4ITXPDDjeXPbC3Wk12fZrik44O3tgQIPPA3V38t1/jimS07edn5P35Xdr+rvARVf6cQ2Tnn4NfYb5cN+VNnYnk77dbYLZeArVLycKeORtxf7Aq+NyYc0xIP7VWkcpv3Q6jofv7naaohcRgy6KR+tNlJ/kg31V5X22rU3tpLS+O73/PoY6vny97rXvdq3f/u3tz/90z9t//E//sd24cKF5bkC1113Xdva2mp3vvOd27Of/ez2ghe8oN31rndt1113XXvhC1/YHvrQhy7fajDTTDNdOrrqAgTvfve72+PwBgKdA/DMZz6z3XDDDe2mm25qN9544/L+7u5ue+ELX9g+8pGPtGuuuaY9+MEPbv/pP/2n9pSnPGUl37/6q79q73znO9vb3va2Y+M1AdLkmKQZlIp8H5476ny+NwC488hBfej9sSl/L4dLoRPxnvaJKh85gHQAlL+cUj7P/1zG60uImQ/lzkMIec8HRpVNGdFB93edK+DhsqpI5bLeHgRgW7NedOI9MOPOeypTPDv5kn7Vi9/uLHnbV05p4sPLSzJLM2uVHia9TPn54ZZ0wrzPOZgkOPH6ss6pPv6sk7clf/tMPQNVe3t7h2Zt1R9YP+oQT46X7jJAcnBwsLJcm/wfHNy6n577rRWY2NraWvK+tbW1DKqp31VL3anPBPgEYfrNYIB+7+7urgQM+Pzm5uaKPJTf9vb2Slls99baCvik3SLPHoCifWB/k56wrsy/tbbCM+ubADQBOGXpfdEBl/dH8UX98XNH1Dc8CMV6LxaLZXuTPz9M0McTAk4H+zoTY3d391DdUxsN2Rz+rsAy5TYEkvi/skXsuykv9RnWhzyk7Q3Jj+D93hhAfpLPwrJTfclTsmM+5lYBm9419sfeeFU973pf2dUqH/Y/Bk85ZrDPpjHbx7ahOni/Z7mbm5srZ8PwDILd3d0VW+KyYJ3H+CQuo7GBhSHq+fIve9nL2m/+5m+21lr7qq/6qpXn/st/+S/tsY99bGuttZ//+Z9vGxsb7WlPe1o7e/Zse/zjH99uuOGGQR92ppkSuQ28UjycFLrqAgSPfexjuwK84YYbVv6/6EUvai960YsG833AAx5wyRqGTl1r9Sy8kwOTXrpqGagPXGPyG3KWCJDToOiDUq+uBIZyCPmfxIEyzWy11laccHcGUucf0w5eNlc8qBwO1pRBzzHryUPP+gF/BKlVMCBd438Hd0NyYDBApJkSBkpaWwX1DvorRzrVPTnCrreVrrlj2dN3ytdnzX2W2fVHdUug0J3ZVF/nl7PFPV1xMMeD6vTfV5aoHjqcj/v/dY3k/YrtQWebII5ARs8qwEKZ8JwGD8wInLrOK08PDupQNwYI9vb2VgCL7klOArcMNtJWcOWM+BVfflI4gV7VhxzQezrKnvl5UMPzTKCMZSQQm3SYuup1Yd/gf9pC70Oq06lTp9r29vZSlmoDBVYITD1I5AEvpVOAQG1MXaxAl+sxv9PY7PKi3NzmuMzSeJvaQvXy8ilHjnPkn+WnILrX2YEqeePYlIIDye6Rxq6QqHwe9r2ezXP5J/vqAUQ+S9vF5yqenHzc9f/MW+Wxn1DeLrMhW5/Gf5FsE99qIJuXbIbXfQzYd1klvV/Hd37sgC8/Js8zZ860173ude11r3vd5PJnmmmmo9FVFyA4aTQWgDpdyijSmGVul5LGyGSIRx/kSHQak3NTDZRj+OaAXbVR5WTqd6+synGpwL9oKOhT8Tg1HevmQCo94/VN5dL5Oyr16tWbpXeglK55GdIDBoZ0v6rLkCyUpnL2K3JdZ2CE4JfAhM5/6icJyFZySOAi5UvA56ssmN71nHUgP1zVQnAq8MTnqs9R6Th114F81V9ay1tLHOiOJQcLBCWepvrN9FUfStd68ku2PK2cSHp2lDZZZ/w9Lj0QHZd+pr40dbxwe5JoTP2nymiqHfRnjtuPGuu7+Aw2+5dPpEwtO30fl67MNNNMM42lOUBwBEogb8gJdxozkPfSsLw0g5DSHaW8ioehenKWyAd4ggYOir6Mrxooufw/ORwOrIacT84K6Ddfh8c8tVWCzjOdcAc/TLtYHD5vgbJ3B96XwFdtsQ45cOMsQjVDMxS8SbOdzHMoAJLq4gA2zdj4bCg/fM805e688b+e9cBQjy+/5u27rrNHmXIWSzLQ2RxcZcDVIK6HlFda4i/5EpCnffzeH7xtlKeW/UtGDvKp874SQjqloI3qnV7VSLlQF9OMdgpKcImxtkuwHv5Kugq0pGX2/O6tgEmBlUoHvc10zWVK/ec9t6/pk/pV0nHdd7vBLSKSoY8L3i7V2DLUf1JfHkMegPHy3dZU4xp58N+JV19Nk+q9jhyYjvn7s0kHx0w0pDaqgl69sWnsuNULqCXeREM+DQOaqU4pL/cplK7q62OCBv68bJ2PYbTHxzUh1AsMHXcgZqaZrgRdDbp8pcufQnOAYA3qDd7rND4HBY8+DzmPKQ8+5+mqWcehAd6BDfczM78eySlUmWmpKEGB9sA6iOP/6lAspnEHm8uHfasDwVKasXSgoXonwOkzbkrDtL6/1+uXHPDUTkMAIj0z9jpf6eeg2Z1aBmscYJBPkus4gS/r7pQcrioAo28eqpb4U/kskzz7cm+VmfbQen+U3Mi7AxL/zbwclDo/rbXlnnnWScv8+eo/l4sHC5wE/pkmgamdnZ0VAKmDti5cuNC2trbaxsbG8jv1DdcrpaO8tKWA75TXsnYPFuqaQKlkxrbz9mKfTEu1lX9qD7YJbY2fT5CCEiIGDyhbt1MJgHjb08akgJgfcsn69wKZ/M+yUwCM8lI7sb28bl5Pgjbm7X2/GhOpP0w3Fmx63+TWDwYIaAPS88me0PZza5s/7/3S06TxPvkEbn+rulX1T+V7e0wFmiqXdWS79Xyr3riv/0NjicryQJU/6885z6kMbtXsAXmVJdKYIhsoPZNNYtBy7BiS/p8ksDLTTDNdXpoDBMdMdGSrwa1nlP2ZBIJ6jtC6AYref79O/jjo9Q6OkWOtGcY060JgIPDiJ5EnQOczh+LR+aHD7kEDthfBEpcT+uFYDjSq2UA6CxrwqwCB0ldt4PnSORgKELi8qav6eIDK9w4TvKgeLl+vB9vUQXHPAUxBJ3duvK+0lk9hJ2B1+Y4JRvBAqIo3J/YX6YbPuBMEet0TVW2cDm5zwLu5udk2Njba9vb2ypkFPJdBh26qfuRXzimDaOrX/K1yFZBhn6Nj60EJbys97wBaQFN5E3jqIEUHont7e0uZEQC4Dqov+tkbkov2/sqOuV64bZFs9vb2ljOBSkc7x5ldls1+WDn9CSyyL9DGqEzVK70Fg4EA70N+zYl5qd0lZ7WTZMFzBobqJPI+z+s9qsZUfy4FhPS8B6OrscT7fQo4ktKMdFWvJKMqqKf7HB+H7K1/jxmHmHcaT5l/WiEiSuOnB0eqIEMF4nVtSJ/47VuaUpCB9XF/gcT+3gseeR3YtgwUyO7ot+QzNbDT8yuntPlMM81026U5QHAMVBnosZRADq9PzSsNDL2lrNWzxxlddnDZ4yH9rtIobx8o/QR6r1flICaQmXjyFQQVWPW86Xy7Q+7pXFZsP1+67Y7ZVOeOskiyoTPE5Zjp+UrXxugTZ+d8tj0FCyonKAWTXN6VI+u/9QzBTqLUPp6P870O2GE6Pp8Ai3ghb3ztIGeLve4OzBOY9lP1/WRtgWh9euAstRtBNMt1x5v9Uh8GpFJ/qeSdytFqBQKIXruwjgpiVLPkyZ5V+bAO/F2BC9f5tFrB27/qN+lekpvaPaVTPfwVlc675+tAqtdHhu6Tl7HXqzapxhcnBsWVphoPKgDfI9Y52d9q7KhoapCg16+ra34/6crYscz7AL/XIekpV/ZN4V3PJP6r9q3KYJ/trSQZq/dTyMeYmWY6yVQFGC83DyeF5gDBMdBR94C5c5EAxNjnj4uPS0V0st25clCwTt6SF2frWJ4vI6TjTX6SA+/AwR0+gmhPl1ZBOKUBPgUKfIYpAfUUtKgAfQIZ7iA64HJZEXSnetB59WtjnEfy4jLz7/TxrSp8xqly6tLzBGOkowQNKzk6OCEloJLuc1aXAJ9liXe+wjPVWWl9fz5nYau3dIintESbgZgUlEk6SP5oP7giQtSbjWdapuEy+UrGY/LxtCnYNvRcFUQhVcCzB6IS/6mfu51TPZz3tEpM/HKLGgMuPvb1QNQUeSeq+hntna8ocNkMEQOePb3pjQ3JP/AyqvHSgwZjlrmn4OYYGz0UGEjjrI+/HhCv7Fw1DlT/dc3t9VAwgXz2xoupwYhqLFJANdUjrWJI/I8JqEzhc6aZZrp90hwgOGZKjl5FVTQ45UEQti758mC+Aqzilw5SiibToehFm5VGs4jnz59fziIpH3+lloM+yojkg6M7OAcHF5e3CpCkd8snh0XkTjhnlFm/9D5x3//O2YAq+OBAqnJQK6A0ZpbTy01yZTrJTqCLy2cJFJNjl5Z0OzBw8mAL8+FzSebV0mp/tuf0MQ3rJ31iXccChipdAinsl9xCoGtM5/dTuZq53d3dXS5TlR1Qv6SOHhwcHFpK7iBfctVZA34A4cbGxvLjr5R0myA+VTb7AdvK+zLrTfuha6nvc1sEy05bBvzbbQbJ9YF9hO1GqgIWqY/6bw98Uf9TGn4kY8+XY05rF7dVVKsoKv2jrNQ2rbWVc0Aon55+O1XBg57+9wI1iVJQ1ts22d8EahkE8/GJwVWVVQVYlF+yzYn3KrCcZOBjjAfJe3wkPhPw5wqftKKiKt8p6S3rwP9u56tVgSmtjzce/E9jiPsjSTb0AdyX4JjD8nmdQbae3g/RHACYaaaZKpoDBEekoeiy3+NgyRnuCli3NrxCgQ75mIEi5Zf48mc8/+RYpPLp+OjjJ4/LkeUhag5GfAD1QV5tkd7bzrK55NmdNnf6OEDTIeCMjANG8cOgBwMFzrc7L+54uKOVHNPkdA4R9SbJmGnojJ4/f34lGLC3t3dob787XSTfcy39T2dYuE5K7g5SKTvJWmck9IIDPWDuDhl5kl5wRtXJg2f8dnmz7MpRdhDiYKwHjhaLxQooPnXqVDt//vxyj7/6G/e4+oGGXAWQHGnnS0Extgnb2JfdU+7+9gK2F/u3gyi2/cHBwcpBhgyQ6FyCxDdBrX5zJYJvo6jkTnvj7Uo984Ppkm0jsR1oV0S9NxTofq/vq14MoLA/sw1Vfx446PVjWR7I8DbkYZKp7mPvOfX6XW/MIu8JuKf+nfqlDvj0QIp0ndcod76tg+U4/8n/qPpWkkN6nv5Jb3sQx0mXofcvH3fJB32pFHioxn236eI91dXz0G8PtLEt2G8YtPZgRA+s85oCsn4oZTU+VTyne17foeBSj+bgwUy3NeqN15eTh5NCc4DgiKSBrgLVrR2eIUjp6HT5MrtE7pz3AOHQzMEU6jlovXIlg2oGwcHYuoOTO/C65sEDB9ruTKVZPXc+3Enz16GxTn7YYtIF5lsN+l6fCpy6TqS86Fj25O2ylGNDAJwCK7rPWVXKhvmOCWgkIv8eCOgFB1KdezKgs8z0nhcdMPHg7VM59BW5bJUHf3sZyVknbwzQyPHVverATAaFXE/TwKtAA53wJEeCCPUVBdzIF+uRbIjKZBmc9b5w4ULb3d09VG6v79OWVPX0+lAXhpwBB1zeL9J/fRPYeMDMAwQinuXg+aW6SAbJllBW6cBBB1zSOR2wxi0s/mxF1LcEkqu2GcqTPPZWNLiNS+OM65N0ryKumCEPHnz0Pkz+e3V0HlnnHj8sJwU7XR6er/cvl13yc6q+rnvSefeZWG4VhK8CDJ6mV0fpqvcjkreP6wT7ZnqW/Phvf877Zc/eUK4z+J9pppmGaA4QXEJK4KBKN5WmGHnnY10wti45KHCnR9QDxVMoORk9cOU05NSzHH47cKrSpTzWobEzAZeKqIMViJVDlRwvz2uq41I5dz0nK7XFECiryh4CclP0qCeX46QEFlLfSKtUHDQMBViSY+5BhcQfy3GQwGBTJRu2seugz2Irj2pVVbIfSdeHqOr7Y54fI+fquXTPdSC1adWHXQ5KM6a/8HdaGcJ03oYpvyl94zhA0bp9sffcEMikrNbhYWp6rerwoEPPXq7DR8/eUQenlHNUHr38Hp+98lMQx/nq+Qf013r64VsTmH/1zJX0F2aa6UrTVJtyqXg4KTQHCI5I7nQeR+M7gB8baKCTd9xKmIIKdPBY/tAz2qusbQa95dGiHsCr0nEpsoMeLWWtZoF4L/G3WCwOLe3l8mZflk156XmXH69TnsmouQPZk0VPpqw3qXJuWFfPOy2D5eoZ3yrhZXmQIDlRnCF2wKlZHb5GUjxUqwiSk8X7vaBOArtVkMD7ZAWymYZ6VwVQevk7n8npVFvomqfRTJ8fROjL2J0vXwav1QRsPy+LfZV6re0QXJbOPqw80ooRys9nZNX2skE7OzuHdFRlcLsS7UN6vaT46Z3JwT7h/cFn/l2P3BZ6vr1+7yt/3HZUgdvW2vI1mXwLhtK6jfPl1+TNZcHVIHp1ZbKJ1ThBQFbVm/2nyoP1d949n9SXnUf9HzN20x5xhRbzSbwPjZupHYcCJel+4oX5V6De5eXyEfkqIq/rkF736tF7pqcT5C3Zcl3v6bjrk4+hWg0hfyj1b7dtXPHFbVjcrjlGLkNUBTJmmmmm2wfNAYKJlAapauBKToRo7Cy+Bpu0NFf/Pa8K+CWnLf2v+GB+XALp9a+cYQ1ip0+fXh5SmJamVg53NUPvPHKWkecNaB9oaxf3P/tr2ujUpe0IKkdLl31AJ0BN2wqSM5HIneGe4zplwE/pk8NWpU2AW2kE4ljXdMhdAoatXdyLnZYzV44Yy9CHB+35cmuSrnFPdmuHl5xXTpvyIE/U3cSzy5f/kzOdltGnfFyWTJscbtZVoJs2Rn1H+iwZ6VvXWmsrBxOKDwYQeLYI5UU9YD+jrOk0uy6lpccqj4EIpSVg39jYWIJR2SIemqrr3DPtQF7tkmRPvWP/ov7QzrAu2pbhdp3Pp2XUlEWlD5Qb6+DBCtdHBWk2Njba1tZW7A/UtTTWJHsufZLsBX4YOCbITmMFye1sD1D3QGHKJ/VR5pVkmc7ZqGwrtxa01pZjpdsD5tGrQy84kOSWZOCykC749oE0bvdW2nhf8useBPbfFa9+LdnsVKbsX+UjyRYyP9kqP1so9SG2ra+GYiCUupH6lvcZPe++hculpyczzTTTTInmAMGaNDToJAAhqgYhXaucHqdesCAN6inPHrhMTmpr+R3vFb8JjKY3GYhHT69BtTfQc0aSgziDACpLpN8+k5Yc5TQzLrCR3iOv32mfYpI591xTRokqoLiOI9BzonUtOS0JMCdHMIEYv8/yHUg5oEqAWw6TA0QHLHzOgxtTQEPqNw6CHLh6GsorLR92MJocbM/X24HXevZG5QiYpTrovpxbzqhVQJFtoOCADiysAANn6ZUfAZLySf2foJqrFSgvOdQOTvf29tqpU6fa2bNnl/UiePdAgctb+bld5KGMvkJA12QL2d8Z7KJ8SD1A5NQDyfrPtzwQ3BI8Eaj7CpF09kplp11+CQBzdQflO8bOeT+txs4hmfaCAw7SHRD2Vp8lfqlHlT2inlTAm/lVY0XKl1RNXvg4yHZimW63qv7u/6VrPFugNylQ1Z/1SvaX9oX9mfqV+hFn7aWrbK9qxYfSeQBWz2j1gOt4qgttgwfAyfdYH3Is9fzEmWY6KTRkMy4XDyeF5gDBVUhHNeZXAw0NKEP1q+6PGajcmaDjkq6PybNyxDhwk9IMyFGJzkz6rf8Vv877WB2ryqj40+8K+DONO+FetynkbZEc32q5bwL+vXJS/kdp56otegPalPJSMGQsLwkADelDFThgGyR+mL8DosqJr8CeB3HIA8uho514aa2tHJrY2uHAmZPrIF9JxjTJLrnsKr0cuwrNqSfzakWB6s5r1ao21tt/p/+6Rv1I8h0D/C81Tek/6zqj3m+m5jEExseUz+fEg/fdsXmPTeNyq/RkKl1ucMvyeuNNFRBI/6fa+tbGrZCZaaaZZqpoDhBcIho7KI6Z8Zla7hTjn5zW1o4OdoaeXywWy1lFvtZQ9/Txd3g7cTaO5dPJ5XvPRZwlY6S/co5ZPsGEvx6J15guzWSTX9aBs04JVCdZ8nuMDtAhq/JPIKtHCWD5qo5UjtfR06f3uOs6twk40EsBnCFQRb4SKE6OLJ/1/y4fv+YzjFOde297B1GV88ml+K0dljHTUs7MnzPsaYac7TIUWNBMGmfmyItfoyyVr/fltESf556kJeziWdc0m6ntCE7ed0W+TFrfviqAdo7lE0Ck1USpbizb5et668EVlweJfch/V+RlDFEKDiT7k4ISDmSTXKYCIspK3+l5yivZiDEBjSpA4/WcQlU/c0pjfyXDCuw6MZCQxjbqWsXT0FiTVhaM8V2mBNV641JvHGe9fEVnj6r+Uo0rlZ5UujrkR8w000wzkeYAwURKg707q7o2JT8+y3zHXE/OMPMfynNosGD+yXkc6wDqW0uFt7e32zXXXNPOnDnTtre3DznSvoyuNzh7nX1rwdAWA9UjBQdEfsia86ayU3CDMuBvAZu0fFOftBS/Aoa8xuXgCbz3HNcEFqutHknHPLCiegh8qewK0Ds45VJKytfPH6hAbmof8pucsrTVZIyz1tt762WltCkfb2Pm11o+CK9qr8VicWgveQrQiVLwpbXVWXUeLrhYLJZLhX1bAftUKoc6T93hHmE9oz4s4L9YLJbXlI565sEAPcv+p0AF+ZWeqZ7cfuDtpf8eeHH9ZflOlAsDMJSf59FblcE2Uvrq+UQMJvnKKNevtB0r1dP12F+1qWeoOwogqRweyjYEqsbI3J9vrcUl/b0PgW8FIpNdqAINHjSunk/1SrbOZdIbS9knejPhzEvtderUqZUxlmMyAwRefrWSh9+ue6lfuc3zcWasDJyvygdhO/lzqS5+LQVVqAP8yCb4fT4zllIbiMbIZaaZThrNwbHxNAcI1iA6rZr5qZSOzos7S71lmkcxztUgUTksoqHo+tgZhCEiQLn22mvb9vZ229raOgTyuL+1N2PlDj8HUgYJ9vb2VsBFAi3Kg05+axf3ExOUuvOhvBwcqM7JYXUeHHxSd5Kj5PmJn2ovI59PebvDx5nN9E1Kjqj2Vuo/eWPgoHLa0l5L/Rb4dPDFduvNKpGHBNy557wC8kPXvH/5bHDP8ec1Ot+pDmnpPfXSr6cAQSWvFJw5OLh17z730DugUPs4uPXVHHS6xSv3IbfWVg4rJFVtwP7EAEjqM7IT4mlzc3MlDYGN0u7t7a3YGoJD6rry8PMxSAo8etvu7+8vQZbKrfSZNswDF7pGm1eBMG9nD9RWwbrET29spN5KVvpP+8sAgWTIwFQ17lIXyJ/b4CqIoPzTIbYpIMDfbnvdLnobUIc8yODPJDn26p/ax/NJ4z71qRccqMY0593HYyfy4Da8Sst6VeBf6ZONGRrD/LrL0vNMZ5T05O5luU/A3ylY7asxfFzv1WcGSTPNNNMQzQGCI5IP9FOWsDlVy2IT+eC8Dg09zzKSk+AOQRrwqsFKznLaYsD0lVNf/Wfd0kDqThnTujzckU5Bi1RXdyZ6zrjPRhIsJ2fTgwZOBF9pFt95SHJLTlcl5yQnz58gIJXrdUrBAv+kAwk9sFDJaIjcOXM+PSDljlkVHKjKSjJJASPVJ/Wp1Fap3Qn8/CDB5HCT9woIttaWS/eZt68c6AEcDxLRHlQy8ns+y6b7ri8ql8FZB8js565TDjqZRwpYMF+Wqzz4RggPcrCsZAe9LAeaSlsFCKQfuuZBDS+/smneJso3gUZSZc8pLxFXgZBPlud8DNHQ+EHZVHpYgbOp5Pkn4NfLf0jGGm/029t7aPzzPJXeA5/VMwSzVdqh9qjsXPpOPPdoypiR7Hkam6eMP1Vf8f5M2+D9fwb+M80003HRHCA4IiVHurX+4FrR1ODClCDBOkDpqDSGN4+CV7P5HDzdMU+UnNkxzmBFdFh7QYueA51AeuVwjm2vKm1aiszyx+rOWAduLK8955BpKvlNdbzW6Yd8tkcOshJx6akHlPjt7SKne2p96eT6jD/TTHGGE9Ab6i9Kw9fVOWh1nkm9vspvv8aVH86jb4PwwIKXL0DKunPLAclnttNKI5bHejufKbBQBR7IF3+7rPmsdNHtwZAuJB56wHkdcgDogc4UMKnsyJTxUc9UPDEvb8d1STxWY17Fyxi7VI0r/lu64IGJit+KxzQmJ51K9mgMMS9uRfF28cDUOuQgv5euqke67jy7jW4tn1WU5DjWfh9VFjPNdFui4xyrjsLDSaE5QHAESjPIacAa83xFPpimAXdosPDBe2yEnTMErR12HOis9fKpSEt1d3d3V16FRudF9ddvl3ly7PXZ2NhYmdVUeg7OfJUX8+Js4+bm5qH97pWD6tcr2UwFWiQ6dR448dntniNdrYCYUo9UJ7/vgR/fnsF0DBA4f/pUe+IrkDPGIFPnCLKq/pbuO4DyVQAEqJSFy0fPEBiqbH0nsEg917L1BGwkQ2+D1J9p09g2rEcCbqqTlsnrGmflfV87ZZJ4kMwZAFCbOUD2wAR586XySf6+AkLgX68k5XNMQwCeVl740u2hfqXtIJKbBz9Ud215cJ6Ujy+XZ5DAy/U2Vt38lYNcjZG2uLjODQEv7xci2mamSW+G4Ax1NT45P06UXVr1xPt+rzf2edt6/x0Cm5K9t3E1Dg3xI+oFOpJPo+8xgQq322N1wINoiS/6Bdx+06uL18l1pzeG8HnqY+851svtmoj2V/096R9XB6a+m/od6+v8jAUqc5BhpplunzQHCCZSAk2VA89n+F+Di89C9cpMYKTndPV4SAPDmAGAsznVEruKl0RybHd2dtpisVieQ0CHmw5GL2+faeIWhr29vRUH1oG1QIzKFQ9a+qvgRQoQjHHKfBmnLw900FA5pZUc2a4M5iQeyUdPJ1zPK7l7H0jy1bfqmmZW/eNyFA8ESwSjiSjv3jJ5pwSwmB/z97ZKTiSvu1zd8XTnM5Xp5ZAXBbN8247zyOXu1IfkZBKI01n19LzG4ICeZdufOnWqbW1trdQp5ettqzzZTzzIpzQE01yNwbNE3HFXeVz2z/bkO8tJ5IMHJaYVFKk92d7eNsxH36yfAq08S0GySjoj3tgvaHepl+w/DBBUq2HSkvUxY0uymZQBg0xM74EPBu8oU9W/B4rc/vB5347GVW+9PCmn1B7sW7rmPHl+ao8UJPA6e17J5o55zm0Uy3X7qG/qlurIQEEK7ifyMYjPJvm6TUuyrPynSme97cSPAhOVnpF38kTbyO1FLhv1S7a7f1gO65bq3JN31fYzzXRboSF7fbl4OCk0BwjWoATWfCCqlhSPVY4eIKzKnXIvpZvKo9JWALSqg+TCA7/csUuOagKDFSgXmCRQPnXq1DIQ4IM5Zyf9fAEGChJgTo4GAxa67jzSEeDzdABby2dT+IxdBfj9ueQ4Mb3Ltfrv5GA35VuBVF5LTqu+E4ByHirHbkxQzvmjDFOfqHSP+uR6nJaUVnWuHGmlSY6on+tRrdBwmVUDJ6/5TH21mqYCbwQO7uB63dzZpX2Q3dBhgrqmwAEBtJ7Z29tb5u8BP387idJsbm4eqo94IV+UjQPHvb29Fb78AEHXa+qaX+dsqcA668vXTSYQleTqwTPXA+qMwJDbLAeCrj8VeGU9K6BKfjxIkIJUCt5UfbOiyk6xrUVuU0hVMKLHh9ts7/NDY4uXn+o+FHio6uF1STaEPPn44rpLe5fqkcZSJ+puAsVpZY7Xucqbgcde+frmqgjmW9WB/V36TPnIhiv45xMf+vZVBEM0pr1PEnCZaaaZLj2tf6LeTJeVxg4EJ40coFcOCNPzuePmpbXDQHNqoGVMGf57LPWeWSe/Hs9DSzaPi3pLXFs7PMvq16bSkJymOtPHSWPq5YCv0lW/n9KL0haHKbymfKvgTwU4aAcccFeztWOupbIrflIdXX5yzLkaYmNjY+Wef6q8EjicyuO6NCU/53Nsfkflu9cfklzT/zF5tXb4bTiJ1rUNU2RwlPHmuHRkKB8GC6vneuPHpfBnLpWdVr4+gTG2zKqutBUMsq2ju0elOTgw00wzOc0rCI6JUpTf7/vM4aXmgeUOOXZDaXzmZgwfiQhuRJwZ1Mwf09CZ9oi9L8lPZfty1QpEpRlFn4Gt5MI802y/rhPs+OxBj9x5rdqLcvA8h9pX32MApfNSXU8zWtxiwFkftWNv6a6DpR7g7elpApC+jLiaRfM8Kp0b2tvrlHRJeultwtlx1ZWAVXWvgDJ5o9y5FF/PsN30vnrOsCsPpWF/4lYH3/Kg1Tysq68OoYzFH2fKE/nKBs020n55HX1LDmXEtAoEMB/KNZ1PoLSSW2oHX50heZEYOPF9+ZKtv5bPn9c329XtD9vIn3dZ8flkk8YEdHpEO6kVYd7vqAuafWX7M52v2PG+4PaF7ZrK9npW93urDahPKs9nlSkLUlrddBSwNxTk8fbrvQbS7Tj7dVrdIqrGG7dlHmCj/ezZut74llZEMX9fucd6V2Mo66m6uyz8GV91kWTj8mCa4wL8x5nXTDNdaZo6/lwqHk4KzQGCNYgDXuXo9ygFD6o8OPD4IMDfchwToK1AnPMwVM5U8vzSAEqHV8uAfY8xB1AfoHVNebmTogFWwMYdKuVBx0FnIShQoDok0OmydQfIHVGvD8slX73ZmRRQqJb3+jLMRMxLoKTaTtGre3JUE3D0gA3BX6qj8+BGvnKiezJMTmRyailH5e3PMl8+l7YPJDmRH8mFbbe5uXloSakDFuWRgmAuN9dN9Tfngc95+adPn27b29vLcvXtBxAy2MY22t/fb7u7u22xWLSdnZ2VdiQfrBf5PTi4dfk+gTTTCUyq37d20T64jBgUoa04f/78ocMctX2DbUJwz4MKlS+DmtSztC1if//igYOqV7JZDry43YJtzTb3wx1pI/ma1UqnBZTZnj5upH4wFsB6nUQp2MM217Pih3u63fbRJvjKFOfZ683tIckH8O+hFQkOHtmfNdbwO42nafyrtu0MkfOdxg3fIsNnqWtJruqfyS4me0sd8zq4nKjLuk75ev2pT+5LVeOeylQfqPTYefXyZQ9kW2g/PDDA7Q7ez1y+1LcxvmnS46QnR/EBZ5ppppNLc4BgIiUjmgYw/ndD3QNVQ2X29sj18hpbjkiDDWexHDhUeVfyIHHwk3Os/aPnz59fOT+gmvkh4HSgx7Q8eZwARDzqI1Cjg948LR0XOqSUTRqY3fGTg+uypLNHWRJEU74eOGE+zkflaPl/zj73ggPOX0Vcju0ANjlzlIPzkeTOMqZQBRioQ5S7vgk+EhgTv+KLeaXyKQc6afpNfaROElh6vszPy+Nv7y+65nqp/5w9P3369PKQQRIPkfRVDSpHvAvou+6qLagvKtsB0WKxaGfOnFl53oGXg2RfYZFkxj7LIITL4PTp08tVT7JfyeH3NuIZCeJrZ2en7e/vt7Nnzx6ybyyT/Ki92FdcLwluE8BLAMTbwPPb2NhYScv+4vbPAfvUsctBG3WGZUoWFU8EeKQqKEg5eHDFye+lNq8Am3h2cOjBAbcvyc44uPeyKiJvfGOH32NdKGde5zjlY1DFgwPepB9pPJM9SECf/FCmtCVT5OTtm4JpnkcVsE3/U3+veFS9XNbJv5ni+w2N5zPNNNPth+YAwSWiMUY2Acnesug0I7oOX2MGjEuZd+UcasBLIL8nG0+byus5JxyMfYm2l+PgVVSlT7xVzkQCv56+ckiUD2deUh5DDoAD1jFtWvHs+TiQ4XdV3+Mmtl1vhcFxEJ3SqpyhtmjtYtDGZ8p1zwF/L2CSVrakYEfFjz4pwEVe08dXPIhfnebNOjNAyboy0ODbIarfznsPnCYQQP2mw68AAdvSA1lenurMFU3MnyupWGcPfKTgou6JdwfHQwBxaMya0jeYX/o9BYj4sxUYTM8kvfP0lc6nPtJLl6570KWq21iaCvimlpP6go93VXCgys/tX7KJ3kfG8NkbOxgYGKo7+RnTB6o2TTwlm5TsRQrwk7fjAu2X0v+baaarnXr+zeXk4aTQHCC4RLROJLYXHDguGqOcVSBi6NkpwYFehJzRcTrbdPSq2YtkANLsA8uulh631n8nO8GZzxg6P55uqrNJ3ivHpOe88DkH7/weWybv8bf/TzL1IEQvLeWXZpq9rmP6XAXYU3v1gjWkMQEo5sHl40zjbTTGwVV6ziJ6e6veyWFn+QxG6Brf4iF++dvllcp3/ny1BussXlk3XaOctBpAWw2SvAnm+Z+21oMRCdDrWZ48Tj4cjDjwZz69eutsh9RH+SxP9Kee9Oyc1ztRD3Qpf9q31M6JerZuHfDDuqTZ3ARAkx1ivaqgwboOXQ8cshySL5fXuFTxcOrUqbgiwp8Za8cq8sAif1c6nspQv3A99C0BrlNjbeBQ0IB9hmO5pxUlO5p8Dq8jn09908uYYuvTyoFkSxIlHT+u4MNMM81026I5QDCREjCpwMq6joU/WxlwN+4ErkOD0hQ+PB8OqGODGgkIcnZMZfEVXpxZ5CwkB1KfKVM+vhJB5Ad/aQZQTjnLSsCO9XHHgsEG8pCIAQXKh/d6zorzRKDAvHndn/NrBIVOQ04EAQjb2s8ySM5QD5xqeS+BHuvnOkHnc6iv6rru8V3zLmcua+/JI7WRA5HF4uKSeS7V9g/3hfsMnhP5I2hIYJSycFnqYEGdwyGZa9+96qD/1HPqu8A79/GzXgcHF7ca+N5uAg2uHnCbpnbXsmEemuiBgdbaCvCmnnqbEqQ5T3yeKwjEk8qTHdMz3E6gvHjQoPhzPdNv5kMd8PrQdjlQUQCEfb/SpQoIVsEAD+aSt95MbgowOG9pnHMbIhk5AKQ+VgET6pHrKNs9gSuXkSjNCjsNAUbKx2WaQCjJx6ahlUWJ0jiUViD5PR97K8BMYp/zMvjfx4zkn/C6XlvsvFa6JbulMlIbkS9uBeFYS1tCu1UFFNQ/K8DufUJBwjRWpTKqOnj+SSYzzTTT7ZPmAMEatI7x7IHN3n1eT0vzKgevcgaGwP3UZddVfj0Z0aF1UNdaWwkMeF7a50vH352EBNIJ/smv9lHTgU/l0nkl/3wfufKko5ScGuVH4FsBf/52p8j58rQOslymrlsO7r0NUxkktQsdLILD5KC3djEw4QECOossLznfyTnr8eyghLpCcOD5sV2SfJieaX1bg84V0OFySp/Ads82uIPOZ5Sf9vozveTNfqH+oACBVg7wW+XoDALJS8vifRWDggR0kFUH8SXQ633V0ycQtFjcGkjc2tpaWSWQdIptRH13oE5Q6G9MUF14xgLlx/Zi8IBnDiTQuVjcGiw6ODhYeU7y5fMKPhCAMSjAs1TcXrmuup0h8HB964Fitjll4M8PBQlSvn5fessxhOc/tLZ6iGeyaSnIkPpfDxCn/6S0SsWfHQKEbvN8HHN7VK1g8+BN4rVqM/Ja1ZvpeFAneU0yT7bN7bEH7NIz1SoSBUt9IkKkNCTx7/05jR3ej9kPvd954E3pZU8ZLO0Rg4ve1mNoTLpqvJxpppNMU/rJpeThpNAcIDgGogNTgaep+YyhKWVVeY8tswc2mWZoRQGdOjq2BBBpps2dLX/dof+u6sRghJzo1trysDG+ei0NjpXj5E4AnYfKIeo5iFXbJuDec9zEU5pV5/+Ur6fx/15WAiOuD+4gpkAR73sAirN9FR+UaeXY65p/ksOV5J2cxp7zrbR0CDXrLapmm4faN9VD+THg4QEhBhMofwUuxGMKEBAcU8dVFl/3V7UT+7ju+4wYgwdVgMDr44EPAXq2gYNqtj15Tx8CVNoiBiX8fAQPPKUT8aUnDBBw+4LSC8Sz/RQU8LQJaCaZOS961q8xrZfB69W1ZDPWcZior5IZxwkHlr7SyO2yKAUGKItKVom/nk1I6VMwlOVSr1Vub1xJQajKLkuPST7GjQWWPvax7KEAgeuceBvrozBwwjbgPR8Pq/HC/RmXsfc18pjGuUofXJcTuS1xP2lIPkmHU94zzTTTTKI5QHA7oXWcsERpJuRSkA98dFLGOF/VoFkBYh/Qp5I71BVorZzNRFOcS6/L2PymOLG9/BzoVw4gqVqx0Hs2AXpPWwF73VsXlIiqspIOJR56Wzl6lPqCz7rrfuLBr3nggnvwU11S+T09dnBC3hxcVeDU60DyQBLBgC/9l544CPL8UnsmHrwNEtj2AEhVpuu+24pqVrJa0j+2byS+GEAhcKn0IQUjptA6zyXwLD59BU16Tr/HAs91qdLZ6n7PLk2xWWPS9gI5x0VHAZ5pLBgzPkylIRsjWzLkawxR6uN+v7XhN/JwdeJMM800jcYGOi81DyeF5gDBFaI0SPRmJDiLoOcrmrLX0AdIn4lbh6qBMAFCDpxyarlsn7NCBwcHy9eoOZjwOlXOuQZ77QHf2to6lC4tr/X6OfBwZ9nz9HZTGp9pZBlDzlvSCX3IT9IHBlsSJUDgdWE6Asy0giDpmQMQf9b59Vm9g4PDy6v52wEbn/V81hk4vE7c4+1lOUmP9WwPzCR+fZk59d2XI0vOvuye8trc3FzZYsDXKqrs3d3d5W8CUfHjM1peL4J4Bje8Xfl7DBjQPR4guLe3d+jVmq63KYDB1QR8JgVh1AbJru3v77e9vb1lGn9Nns9merCDafxAS9qntARecuCMOXVAfdX7n+SdggSsX6+PTqWe/alsL38nW+SBIa4eqFZNeF9hfXpAv7KhzruXO5Qvf7ssxsomleE+htsZD7qwvGRPnYb48rJ6NDTOpzLZn6r2Y116AdGhOgylTeNc4oH15cfP7/H6pnGrau+x9Uo+aU8uM800022X5gDBEWkKEPe07ohU+dLxHyrT99pxIEyAleU5wBxDVUChNyA5oNVv5cO9+UxPGdIxd9lyWbIPoAJm11xzzYrDSKebIKEXqXeAI0rAsHJAPUDApdAutwpIJod9jF5Kbul5v5bazIG5g46KEmhxUOLlEghLVyQ7Bib8/fCpzvydgg6VkyTe3bljPcgz83UaOhDS+eSH4DMBRNadfCkI4GcL0ClV/+C7wltryzLVp3y2NoFggny1Ge+x/1ROr8+Wu5z4vbu7uwKAGWDUNZ05ksBUWsKt/LivWt/cDkH7pfbzMwccsCttAo/umHMbw4ULF9rGxsaSB205YHkOGlR/fbSFhH1P5egsBPblXv+g/rlM+ZsAdCoYq/L0funAkPpKnWK7JFlpPEh9cQrY4vMMCil9kk1vJYSPdxU45HiR0qbVJZRlsuHUgx5gVVqC9Z5cqrHL+2VqV24HSnklW+6BDo6BHuxzWVb1T9sR3IdxX6bXT6vxUHXWFqPU/mP9t9SGft9t+EwzzXT7oTlAMJEcLIimOBJD+Y+lykkYO0B4Pum/D/giDoYp2FCV4wOxD5oOGgje5SAL9PT2CFZ78zRLur29fehgIKX1Q8vSLL87mBUwIm/u7LPMJB8vy+soZ5KOFJ9JZeu51EaVo+VOCtuNKwfSjMeQLJIDJRDk5DPQ1HWBWsrB6+P/vc3Gkvc78s0gBevvfHidKoDlOqW+wfMyXL5yqB2EKiCgA/14voD44m/lJR49QEDnmuC0kqcH06oVBO6Uuo1gPfnc3t7e0kYkx//gYHUFUpphZxvxOYIA9n0eqKrf0i3WVfc8AJhAXM/pFziS7ZIeMGDhhz+qXLU3l00zqOW6yWvKj4EOkvNW0brjYpIH+76Pvd7fXKeTvWb+XuaQfXCb57ySCJ5bayt6qOfHBAkq2fiz5EnfvcC3goPKizx6QLKShergPExtf67+cPL+WOlkei6lGQpqjwXdaayjvmp84zWOpwxwui/g9eu1Y6rjUeo100wnnZKvdSV4OCk0BwhOGN2WDTUHMgfelZPAZ4eIEXlfWtjaYeDKawSmvfKrmQGvn+ro/K1LCRQfNU+nBKD8f+VgD+Xn6Twg5Y4pHWwHlqkNREPt2KM00+v8uzMop9qDGlOoAt0Ocnpy9o+v/qiAVCovvWov8ZfqUF0bAhy9NhtjF3q60QOHvO489Oo/BDpTGSlI5ADGAybJZql8D+i6vvR4Yd7JPqa0l5p6ZSQQfVxlXi0O3VCdxoLAdYD6WBorqzHlS8erlWBj+afN9z6S8pja3r1gjX6n8nm/CgqKPEB6NQCdmWaa6bZNc4DgCOQzP710x1lma9lxSbNsiYZAY3regZHP3nObQQ9E+5JbOrJpOTkj7Xy3eIqsV8v3FovFyoyZL4VXVF/P8ERsn8XpORQe0CBPTFe9y1wzggRwqT16vOh+xSP/pxmX6nnm7cByCKxU/9NHlIInvZmk1i6+nortqrJ8htQdRSc+K73RLLxmx1SudIozQMynctAFth10c/ks+wnvubzZBlzNoPu+pSDJ2eXkp/lTLh60GwoW9AJHPefXAxg9EJj6vzvnWgXBs02ox2lLAPOk/vtKEbZ3NdOa9MBnNMcEoVhnzjhq9jetrlI9VYZWNfAsBcqaNtNtaXrNoweexoAYt0NDdoPXqoAM76WgRjVu6p5WQXCbQTVTO5Y/v5/G4BSIqoJT1X/qcVXfIUrj2Bhg2gs+sf9U31OI/ZDPpjcxcNxNQd4qCDbk3/Xqybz5m23kKyyYLgVwva6Xkob6zEwzzXTbpzlAcETqOThDoKwHxLmXurU8m5cGn5Q3HeFq2SKf4fUxS9h8pjcNfCk4oL10SufLGLVkWPycPn267e3tLfMX6CGgae0iUORz4mdzc3NlWbXXnY6Cv7/dwZQDJwdzBFm+7JvlEnj4clOfNXRHptI938ZQtbe3eXJC1KYEnnRcfGuB81SBOwdoCWw60CHvuudLn8+fP78CYlq7uGzWl9AzP/9NuWvPtnjlnnQHViozbZOgs3pwsLoc3IMAvlTcdY79jP3g1Klbt9F4O7nDKT7Ip+sXQTfBggAml+v7FgISbY8vse61Afu68yFKoICrNkTij/VPAQj2QQfZ7ryn4A23gVBHknxSYMjLqUCo8mTQU+cTKO8EWA4ODpZ2dG9vb9kv1L8ZDHNbTjsg++tBMZe38z2G3B5X9/mfHxH1LqXx4CbHX7avnh8zHpJ8jHFgnNJS1r58Po3hHjxVe6ZANPW7IupiqkMax3pySe1C/it5Obl8+Nv11Psk+wufr/whLvF32VZ1q0C0j38eIGBb+YSFAtIe8O2RBzbSM66D/pu8J79wpplOIvX66eXkYR16/etf337mZ36m3XTTTe3BD35we+1rX9v+/t//+2X6nZ2d9opXvKK9+c1vbh/96EfbF33RF7Wf+ImfaN/7vd87usw5QDCR3IlNg5yTz65XAGxocKwAfTV4qczqeSd3gIZWGlTgjfn5QHXhwoXl4MtAQWsXQS0dW/1PTgEHfh/0HbxpgHWg57wSOKlsgqCqnh4goFOh+vae9aCAvh3ksf7Mw2Xj93ptm2YbXS667rPTPpPqgMb1LwEg1jdRBSbp0Hu/4kF8Ls+KqoCLwNLGxkbb3Nxc8lTJlPpJR5u8M0DGPlABTMmJMiSAVD0Xi1uDYAoQsP4JgLMMl0UFzpVW7aJ+W82as50oq57dI4BLDraDQD7nDi1lyIAk+6c/TwBMWfsBYiyP7SYePUjkAQvJv7WLNsftk+ukBwdaa4fOFmB+4iP9p+1VWyqI6rzQliqNDr4UH9VBlV4P3fNr+j8EYl2WiSQr5slxxUG32zGORXre++DY+rgdTXXw+xVg88AF+6qeo310nRuilEY6MDTWuKxYj56/kMb0dJ/6n+57eaxLOv9DHwWV9Z9+itta121+aNNSHz44uHhmhvhh31EZPJSUfkyPej5e5T+O9TmvNKiaaabbM/3ar/1ae97zntde//rXt6//+q9vv/RLv9Se/OQnt/e///3tvve9b3zmaU97Wvu7v/u7dv3117cv//Ivbx/72MdWzkwaQ3OAYE2qwHoaFI+LaLAZdKhoCMCTjnMAcNDkDo+XWzkTIjprGkA5Q+iBGo8SctD1GUPxqEHbZ7XdGUv8+/+hKCUdO+XNdvKASHJgKRenylkiVbox5DDwk2Y4/X+65g5aRe7AnDp1agVwsd1d5jwwTmlSO/J55ssyVVcFHfgc61I59Ek3PQjms/MMQPScNLZFCoYRvBEgMT860qyT9DItzfX6+Cxt4tPJA0QkyrLSH/HqebuuV8GLBEZd5rQNrvsVCHY9cB49cMF2IIAgn2PaXnk6WGRAh/x6MIM2kLOtrue+pYZvPmB5rvtjyG1673mXuX+qZ9L4IJl5YCKB+ilUPTfGdifbUuWTAhGiISA4hqb4Eol8HGLQcSxvLg/2K/eNKl+jl2/Vj6fymfInz+Tdx9AUvPDA87qUxrpe2plmmunqoNe85jXt2c9+dvu+7/u+1lprr33ta9vv/d7vtTe84Q3tp3/6pw+l/93f/d32jne8o/31X/91u+6661prrX3Jl3zJ5HKP7wSz2xlNNaC9wTXN8CVy4HKUMi8HpfLHLpNzctnICUgzVhpUU0BgCJSS7wSIx/LnZSXn1R0QB4w+Sz0m+ODkQRD99nMYkpOi30mGST5VYCABpTFtke6la2P6jc8ekgfqCl8F5/ozhgi8uEpGqwS8XRNfrKuvIiEoG+I1gXjXsQSsEvCtggOJvM9430l6M/bTk3tVR9++wfZI1z2/qr1SvVP7ife0vSWBEy+bejNUfrJ1PqOZthMk3aH8eP5LemMF+xTLq/S0alOvV2Ujea/S4bTFZ4rNquQ4dhzp0VDQY518hvrlUamyZVxl0aN1/ZFqHJgq/2qFU6/cNHalNNQRn2SoiGM7r/m3y7zq/8fR7nNgYKbbMlVjxeX+tNbaZz7zmZXPzs5O5Hl3d7e95z3vaU984hNXrj/xiU9s73rXu+Izv/mbv9ke9ahHtVe/+tXt3ve+d3vAAx7QXvjCF7azZ89Okte8gmAiVU4NHSumSdFfRXJ5recYVTRmwE1gz/Pnb86kDK1+4ECoZ3gvycQdUzpenrcDbObFgVPLA31g1of7ZHlP6bnHOwUEkkMoB9SBSS99cuB03cG5tz9XjFQOtjs0yodt7q+0SzIhmKmcfW+39F3JgfxqpjIBWweWpF4fZD6+HJ76QIdusbi4moN9lzOkaQVHAlT66AyNBO781XSpv7PuPktMHheLxXLrQ2urs3N03nluAu+nFQSSDfWz4jO1SxUQIM+6xwNChxzUBBIZLGQ6pudZIORTM8ZVueo/1B+t5kk2irLjuRAu47T1gPZT6ZMN8fHG5U2+mV5tyLyqVxJKV7h6QqsEFovFoVUlXIrdWmubm5sx+MX0PZtIeaaxsfrs7e2tlON9INkllkM5uX3S89wOpLb1OnhdUn3GjPFjyfu111fkK4H8f5W32zn2qaqNSUrnY2oqQ3kk2+/jnZ5N6dh+zFf19vZXv07jnq/KYR4pCLa5uVn6NpRjusag3Pnz59vu7m47e/ZsO3v2bNvd3W17e3uHgnQp/yFyvnz85PXj1NWZZpqptfvc5z4r/1/60pe2l73sZYfSffzjH28XLlxod7/73Veu3/3ud28f/ehHY95//dd/3d75zne2M2fOtF//9V9vH//4x9tznvOc9slPfrL9yq/8ymge5wDBREpAf8wznjYNGtWMR3WtV3YaSPVbzmdvAHbHqEcOCuh0O9gTOBuaSarAF51e7p8VcXacM2VpFo2OIMskOHIHkKCK15JTRhDioGCMUyYHns6q5NCTXwXS3bGRE+Ngjd/J0aETlerL9N6u1Fk/KJI8poPnUjoHGcyPjjxl2Fpb0UOBf7WTDnkTH9Qhd+zIi/rV7u7u8lvX/TBArjAQ+WwzZekBAg94+aGmaXUAAwQeNPB6sW1Tnrqn696mroNsBz/UkrJ3J9Xr4GXKTjEAk+ovMONbRJxHyVTtJT0huKFuMj/vYwxY8u0ryjv1D+qEAyiSgg/eX2ivSB4MkFyo62lVRWtteaChQD+DhdJpBWnZr1Q/2sq0IiGBJW//VJ/U3ml1g/5LV3pjjtpLz3owi/0m8ec2yNPw+QQ6e4BvyNfwdmN9kg1UGh/rK/0R3wcHBytbuMaS23r3iZJ/1GsnPZP8sKqNRVVg0McwTma4HaKPoTNqNJakc0TEp7cT6+KrNPb29tru7m675ZZb2tmzZ9u5c+fa7u7u8uySpHtDfmm6n/S2SjvTTCeVxtjRy8FDa639zd/8TbvTne60vL69vd19Lo0rQ/bt3/ybf9PufOc7t9Zu3abw7d/+7e1f/at/1a655ppRvM4BgjUoRaXTTEwCoFV+HhxwcJ4Gz3WixL0ynO8qj1SuO8cVLw7YezwmcKHf7uglUMWT69Ng3XMs2Mb+3525KkDgDle1nFC/va4OtDiLWbWBO7PJUapkwrqyrXittbx3PIHCyuFIz5AYAKEsEjCvggOUqwOJtMKEs9ge+HBw7vJlmzkA8msiOngEUknO1GMCQm8f8pBWAPl1ysblqP7l9xyou9wpM7/u/aknWwbDnB+vk571ABzrx3M93Fl3IMW25eFlrhu+GsH13vu/y5PPJuDA+jrAk67o23lJ7ZKIsnd99TZR2WmrDGXHQLDqkGygn7XC8pxSX/OP+GYZ3v+9nfy6j+09gOcy8jar7LTbItfDqeT9eMgJ7pVT2VD+pi3zcYPk/sUYv2Ws804+q2d8LGe7jMmb9sl9tBQk8BUFlY9Bnqt7DBJoFcHe3t5y9cCYbR1jZTmUrqrDTDPNtD7d6U53WgkQVHS3u92tnT59+tBqgY997GOHVhWI7nnPe7Z73/vey+BAa6098IEPbAcHB+3DH/5wu//97z+Kx/kMgplG0XENRlOfrQAB71dgWd89R9kBckozlirAKz4r6jkLuk4nOAE7ppvCL/nugfwkp16epF7AqMpvahskXqvrCfgOUQLJvU9v2XFVzyqIVaVP1yodSLoyhqb0rYon168xutTjdagvpc8Ycn2o2tyv+QqGMXo1JJ9emxJg6ntKv0+BPf9US8FT3dNv9gGW6WWk35V+JFuXykoyS3ykb5dLRWNs49QxcYqeOy8JiKd0UynpO++tY1PWHV+vVlpnTHRKbc9ryb5capqDAjPNdOVpa2urPfKRj2xvf/vbV66//e1vb1/3dV8Xn/n6r//69rd/+7ftc5/73PLaX/3VX7VTp061L/qiLxpd9ryCYA3yGQoRgYfP/vjMQpXf0JJ+zaSl8shTitZ7uV7WELg9SqSZjpwva+b11lbfCyyeuKRYyzM1+8L8nZ+e080ZgDTDxSWpTu4YV05iNahX4MXrw/cja6kvZ2Y0i6z6pIPQKA894zKRPPW8Zq11j9+Vc1yVm1aq9IAAZyMT//5f3750ncCD8pF8OUvD/uL9VkQQ5LNJusaZHe97lIH2c/fk4bPw7oxzVp22IPWJysGv5Or5if/EM7eKpCAH639wcLCif63VfYR8s630m23mWwyYH3XBZcr6kye2Pfmr3j7BdDzvINXNdcHr68vX9Z/bMLTXXvlVq8FYX9q8ylarfajr5Jky0RsQJHuVz1ckpn7sK+O8ji5ztjf/a5m7jyUVaE39K81yc/whz0mfWEY1FrkupiX83h5jwJnbW7Ybxy4GKyt7ksjl76tGKDsP8ugaeR1TjzROJ778m+nGrIr059yGDlGqT2VfWK+hoJJ44RkEaeup0qV6VDxW9eqlo82YaaaTTmP796XmYSo9//nPb894xjPaox71qPboRz+6/fIv/3K78cYb2w/8wA+01lp78Ytf3D7ykY+0N77xja211r7ru76rvfKVr2zPetaz2stf/vL28Y9/vP3Ij/xI+97v/d7R2wtamwMER6LU0D7IJKDO532AZx5eTjXQ85oGb9+T7DQ045CcmCqNA8iqrtXyZgfnAhwMBNA5JqjnvlgSAYHvvdW3nFjnPQ3mbJMEJt2BZr3ccWU79ZxZgiDKTksa1c6+zLi1ttxbnJw0d2QkI+6d5LLJJNMxAQLqqfPBtFxmS0r9KC3b1vWtra1Djqo7bFwuTpAjYMRy6WjLSfN9/OnDZc4uc69fj5wf6mYPUIuGlh17+yS74sEoJ19O67yzLVS+A0TymWyf0tBh9vow8FjJ0m2BB/8cSKtc9UXyeP78+UNtSjvmuuf9ZGNjY8V+CpS6XdRZFT4G6HwL5ennrGiZv+6RL+oP+ff6UM4Oij1QozpoS8bW1lbb3Nxcbt+h3VAAgUEyXxmlttZWHLbV7u7uMk0VEEjgyduCgS3KQ99pqwFl5gGzZBfYZnqGOsbAB/ng+OHlsx5uO/lNHfNynFLfdh3k1gLlw0C+eEuBggpgVgEF2vm0dYE8pjyZD8dQ5uGB4RSY6AF58u867s+n+qatD/STzp8/3/b29uK7y5N+814F+pOd7/msc2BgppmuPD396U9vn/jEJ9orXvGKdtNNN7WHPOQh7bd/+7fbF3/xF7fWWrvpppvajTfeuEz/eZ/3ee3tb397e+5zn9se9ahHtbve9a7taU97Wvupn/qpSeXOAYKJlBzTKl1rdYSYv5OT2gss8DkCafLjzok7Mz1K6TwYQJ79XsqDjrYP8B4goNPJ5+SYc1D2fIYOP3TeOOslR4jPVjMCXnfuBXedqIIByREUcVWDSA7NhQsX4iF+lFs1uPtrzVq7CDD4toetra0oqwR0U0CFDozrdAo8eFn+n46Np+NBUcybDlua7WPQicQ+RJlzBtuBd5pJJnm/Sc6o/9cznCmlLNJ/DyJ4f/P0VbupvCRr3qdOuGPs/SiRyzHJgvXgLKYDIwfxkiF5cIDG31WbsBzO5lUATflVrxCkPKpDSNluvqJgf//iGzKYH/uBAKKue7vQzrE+/PROSueMv+onQK/yvT1ZZ5LsuvJTnup/CXALQHl7p7bzsrwNEhiXbvtqENcr8uaAM9n1XuC9Z/+cnJ/WLuoSr1d+SLKlLkOvWzoYjwDe+13KV/8rAE476atKPN8kI+anoJvGUk6asL+mOveoAv1jAiGUe8+vYDDUA5+Jz8RzGiv9emX7Z5pppquLnvOc57TnPOc58d4NN9xw6NpXfuVXHtqWMJXmAMElohT5vtTUM/CXi5800CTnTQN2GuSGHD53zHr1rgZhOlEpQDP0vPPlTsLQ4E0+PE8fwD0vghLOcvN6cgxT+zvfSSY9eYxxjvhcStd7LqVz0OEAMK0gIDBy59BlKUpOmc90plU9rpOp7q5zle6TvAznrec0VkDBqcq/tcNBDgedQ3lWRN4TSBF5YHGKc1+BYS+zAlKV/WRQgjwSwCUw4n3G0w8FdKnHBNNejsrytqrqzj7jdVJZLIN9gKttUjCHz3uf8ENCHfxWdr/X5kkOBPvORwLNFXlfPm5wlQIJQ32sqm+6P4bnJOe03J1jT7IfVR0qWzd2PKgCFdRvBovZ5iqDfshReBmbdkrdxgYsLgWwH+u/zDTTSaIx/ely8HBSaA4QHJHSjPFxUhrI1wH7lXNb5eP1Sul6dfeBMC3FTR3FB8axg66cTAcCVWf0lQHV755B8Vn4saDa86hmmjij6PlpBk15y8nhcmKCjB4QILgec4ZB7/fQMymt8+jggc+pjtQNBgb4zupe8CIBTK7Cof55QCY5yuQl5T1U96RnDhIr8O4AMFEKyvjMtuftTnYCtUN1Itjz9nUA6aCQ+fXAtQNq6ga3EJHf1Kd7gRnx26OqLfm/+k3gysCp5MJZegfULgvJka9WrEA665za2du4WpFAW0I+NBPKIALzZDDCZ/GVlq9iVP9nnVK7jAH7PYDfCxgksC1+W1t9U8rQ/nHPi200FDx2eyVKYzfBcS+g4v3RA6FjxnzymVaqpDqJ0mpE0hTfJ/kglANXlzmP3gd0jfz2xslq3ElUyTuNCakdezZtpplmmmldmgMEa1AP/FbXhgbm6poGmbGzGmkQJM9pQK6WA/p1OqtM4zN7PXLnODnSlTPjwQMCOO2F1r7b5EA6QGHd/F3srK87YJSrnFefWXN5+/LGnpz0TBVIcaeT72tPy709UKAPX0W2ubl5aB+ly6pyfConSWVXQDS1gztfvmWEz/tqAba9y5O/Dw4OVpbtc4+n/usZbr2gw58cX391ZDroTOSOIPlMcqBMxziGCegzP28fPeMrIgjU3GFWG3i7MB+CJX7Yt9JSdgdvDqRTGyd9IghIskh21uUpnXCA4LJ2PrX1qwcUHCxTR3guiJYa7+7uxtcRiihP5ZkCJqkve7BB3z6eeIAgfWu5vfhZLBZtd3d3pU5V32bf17kiGxsbK/WSXkkula1MfYf64LPfDgD92/VSMibxFa0qk2OLByDT+J50me3J7Qwcg9M45W3FdN5f2S8V2PHAja/8S2OCj7nik2OT7Eci2gO3cx6g6AUMqnF4aIKA4xZtv/s+btMqmVQ22u0gA2rJ91iXqNdjfbSZZprp9k1zgOCIlIDUUNrKACdHgURHgHvqfIBMAK9ybp3cSUzOhf93cFzVjXlycKyCBJxB99k/H4yT08n8e7PKBD6JTzpJdMr4rfLkuCWww3SUV3LwEkhhXnIm6IjrQDCl9WCJnpeTz6ACDxOrHOFKdj3i2QzML4GqBCQVuEhlq73d6afM6Iy7zvlyaMlT+7tV/pkzZ5ay8uCUeKPuUTcq55z92GWR9mhTdgzS8dkKbKR2kqxTWa4rvFf1HZe3z2BSLtRhgpEEblhnL4/kdiuV7cDK6+v/qZtpxYinS22d+OHvFNjzgM3m5ubK+SiSVQoU8jpBtPq8eKr6pddR+bTWVnRdVM0mixfqifrH5uZmO3Xq1nNO/K0p4oN8qY/v7Ows66RvBvfStgTlQbvj5Xiwj3yn+/rNN8y43DhupD6egvhOlHPSW33YzhzLyPeYVQRcHbW/v79yEGbPd/B+l3TC/YVqUqEaN3nP+7oHMKrnU19kv3WbJZuuZ6l3SlPZI7eTaVz3cYcHc/rqqlQXtWPVnk69INRQPnPQYKbbAjl2uFI8nBSaAwTHQEMgaej+paSeM9zaNGVNg9RUZScwYpBD13zGy0n3fIbBwSXT87le3VxWCexUzyh9z9GWg7HOYF79J1DVAWGtXdxy4OCFPAmUpMPUEuBKoJD1Sv8ToKyCIA5ACbzp6CovBTXSslSChSRzOvByyPb29tr+/n47d+7cSn3TaeeJevrndZdDn4IlDqzS8/zf06fkBIp8ZYfn5TParKP/dnL9lLy9LA+WiPh2jor8lZVpZYEHDJ0PyqjSTZdLFRzwAAHlzXYfAloeRFA+OnCNQaTqADPKhf2ZQSuvu+tXCjy7TqSZcpGvRhEgV0CAANt1k31d9xUMIK8EwWPHo9QnEvhmHR2Eev9MwJx9nOW5jlUAsHfdeans+9QggWSabNFU8iCIlzcU+GdddL+6V1E1lrW2Oh67rUm23GXo1APgQ3y6PawCF5ea1vHpZpppptsmzQGCYyJ3Dq8WSk4qaQq/RwkuDOWTHBEfJOno9/KsAFbKO7Vb5UiQyEdy4hLouJQDvQMWzvr5stwx1AOmx0UMnOi/B3p8VUNaCeKzoD47RafLVw14EKjSzRT86fWdFFjis9Ws11C+Y4hOccVvD6SmvES9vuppWstbMZimAt69a60dBtpDjvu6OpxAC/NLgI/pUn787XpAUJfypc4rUCAefDVIa4ffLHNwcHDorTfV+DBWXh6ASLbS8xUfusfzErz81AaUQ7JpDrKq9k/Brp5OJrs4BqROAYtOCqz4Kraj5qlv2r5KlytKfbsqj3a0Z2+PYv/GPu/jc9KDXtDJ7U+SW8WLp9F3FSCZMmZPsXFHsYszzXQSqepjl5uHk0JzgOCYacyAR+dyymDos7S9st0xovNTlckZ/JS3O/1VujSbx4GQy7hJArPJ0afjTGK9NBvMPeNMU9WDstR+X82s9+Tlz+q3vxqL9ddzYwfnIadd+Wg2bm9vb+lsCzAIZOv/5ubmirOW8nbZJSffARrTOZDnb9+eoXtc9q7fWobsfLV2cQVBOr3dgwGSi1YL+DcdZQYapKutjZsRIx/cG+1yUrq09SJt86D8KiDjsqTT6WApPcP/VR8mj14XpkmBF9eRJHeW51tLvK5efs9hJ19OPcBfyS7dqw6kcz13HiVLydxX8VBuWoov+TFA4HvGXSbSd1+VwLbkM1w5U9ndpB/ezpSd6sXXhqosl5n3Ac+Hr3HkuQy9b/LDujBgQrvYs3G9cUHl+IGKkq9vPaiI9311AvsG260awxk0SfLRmOx9sqpbTwapDikQIX59JQrLG+tQsz+Qt6GACp85derWbT/pPBvfYsD6uSyHfCnXR/YJ8pJWUqWxuCev1P/G+J69cmaaaabbPs0BgmOioxjPCqSNyTvdqwYJgnfSmJltd665PLRa4p0GUj23s7OzMhCKbzlPdKg0gCudH7RFMNdaW1lqX4EqHTpGZ1n//Zqu+zvQnYexzlMF8nRvyFFKbUvn4tSpW/fmynEWkOYbDqgLFWhxB8mdXBGBjfNKGdKBpZPrgQE5RqdPn26bm5sr8k0AUrzRuZI+8HC38+fPL7cR8HAz8krZClDpN9+QoMPTvHzKKb033FfBUAapbcVXJcsqDVeOJOCanmd/SHrhKzPcqefHV2n03o6R+gv3u1cy8a0DSVf9AMqKeM91wANHBOiUrX5XjrXz53rNQJ7unTp1ahnQa62tgGLJmfbPA1789sMLF4vFMmDAoCH7VQLq/J1svLePA2G1SwLIkgdl4brjAUYFOtQGHoDQ++S9j3p+7MsOtis+3dbpmyu41G4cgxmcHEPkh2NrAsFpbGE/9dVTlBF1Zgo4TyQZ+cQG85Vckr/Afsb/lb2WHqTgNJ9PZdDeKEhAP0PfaYWMZKjyWWdvH7eTVRu4HddvBsSHiHrbs7uVTIbSzTTTTLdtmgMEa1IyvGmQU9rkfKT/zKcCmD2A7yCd+3Q9f86apDr470R+vZdOzhZn2OnwpO9U9yqIwgGx53jRAfLZZ5+ZqVYiJMeM/HGmpwJoBAk9XscM2CpPgIiOBcES+auCSD0Q2uM1ySndSwEBDwzwrRRpeW1rF9uKII71IEDQCoLd3d1DAEL5chaTQJcy9hPKeU98suwELlyPCIST3qb04jHJm8CNs6F6hrrt+bpTTvK+4nbNHV+BoOrkfHfuRd4HHZizjm5Xk7x133XEZVIBQdaXgJH7yz1/r2MCmuyvDMyQn42NjRXAoHorL+qNzigQ0KA+ep9XXq7TSkP9SFsXEiClLNk+lC1lxyABeRRAU+CCAU7yxTFEZStP9e/q7RO8Rn4p61RfAbRUb5cL5cO3pujaFKDH8nxs9OvV2NTa4VU73ibe748rSKDfyV8gEPay9Rx5SeMm25N+T49cjxaLxaFDQ33sSeCfNsDr6TaKafw3g1jiKfV/lxHLctvcCxCQZ5f5ULqZZjqJVPkHl5uHk0LjNjfNdEmoArEpyHC5aezMxlHLcGBflc+0PZrS+Rwk9CLq1cCZ0o6lKWnHkjsdLrc0+8HvdckdGAd46ZoDCTpTCSSmPCsZJL1y2VQOW3L+q2eZf8/57snZZVHJd+haFSjwNqjkNYaoV1V91iG2u1/j7yl9kbSOPasCDb06J32q0nm/7OmL62YC4QTM1faMVH6lz706jwUWY9rK7RQDGWP60JBMhmxIpVtDvI9N6+mSPazyOY7+VeXRA6uXiio9utxOs6/AEFXjU0rrVI05vTr3dPtS+AczzTTTTGNpXkGwBiXQMeW5asBIjsIYZ7Sabfd0vlJgDB0lUJBAvi9z56v6uHSUMywaqOlA9lZYiCjXSo4+O0AaC0x91UZyPCvHO9EQ8BsiyojLSbntQNsQFovFoVlepXdnVrMS5Cct56SsOOvngQAul/ZAga6npe7udPE8gYODg+UMKrcRcEktn+esizuEvsSUwHhvb+/Qq/m4MqJqv+Rweh2rFUJ+JoYHNZg/dY7leECDfDFvn213+UnuKo99k30qgbXkcPtKnbT1gvXu9Yke2NV91qsHitmXqjyYntdcb/ntz1T2XjaytcOvVPUgDfVWsvaZTJcL89K3nvUVEkrL/jpm/KP9TqsYeN/T8pWO3HbAvlbpg9LyP5fRexsrH+ocZ+V79po8pD7ElR6Sm9uJXqDGddav+XXPIwVd3C6Sd68fy0vpxgBb6hCvVWNw6mOeV6KhCRYfs9zecPUat4akgzRJ1TjlOkbZc3yq/LmxgapKZ/R7SsAr3ZsDFjPNdPuiOUBwBPLBrhqYhsDh1Khxclg972rp/1AwgWlJaauBOxVjggkMVigwwGXxKssdRTm77lyKktySc+sOKQdtd6rpPFSOAR0LOZTuWCbHx50ed0QrQD5WvqoHlxrL4SawU9n+bO+jZypHi6Cf7z73oIHeh67zIlgHB4hcAu3L93mugOqo+77kmMT2pqw9MOGO9/7+rQd6LRaL5ZYF8Xj69Ol25syZcomrBxEqXacsPK14IngUVQfLse0SqPWAULJPvgRWvPn+ajqjzs9icfGgPQe2qR6+RcpBRgXUHRCRWGcHhule9WwCYrQlSYbJZnpApwJQ1A1vNw+usa9o+baWK1M+3LPP6+x3DDYqLz/YzVeqpHGxCp6mQAMDTVVgkVsPfOsP+ddZJtxW5ABZdpFn10guHDOrsVple5+TPvAcHdqhpHNeVhpX3SZRX0g+1rgN9QBqj2iPPW3ioTcm6x4nAdKY4uV7Xml8ZdrEC8cwt/myZ1tbW8tvBsxToDT1V/fB+KyPUzx7wOtQBWKST8nnhu738nAdH8pvpplOCrm9vFI8nBSaAwQTaQjsO3HGoLXDxptO0Jgor+etZ728S0VycNxhH0uUBx2z1trSOXNgrcGVzupQcMDLYlqmd+eb9x34elnpvjstVYAgUS9IwOd6eSWnUo6XH6TkM46sU5oF5lsRqjrSyaLTpWAAZwAZICBQ5+vPnKQ3dG794EE/uM0DCsonzaoSsFAOeoZ66zyxzto77eQBCAYSUhDKgRTbJ81sppU1ftAfdd5BcM95JJig3Ah6UhDPdUv6Q3BLWaoeBAwpqOH9gYA9nZeQ0qaAp34n0JT0IX0qGVbXGFjwexVw0710qKDX0WcrvV+k/sFAgZ9pIPLgaQL71T0+S3tDkEWeGCDgjHzSX9ojBmPUd1VnyUD31R95wKjru9dN7earYLwObGOXSRUM6Oln+p8CB0k3XRY+XrBs9yeSjia99nEq+UB+2HEVeB5LHqhi+eRpaNza2NhY2nC3Bd6/kizor7B8toN0zw+rTHYz2Uj3E9x+9PzS6ple+plmmun2RXOA4DJQNdB6mnT/uAH/cRr6dSNhDvYrB9udsuQIHpWGHJupgycHdb9XzUSNoSqS70EEUnK0KyDTAzd0QqrAQHK49M2gQPrNWTufOWzt8Gs16bD5bFhVZ9ZpSI/onFUOYHVAXQUGqNMJvDhw8DL5LAMYQ88n/fBZTAdhLqcEwNUuDi56TqcHObw+qQ3GOrxJXpUuJ91IeQzNqE4h8tKrU0rX49HbjmDCA04uh6H82M8Y0PH+1bORBMIe+BOvKdBFEEV+PKjg/FQBAn6qfB2QpYBdj/g8bSbvpbr7tURJNul6em6orXt67qtb2J7r9o+kM/Rz6Be4LI9j3HfwzWvUG41PfBWot2uqW69tfMxNKxKc17F1mupTDFEav2aaaabbD80Bgol0qSKplWNw1OBAckCPMriLhpzXKeTOSpr5d+fPn+/xODY9eemlpfwcyIyRhzvJQ45B9btyPp1Xv+/bDihzgnM6BwnA+dJfB/1cHeCnQ/O5yvEj6OZsHx2qNAteyTKB89R+XMnAGUbed7mn2X06vRXwdyesakvnMwHoXhkuU4L7BPoTjdVt55PP9dqA9a9WCVXg3gFlul8FLZzPo9i0yuZU7ZvaM4FLl2Gy6w6ydJ35ePv4e+O5kqoilbVY5HNilEak4EBakcE6+RYBz8v7qfhQ4EFjG8t1uVLmXJ0im+WBB6ZjXZMdYF92PfC274FUt8NpFrr69uAObaR/KKc0EeGrd/h7jP8wZnxKz0j2aVXllCBB1df028ei1i5uSfHrvtXEdT31R/9PfU12thqPqiDOkJ9yVDpOH2+mma4GqgJxl5uHk0JzgGAN6g08Ijo61WDqzhyfS2V4Xu4MTQH9lRNSUVoFMeRIMn3FNwdNvYaPh8O545uWHPPbeUtLbofq6Hn68kJ3KJJjlRzFxIs7ryn4wDp5Hb1OyQkivwK+5NNnz+hAy2l2MMx9v0rD/cBbW1vt1KmL2wg2NzdXyvTfDuocwO7t7bWDg9UzBXwvMWWqPOVk8vVkaYsE279afpt03ftDa21l+4HkQ70msd3TTHpqSwdDzqODaJ8tpaw84JJ0jGVWjq/k6v2Uz1X65vV2AKtyeoEa3fdX5zm4cJ7T0t1UT7ePrq8O7l2Oya67LXFg4EDU83JZOJj0j8rw1wUyvW/N8HL8Pe+87nZQ17gFQm3j9sT5kE5QX70tNV5omxrLUn/a399f0UvJgK+P41Yo2RTZG/WP3d3dtre3t3xdqvPoRBvnaXzVAFdp+Gsr1a48ENX7NnXAr+kZ337lbVydmVLx7fdTQMdBdeUDMH+2cTUOpsMdlc6JfVLlSj+4ko2v1eQBhenAz/SqS/YN8e72WZ/d3d3l+EKb5gGRyuYO2eMxAZSU50wzzTQTaQ4QTKQxwYHWDs+gpMGVwHBsmVUUm/dJaVCugI7zyLzSIJ/ySOW6M0qiQyMnT0vOxRPrSUCRHCaXlad3J2bMTIDPUntghkEQd/pZD3d6qwh9JatK9pWDSiBPucj55eF3ysfBGZ1W1pdOFM8SYICAgQLy0HOYKZ/qnAF3uOj0Jjkk/Ut1ZjBCYJNt5eBWsvAgGJ15f387ZenAuQKVqofL0HXKSU6rgwKCwLRKgmW21lYOFWQ5bCvpQMUr5TwmgMZrCQx5n6fDrUM42c6sj7epqFp9kOTqoNvLqHQ9yZggdeyY4Lyk2Wzl40CL7eAgRgGW3my/z4J64MrL8kM/3c60thoI8nKrVS7UbddV2aLNzc1lP+GMsduEjY2NZWDP5XDhwoW2sbHRdnZ2lnXzMUE8uMyVvgKxPg4dHBy0zc3NlTMQ2J69wADPkWA6BuA9jeur81S1CdOyrXu2fQwpqEBA7raafDuvrmO8Rh1ggICBAI5pfvglAwQuA7YT+47GfunU+fPnl+ML+5D0UXap57OkcofI27eyXWMDDDPNdBJpSp+5lDycFJoDBFcZ+SCUDLg7vQm4OvXuTXVKPb/kBHgwoiqDgymDAb7vj7z6YFcFX5i+GmSZT7qfAEMKQiQefUbAHYAqSJAGat73YE4CKM6LO3s6sVt5OciQw1TVn064f8sx1ynQPnvuM/6Us6fx1xXSiXdHmPJOjqO3m/JJsvHZaNaZ4MJBhzuS1F/KgHw6qHId9Db0a6kPTAEX7qiyDA9uJaJ8JIsqIJRAatVGvFYFkdI1gv8EJlL+vOegz+ua8kp9sGrH9N/bM5VZUeqjlSPktontqiCRv77TeaB8fUxif2L9NJOfxrPWVvuj9xOvI3U+gSgPzuoZ2l7nUTaKQQ/95qGGHJOq9mL90rU0U0xeVH4au7z/8pr/ljzZzxlQ8T7p7cz29vYYqjeDkkkOnGGv7onvBPqdkjwTX257GMD1N2KwrdUmXJlCfhX4TW3ltonjmcvJdYN5TaWxfl1PXuxzM8000+2L5gDBEWgdw7mOoXeqItlTqVrZcFzkzp5TNRAOOfVVXkM0lGcvEDCVprYzwcxx6EgCW+vmw/yqj6dxGnLukkNVBRAq4KNvOu8VVbPRFfCr6lmBgN5/1jvRFB1IcnFwUMlTaaZSVfcEkivAn4DamDr27ieQrO9kZ4bkfNT+42VearpU9iO1K8ts7XB/SnUfasOhvjSmPZLNkF1xEOcBJC+DwTHOOvvzArGUQVr9tg6NrfNQ/Z2HxNMUPi+HPk8p3wMpQzbYddtXNfUCdp5fb3UkQXYKig/V73LK+Uq36UwzzXR10RwgOCL1ouSiKUvDWzu8J7MCtgRCGoCGovKeZ48PPZP4H3uNg2TFn57ja/j0LA+g6jk66TsFHKqyOYjrupxBB0Nsc9VJgCfN5KTBnul5bYwj58T66ZuzID3qATjOqnDppX5z5QBnYzirzlUJ3iZ8xZovG/b3c/cAvM9uuwOvtuCMDT97e3srS3olT59R9K0SDiy4ZcMBcGsXZ2id9zEOqbe3y8WXO3OGyvcvez8dAoO+BaIKCFFOKbAi8j3wbCdvQ86Apj5VyYP5Onio7Eh1r0e9QJSDCMnHn3U9GVuu+Pbv1EdIqa6UmW894vJ/1wHaT6Zh3ZSeZSSdqIAY7STr7Tbb7/N1rlxZoi1sXCXl+rq5ubnkh2eK6L/bKLcx3H9fBT56fZ12jXKsxmTywZUgvr2AK4UqQJ364VQ6depU3LbkPFfPVgEm33bg5P4SdY1nTXC88lfy8rtqJ18VR/7YPhpvJH9t7xuSK1d29QK9LqMhSunG+LAzzXRboXVt2u2R5gDBGpScKle63swc0xOQVoCOeaelxDTsQ0GC1lYPFBpaRXDUFQbJofFBnk7m+fPnl86i9gdqkHTnWs9UDq8PpD6r445HddI2Hd7EC/lJPFVE59Xr48tEp5Dk5gDOy6XznkCfnCAFBra2tpbf2kZw6tTFgwjpWHHrRVqiShCr8wXoXMu5TAcRusxdj+jU8fkLFy4sD4hKS2/FlzuUBwcHh84ScFBCoOcHpVEOrg9bW1uHZF/pDPXJAx7UW/33rRIMYCWdoCwZJHGgl75FvuVC15jO83TgnwC9H6ZIGXH7iQdKyKeX4/bbr7OPe6DLAXoVaPNryYa5fJJse3akNz44Hy5Xlzt1WKTfKeDJ5fe6Rt0XUNS3B8MqPeE3bZXGBefb68fDFPWsApkO3tMbVrjFj0HRzc3NZUBRfY6/9/b22s7OzlK2PHSQ7VPpRmVXfMsX68ugJ4MEOzs7K32D7XQUSvbD9SrVsUcpcOZBKPY59yFoF91WtbYaHGBgmx/e1/8qmHXhwoWVFSmpD3oAl2dA9OTj6atgOdNPlXci9YeUzwyqZprp9kdzgGAiuQOra60NL2F3mgr80qwBAci6+TolB2DMMyKP4KfggH77qc08IVjXK3nrNwdh3+uuZ6vB3p9PQJR14jN0YDxg4M6BE/PrAZGxbUl+fKa7Ry4Td858BYGvHODrwTxIoPpUAEVOK2e6CHopxzQ7XMmP4ILOms+mKT+Vr2f8cMb9/f2VWaZKjl53BzbunKeZYwUkKifcP6qT32ddfXUEZZgAq/M3ZgUBeXbQ54FPBgiSg50c7uQc0y64HLw+SXa8xzSVXa0o9TMHfL2ASi/fVL6DpzTupICD15P2hUERDxzqv89oqnxfpeJ9gQDdAwO+2igFCZJt9VUBqkOabaWOMiDg40LiieMHz1fRbDADnP4GBPHkQLdqZ5XtJ+RXv0k+hqXD8FxHXE8q6vkDY4NYY8ntB0ntnnwdDzZy1QvtOW0azxzwAwu5iiYF3fxQTdc3XeNYo3boydyDC952brum0tCzyZddxx+caaaZTj7NAYI16KRHUxOgvRxUgZ4UAHBnfUoZvfYZcvr5/OUaGN2BHyqzF3BIqwI8TfWf1wkMec0duJ5DJ3KZpnts7wrA+XPkoWrTITBYOV0JYFUyTfcT0OnVp+I9gT/n3+9X8qz0mk6wr2hxGmrrKn0KQul3Ra7nVSBhiuPsjjyvr0NHsQ8OTo+DaE+n9ElPP9TXq37k+TPvIbtbBVrStZS+ak/vI4ln59/rzUAXgwu8z2DEGNs0hRg8SJT0nzagRz3bx3tV+UO2emiVYirX83fA2ktf5T12XBvK19tU/13Xk332SQzWsbrmExZHDRKkOsyBgJluD3Qcfec4eDgpNAcI1qDktI81rJVjPoZ8KbVoqsKlGeuKx7E0xinV4FzV+eDgYGXpni8X7IGNKojQc37Id3rOZ/8Inqp8CMpS+cqnxyPrpRUVPWL90xJv31fJ5bJbW1vLLQM+k+JnDKR69wAXZetOTm/JpOrksnBy5555ejneLiTXsTTD7Wk2NzdXZM9vrt7wGXqXE3nirGgv4NFaO7TaIoEd8e16zOXT5F08iE/qUrXFgPer3wSV3o/p7NOu0lZU4LNa8dNz9B3cHoWcf6c08yhKM9dV3k49wF0FXhIQ7vUp/vc+7LImaGadK72kzaZu8tlkb5KcfDzhTPKQTjiA9hU9Pq54XflqPMlGdtX11/W9B/jG+Aji20/E14qGtNojtX0asyv9qPhQWgfypBSETHlVwQmV3zv0mHpFG+RvJeBYV9kuljlmZSHHf65k8noy72Sv2Y60774SJMnnKDTkt80000y3P5oDBGtQiiD7wFgtG2capZsyS+7OQ6IqkOCUBi93tqYEMBKQTnx6nROY1DJJLvXTgM5Pb2BPjiwBvreLeCH4aK2tlJtm6N0prcCol+t1d+eUhyTS8Uh5pn20+hbQ59kBp0+fbne84x2XDi3Tnjp1aplG39USe3eIHFCyPfgMfw9tH6BM2Yd8ab2WObNdtcReSz1ddiqDOkSHkkDbnU0HHOn8BQfJXvbe3t7K80zn9oIy5OFXFYB2GTJAkMrxMpUmbVepnHH9HjoDwx3rZLNSIIC6oq0hvrydbZrKVjkVmHYQQlvlqyuqQIST2wrvo7Qh1bMO1ofK6gUJUnq/50ubU3rWpwpSJZ69XzOYJRvpNt1l5LP2LHfMrDlf+ddaW24VYD93268DDtnHVTfKxXWT+8l7PNF2ebt439A2B/GtMhUg0FYHD5pSlpJz0mEGNVIgQXwke+V9hH08jQ+eZ3XNz7FgGa0dPmtAbcZvjmc6X4Jb6ahnAul+vgnHZ7fL7s9VYxv7F/XFP3t7e213d3flrIuxcvN7la2fmt9MM81026c5QDCRKucrpWmtrQyMKd0UI+wglWW0VgNxv5YoPUtQndKvEzyoeNVAy5koOUFbW1srwC0B6VSvCnC2tnogj7dBcqqqMpyfodUDeoZOVwoYJaer2mPtzg8dKJ4boACBVg1ce+21K2cIMJjAwwk56+KOMevsQaHEO/nn4WdOXn+2G+XLst2Ja62tHHrIGRgHqNKj1trKDKA77ZKFDhf0tmQ+vFY5tOR/b29vBZA7aGbd2D8oPzr0KUDmgJ66VNk013HWK+XpdXCA6ICObew8O4hk26tNdcq888X60e7QiU/14n/nxduPlPYlJ/LAQJL9GGff+ajaz0G78+L3va9JvuSZealPCEwxrxSE1X32PZXH9kt21IMCvTr36k2dTAEK10uuotJzSk/bR/1XGslvsVjEQGXij+2T/kvWOjCRbyngCgKVpXqqDgSnmpkf8kV6QLJnO8R3CiZ43mlMdFvhfHjggYFtXxV36tSppT+RAgMc56X7lK0HCcgj7TH1geT801YoGMBDMM+fP992d3fb7u7uMhDkuu1t0/NNe9SzhevmOdNMVxP1bO3l5OGk0BwgWIOmgONeEGBo8BjKc2qAYWxwIN2fEgyoaIhfB3wXLlxYWcqdnIvqelW+yqnS04BwSaSDD8/Tn0/1pBwTQKqe8fyqwdtn3HTPQRxnT7jUsrW2soKgAn9VfXU6OHmk45TqQJ1IYCK1tTtI1BkGdiRvd+ySjEX+eiu2AfngagF3CL1e3h4puCJHnjrmTjz7IOvMAEWlQ5RlAno9G1DVx+vLfujXHBD28nM9qZzhoXYdA+oTuOm1XY96/bhK7/rigN31f8gOjwFgvTq7Lrk9rILQbht6oNzr48EA1iHZvlRf/+2rjdiXPC+CfeXjp9Qz7yQDfQtktnYxOLmxsXEoiJDI23ZI3xiEcXDqB70yyOjB22SDxwbcEym/XnDA80rtUo01Q2XrO41f/PZxzcd26r8Dc5blttrTjLEHtPH+u7VhW9eTxxiZnSTQMtNMM10emgMEa9BxgOXWDg8mY430usY8OXh+f8r1qTSWb/LpwC8N1JVDrWspyi6qwI3nkQbo9EwvWOFLRCsaCsgwbz9fgE6Oz6DwNx0jOoyVHJLc/W0TDnTFAx101p2vGyMlAJ0cqDEOI2VG4J2CPGkLi6dxsM28e45zAkteL+WV5EGAMVTPysEe4nEsVbJxntP1MYETDyQk4Dm2fwzxNFSP46CpulI91wsCiTwQk/JMz3sAwT96loA+tYO3XW+8UTr2x9TWvQBFr54kBnk9XU9fHCCKj8r+uI1Js9vMO/0eCmbw3JExVPVPJw9Acgz2Z6t+sw7Y7AV9xhLb0VcG9cod4xuMeZ7pk30csv9Ve/bs3djAw0wzzTTTOjQHCCZSNaBUhrgaiIdm7XtOnPKoDuzp5c8ZAoKzagBaJzjgz5CfsXXXssyNjY3l0jsCYXdgHWD1nFiW47MHdO40sAsIk9I+bgfo4mWoLUXJkeDznK0TD74aQNsFJCeuEtje3l55ZSG3EbBeHnAgLyR/HRd556wa7yXd6DlP7kRxz316fRflT53Q9YOD1dnyFNDxWSUSz2tIgaUqwFTZB18KrGs++6Z8vAzVyevK9F7XxNcQePbr1DHnqZptq3Se5DruwI7t7tsryFtqV8op8U358hnqcC94N6Z+PT2pnkn3+F0B1YqvKn8GYbl8XnmoXWSbSeKB/Y+ByJSW/PgKnKru1IXUzqndXQZVX/S+tr9/6xJvX0HkAQLaZ/IlPVHf5vfGxsahwwS5lJ02TrzwFa1M1wuwJqrGepcZt5ZUckr2xevv6dL/RGOCOQx4e/C7twJO/pNkTH+BY4XbB5e31zGd18K6MA9+0qGzvMdnx/oOQ/Ick26dgM9MM12tNCWweil5OCl0+d91N4Je//rXty/90i9tZ86caY985CPbf/2v/7VM+0//6T895HQtFov24Ac/eJlmb2+vveIVr2j3u9/92pkzZ9rDH/7w9ru/+7tr8+egJhnuIUUcs1zMBxF3inuzAJyV7JEvqdO1oeenBg58mSOvucOlOnJPHvfhuSPFgdX3ClJmiee0zNCdAvLhAZbKEXG5Dq2CEKVBPDnfBPdbW1tte3u7bW5utjNnzrQzZ860a6+9tt3hDndo11577fJz5syZtr293ba2tlYCCvqvA5sYQJAsJFu2x9mzZ9stt9zSbr755nbLLbe0c+fOLT/8v7Ozs3Ru9Xz60AFmOWpzpkkndSeAweAAV1FQbvr0TrumjH37hetAAqUEAD1Z7O7utp2dnaXszp4923Z2dtrOzk7UfQ9IeV1dNz24lvSvF1TQNQ8i0fFmn3MgSH2mvWHbVXJtra3IL9lQ73vOfxUgqPSGPIuGApwM1pC8nUipHkO6zDq4TKs2rgC42yjXM9UrnenhQcxTp1bfgsL2I28+rjkY9o/2gzNYmHRMQI3BTvVbt3Me6HVZyBZx/NGBcXzHfWttJfgqe+Hf11xzzfIjWy37I348KEpe0hhInns+RQq8sl2Tv5HGTz7bC+iMmcnvBWsqW+TXpG8MmPuKOn6ndnY9TuV7W/g4Tl0TH84724njXZKv+mHyG5Jd7dHY4ACJslgH1PzRH/1R++Zv/uZ2r3vdqy0Wi/Ybv/Ebh/J/2cte1u51r3u1a665pj32sY9tf/EXf7GSZmdnpz33uc9td7vb3dod7nCH9tSnPrV9+MMfnszLTDPNNJ2uugDBr/3ar7XnPe957Sd+4ifae9/73vb3//7fb09+8pPbjTfeGNP/wi/8QrvpppuWn7/5m79p1113XfuO7/iOZZqf/MmfbL/0S7/UXve617X3v//97Qd+4AfaP/pH/6i9973vXYtHAs2xhjOBwgSaUxnHQdXA0ptpqvIhDS0hXZdPDqIOCnwgTQ6PBwlc/skRqMACnWafMeg9l+o1JTDgzxEg0BHmGwfknPqHjnEPCPu9BOrUHgKzOzs7S6eZhywR4HMGjM51ek2XPgoC+N7aMQ5TBfboUHowxIFp5XxW4JLlDjmiDozoLKbgQZpd7NWVPKYZtErXEvWCBKnOPT2v8q9k2OuPFSCqZKJ28DRj2vC4aEz+QwGLMbYiXU88MI2+vZ+57aquK+8U4En1dVtfleN2nO3ea38PpiT7Vq1w8P7Jvpnkw7ozUOAft8kK8vpbYlKAgPz0gsxjiIENltFaHbjXPdeZRKnNe/1pHZDrY2Ky33quCoqNGZcd3LNdXPc9OJEotWkVdEj9Yx35Ddn+sflMoZtvvrk9/OEPb7/4i78Y77/61a9ur3nNa9ov/uIvtv/5P/9nu8c97tH+4T/8h+2zn/3sMs3znve89uu//uvtLW95S3vnO9/ZPve5z7Vv+qZv6r4NZKaZKkp9/kp8TgpddQGC17zmNe3Zz352+77v+772wAc+sL32ta9t97nPfdob3vCGmP7Od75zu8c97rH8vPvd726f+tSn2rOe9axlmje96U3tx3/8x9tTnvKU9mVf9mXtB3/wB9uTnvSk9nM/93OXq1qDs04nlY47kEHyQZLX2cn8fi+/5Cyvw5Oe7Tn5vf+s25DRSGBGjqg7R9WqhmpGtlcPd8KP2zBWzpY7SKm9K3knuTtgGJO2tXqW2cF/onQ91SulH9KJXv0vFQ3p+RgH9Sjljem7Y53gq4GOYneO45l1nRXX4YpcL9KqjqQ7Y8cT8TE0a+5l8v+UYFBlk7xsl00vyHMcwajec2PHxOqZS+HI9kB7FUxwm5yuV88dh981pp+MsT1DNn9qmVc7PfnJT24/9VM/1b7t277t0L2Dg4P22te+tv3ET/xE+7Zv+7b2kIc8pP3rf/2v2y233NL+7b/9t6211j796U+366+/vv3cz/1ce8ITntAe8YhHtDe/+c3tf/2v/9V+//d//3JXZ6aZbnd0VZ1BsLu7297znve0H/uxH1u5/sQnPrG9613vGpXH9ddf357whCe0L/7iL15e29nZaWfOnFlJd80117R3vvOdZT6aGRV95jOfWf5Ozs46TgrJBzIt8z8qKZ8KAI6N8E9Js07aNJC780enjBF4zrokGnKGE4CsZtncKU1OXgKWzIP1GyLNSoi4hFerAra2tlbePpDeAc3zCRhcEE9eJ5674E4vV3fw3mKx+s5sfQ4ODpbv5Gbk3/XSgULPAVf6g4OLe8S1fN7bxfWcRL3T8t5qeX5yOKkTKlPtyiXTmiFSPh7UqgJIJD5X1TU9XwUrUv7+nwEVbm+ZYjeGAjK9/ukHsrGfSgYVmGBdx8gq6ckYvWltuC/7zCZ1k31HZY5tsyFi3VKQ1fNkW00BmA6Ie32uAnZuJyWHoTFWfc/Hugq0+TXOdrO8VG4KkEhO7JPkLemu7Ewa52mjxY+vAvIxS+VXY2aqN9NMIdZ3LPXAvxPr49fZh7gyhNe5EsPHFG/j1i72DbWLxqlqC0CyZ0OyqFbB+UoU307DbTVDcp1CrhM+dvfos5/97Io/rC0yU+iDH/xg++hHP9qe+MQnruTzDd/wDe1d73pX+2f/7J+197znPW1vb28lzb3uda/2kIc8pL3rXe9qT3rSkyaVOdNMM02jqypA8PGPf7xduHCh3f3ud1+5fve737199KMfHXz+pptuar/zO7+zjECKnvSkJ7XXvOY17TGPeUy73/3u1/7gD/6g/Yf/8B+6y5R++qd/ur385S+P93oGtHLy0mDiA60/s06QID2TrjnIGJPPcRLzToMrHUSfZU5LtVWX/f3Vwxt9tqdylpLjxQ/LJmgR6KaT4UtXHTgyr54M3NGRM6T9qmnbAAMCfEbBg7T0nDJ1B5k66UtOGSBwwEOe3fGqiDKogEtybBKfSfZyyhWwcD3Q77QFw9OmYJXf47kY4ssBT6qPL6H2FR981sG77lEe/u1UAVIHWJJDtXxXvLJNRNSBlLeX63KkTBhkSXri7cTvpGOVXJItJ8Agnzyd3m2ngzvpVLVUPv2unHeXddXm+/v7S51PRFtT5VMFLcYCC/Irubic3J6nPL2f+zhL3UyHxnmfT/ridU71d5vmOkneBPZZroCf86zvBIR1aC8D4y4/8dYbvz2oTvBbjZHeHuTdnyF/FR9VcETycrmksbVaHUf5eR38w77DPqnzJ/zsC/LD78omHRwcrGyP1G8GzXnukm/P6523wjKqdvJnhtJWtkj0oAc9aOX/S1/60vayl70slleR/Pnk63/oQx9aptna2mp3uctdDqUZgwdmmsmpGscuNw8nha6qAIFoaGCq6IYbbmif//mf3771W7915fov/MIvtO///u9vX/mVX9kWi0W73/3u1571rGe1X/3VXy3zevGLX9ye//znL/9/5jOfafe5z33KAVF8jqkPySPddEB7wYIEKPWM0k5dXud88nkfyHttMra9fCVGGlhTua21Q++p9gBA4okySU5i9Un8OFjhjLs/Tz5Fnk9youjscA/8He5wh0NvJfDZEzpHPJjPAw6sl5wUpqHzJEdGxEDJ6dOnDwE58ePBFZcB65vahvc8DcGaP0c5qCzxkxwuynCxWKy8EYJER5JBAt3Th29ccGfUAV0CCNU91/UhgOi657JL9/SbwMZnv9MzVT69elWrRci/Bwhk56oAQVX/VPcKEA1d8zolsJtmPcWjz/gOOepVgCC1o9edhwAmebmOjxnXWIZ+9+w+7/kBqGPHkgTAaQOoE2PHP9fVJPfU39JKqtZW7drGxsZKGbS5bqdFnkb2VfdchygDt+l8huRBTdaXtpLXXVZ+bwqxPzhf1dtRkj3mQZTez1y29AH0O92XDgio8zBKtYnqwLLFfxoTNPalN1D4igKeO8PggOulB3l8fBhDqe/12rq11t7//ve3e9/73sv/U1cPkNbx9cf6lzPNNNPR6KraGH+3u92tnT59+lB08GMf+9ihSKPTwcFB+5Vf+ZX2jGc8o21tba3c+4Iv+IL2G7/xG+3mm29uH/rQh9pf/uVfts/7vM9rX/qlX1rmt7293e50pzutfEhTDVQCPZeSEthahy4Hr2MGBB8c0/Xe8+l3xUfVVqm8BE79Oaar+HJi+9GZFthPpzb7IVx0IocCHyQPXriD7E7zmHtp9Yenp5PUy7+SfwKllAFXUww9kwBd5RxXMvAgQkpb1SXd8zaqgD15S/+H+Kj4qX6PpXVsyVR59YDmkLzGUNXPx+Q3JLuptqwqI6Xp6SIpzdIehZ9EHoBcty2qfue/e3wQoI4ZM1OfcrtWjTeVrUn3ejS1PzIQ0Mv7uFcMVoGPMWmdqoACnz2KbaratddXxowhBPE9+1uNmdUqo+OgdfO74x3vuOIXrxMguMc97tFaa11f/x73uEfb3d1tn/rUp8o0M80006WjqypAsLW11R75yEe2t7/97SvX3/72t7ev+7qv6z77jne8o33gAx9oz372s8s0Z86cafe+973b+fPn21vf+tb2Ld/yLWvzmox2DyQOgdTjHgQc5K3zLJ/3gfk4AgdjeRwDzCoQOcbpGQtCKpCviPYUx9KBJ2f5dY6ABwJ4vfcREE6voXO+E3A/ODj8rvk04+Q6zWe4j9JfZchAgG9bUJ7JOeo53nTKqjcSUAZM54EVluFbWXqnu/dA6NRABB3MXpAiAZSx/DkvPdAq4JnaIOU9JvjQA2Reh8RzWl7cC3yleq1DlZ33duoFmSr59AJKSd5pJUvSh1Rn56e1w2DS65H0NMkl1T/1L9arKmNqe1Qgy+vvNi3VvScvluFl0174fnLubec77tnf03J5BjmH7PuYIENaWZAo+QNe30Tpegpes47pLTrJnlf9fcjuOM/ejmmW3+V16tTFrXz+YRlui311gY8p6ZWelW0d075jA01T7x0HfemXfmm7xz3useLr7+7utne84x1LX/+Rj3xk29zcXElz0003tT//8z8fxAMzzZRoaHy9XJ+TQlfdFoPnP//57RnPeEZ71KMe1R796Ee3X/7lX2433nhj+4Ef+IHW2q1L/z/ykY+0N77xjSvPXX/99e1rvuZr2kMe8pBDef6P//E/2kc+8pH2VV/1Ve0jH/lIe9nLXtb29/fbi170orV4TI7GWHA4BUSuy1e1XL0Hlv1+2qIwlIdoyuDCJX8pHx90+dsdQJLuVwA/OQieh5bNc9+nnucA7/t3negcsF5cmuiOk8rnFgJtKdD31tbWirOYwDBlQGd2sVgsZc/9keJRWyYqAJDq5oc5eVuKxCPl0QvEVDqgZ9M+Y8mXZTD95uZmmafrRHKQHYgl3XTnlQ4t60Q9T/pUBeck88VisXLOQQ/opz5BoE4+PL3LikGDBDTZxs47dVWHNyZglc4fSHJwSkGnJAt+kzemTff5Uf17gNf7pR++6PxVIMaJMpDc2L+op6xrAuG0DbIPPFshydB/Vyt1WA+Vw76jpfh+3scUkOO6v79/655ut4uVjUx5s41dXzwAQ5nr47rkB5fyedkrLaWnbin/7e3tlT6f7I/bGJbhqzf0W3rDdqRs+Dx5Svkm8vtue1zuXDWXAk1e18oJr2whdVFydl6Yh9pEdfHgheuExlR/PaYH0Pf395evAWYwfWdnZ+U1vz0b0PMbvf7JHvdstMtrCn3uc59rH/jAB5b/P/jBD7Y/+7M/a9ddd127733v2573vOe1V73qVe3+979/u//9799e9apXtWuvvbZ913d9V2vt1jeUPfvZz24veMEL2l3vetd23XXXtRe+8IXtoQ99aHvCE54wiZeZZpppOl11AYKnP/3p7ROf+ER7xSte0W666ab2kIc8pP32b//28q0EN910U7vxxhtXnvn0pz/d3vrWt7Zf+IVfiHmeO3eu/eRP/mT767/+6/Z5n/d57SlPeUp705ve1D7/8z//yPxqkPE9nCI6DRUQbu0wqE+gJ6XvAVOC/HUiwilIMIUYUFA+3IM+FMGuIvP61uApx0rtQFlXANed7wrU0uEV73SeVJZm+hNVARs6PXzDgMr2wwWvueaadurUqWVgQN8+86LnK3Cr33SMOIvB+juQJMh1R0tODmXrQJMzMEpHZzABVuphBdY2NjaWzh7brAKKDBA4r3Ti6USy/FR3yp0ydCc/gRTpq+qrOhMokE8H8ufPn4/ySeQgwT9Moz5VOZIeeNB/Bxz+nMqg3Fg/zrBWIN11gs/7dd6v/jsg1H1vP0/r8qC+9FamVLyQf9ddtyWUmwdTeL2qq+sR7/vBeq530lfKKNkKtpP3qxQ4TTIdAkGufwS24ikd+prk4m3lIJn1kMxbWz1kUfrL/Jk+2RSNH36PeqX2FKjnqgSXW+qzqY4+zrtcCJ59PKdsqmASy2X5apPEG/XAg9/Mi0TbKH5S8Ic2R2Of6kR9UT1U1/RaYaZN/Y7nF1AvGChgIECHEypAkM6xGUup/dnXhvrUUJoheve7390e97jHLf/rTK9nPvOZ7YYbbmgvetGL2tmzZ9tznvOc9qlPfap9zdd8TXvb297W7njHOy6f+fmf//m2sbHRnva0p7WzZ8+2xz/+8e2GG24ofa2ZZprp+OiqCxC01tpznvOc9pznPCfeu+GGGw5du/Od79xuueWWMr9v+IZvaO9///uPi70VomO1jkE9Kgj35xMYHUu9FQJet7Fljll14HVIg7qup2tp4Exgxp0uT1uBBXcc0nN+L5Hn72cLOHAU8PVDBrn1QP8rIOJ168mwcthbW531dxnQ+SFYlpOkNOK1tYuAlrKmEzrUVnqutcMOJGWi/JSeQQTPU/WjY1+BfweQvQCgO+6sM+vOfByADvHu/SCBXebjqyt6+jtGr+kks+0qp9YDJCyn0kem8/4schDnPLrc0j2V0QM63jZ+n+lYV+fPn03tyaCHz54mPfR6pmtD5PU7OLh4UJ6uq2169XU99LHAdWTsCpEhYjmuaylfbwvKlnbPn3Eb68ED3vMAgey121sGCxkgZRuofszH5Takwy6DHrl8knzdNla8Vbrh+sODGflNStd8XB5bLw/Mkl8fW3itype64N8MGnjA4ODgYGWLQbKBvXqMpTQ2KK+Ubmo/fOxjHzsYhHjZy17WXtZ5A8KZM2fa6173uva6171uUtkzzZRoHT2+FDycFLoqAwQngY6jkY8SGFgnfwfrY4ITQysfhugoAYuKkvOfAHD12/PqkTsKPZ5SOjk6PhD7DEQCHXRKUlryt07d6Mj5TLsDPgZI6JwmJ1nfXn5KmxzLXp0SwNb/VN5YSml7+TmA4MykqJqdTeQgZEjflK/rVg8IO19jHcrK+TzugS7pEZ1W13l3aL3fpWd5f0jfUvAipUlyGNNPe+CiItcl2vTeqoQE5IfqPbb+/r/KO91j8NX5rOTq6aZQZZeYfwpYe7qhYEdlG/26r/BK4IzjgK8UYDqOFVzxxuCM24bUxpfTgU06mexpqnMvOFARxzMPbDBQ4KvaVF4ag6uye6v3dD8FlxigHuPDkPdLQScJ0Mw000zHR3OA4BjpuAzp2MDBcQQYxoCXFEiYCvx9KTFpSj24hHOxWCy3GCgCz/z8NYjVKgA6CAnoK0CSZg2Y/8HBxVmfjY2NtrW1tXIQlc+6cBuJ9uCKuCrADydMBySJl+SUuKOaHEHfz6q6ulPL/P2ZaokzyyaYIS+SAWfMxjjCDJ5whjO1ay945I6ZB01Yfvrdm8FLQYzeDDr1zfl1OfbASDXz5v9TWT0w1APX3tYEKT3ATP1K2wrSs5SX8+V5UnYu06GAlNuC3jMOINxm9IICqQ29fXndn08z+hV/tJHpXgp8JPDKspVfNaOt39peJBDrQQHvb7qW6kO721o9VmmMSOBOeVNutNkO6BzYeV/kUnJPx1nhZONoQ9lO4p1lKF/Jc2tra5mnxkU/dM9l7H3A5ZJWrng6b49E1Ct9eE5FlUbXvbwqOCA7zvEg2TsG1qrVcc5TtbWAZffGC64S8HbxwwnTK0lVThXISX02XeuR64XnNdNMJ5nS2HkleDgpNAcIjpmqqHI6MI2KUjlUiY4SGBiz5L8id7SPe8BIzkgCawQem5uby/9cmsngAA/cGwp0KA1nW+Ro+L51OmziJ+3bpWNJHugc+f5TbiXQoYQC0JubmysOlupdAWD9d0db/31rgPghmJcD48/SYU6A2nnwfAi89LwHPRxgSDZ01nozfj09dceO9WDAwJ3VJIcKuDIYQue/ynNoSamvAkr1oLxI3Ied9CX1ce+X4j+BC4IfBvII3Kr9owRRLqcqQOCBBH2rLAIul4sD6kSpjYbsHm0NlyPTpgz1I6ZpbfVAPAeplB+fYzCD5fqhpuQ7gR/PX2kpO/Ls/ddlyWCot0+vPyVgT/kQFDKN86i8/L+upTIqW+dtIt3d3d1dOc/FAwTOj6dTGsqS9tgDBLq+sbGxPI+F53icO3du5ayCBCT5m3qovKsggeup/09bwNxuV/qYfntAkPbJ+wX7bJK32zHXO/GpLX3SMT7nfTPZGuoK3+7jwQGdQcCATmt1cM5/J6KtGeOzpSDEHByYaabbH80BgolUORwJyAwZ195A7ffSAM30nk9vRnMsJf6nPF8FIshblcYdFKVNDoHPYHMAdwevF6QR0aEnz9xqkQINDE54PQiceJgTgwWc4VI6BQa4asAPS2K7Vs4J73lgg7MYCdzKqVFZrvfeLpQv0/k368rAQBXsoLNHWfhsvAP7If3tOf4VVX1dsqOz6wDHnWjn0QHaUJ+rggPJJqS83XalfBzke5skflprK4eIJsBZATDvq2m2NQHZykbyzAvn+ygBAvYnfpNnzmQyKOEypgxaa9GOaGbRAURVf5eR8+bjhK8oILGtuMrFZeK2knl5X5Ve+WFstIU9UvoqaF4FMargQ2UvKv3kdQUHeOBcsqOkVL/Ep2w+A9EeFJGNlp5pBYEAabLTahP2bbdPzlcVvGUeVV/1WXj2kTHtPUZu9Askh2TT1I9SuT4O94LRzMvLoax8zOUKPF3nCoKhPlD5l5VNnkq9oMRMM81026c5QHCV0joG/XLS2Gj0peZB3w50ErgaAlBDNBRU4G8GGegsVwO+0vfeIuBlOPXq42CsetaBDp+Vw1KBPf8/5NhU/Ay1yxi9G6ufR9GHIZ5cjtV39dxx01R5+PVK51xXqoBBL+8hnseCeXea/duDRvweE5A5CoCZSgSk5Isgz0E4QZL3aecrAQt+JwDiwY0x+TolW9mj4x5ryHsK1qT0PZuXAl36n1b4qGzmQX6cPPhSBc4UEODY46DcgwOXytaMoUvlP6RgznEA5tbG6esY3rz8KnijZy43XQ3+3UwzHTf1/JDLycNJoTlAcAyUZrd6NOSMtJYHbi7dTUs4xYsPMmOcoCHirMZRB49qNUQinjFAkMpVAwTWutbarTMq3Oev+lNGlUN2cHBxliwtDSZo56oAOWm+zYGzR3wto8/guUOXZlzIN/NP5I6SO64EIGxTPztBS8UZIHDgkPIZAnT+PGdP3QFOz1IX2F6Up+qQ6lrJzmeKeC3dYz0cgFYALT3Xox6A4Iyu1721w9t2Kr1JQNrlWDnbLJ+zX779J21V8WW65Mc/QyCLOqP800GhGxsbK7yklR0VeVskvpKMEqUglexYAjspkNHjNY0pyrP3ujCfDfZ29sCQ0lYrgRLRflbP9PSN19iOni4FV9JsdwKA1fM+++szw84f7abLbiqI9bHHxynWa7FYLLfHaezzg/AoM/cxqrIpw954ngJyQ/Xrka928Hush/wH56Eau3r8V/1AH75imXbIx02Wy5Vq6XWkl5rGBKVmmmmm2yfNAYIjkg+MDsbXMbS9wZnOSQIwGhiZlnz2lk07VbxPCTZUchD/Q3zt79+6n3NjY6MtFheXCmuf5d7e3jItl+EfHBysLFuVM7y/v7881CnxlwCdBns9x2WJfAUhAREdetVjZ2dnxVGstoHoo60F3DPsjsoQ0KfDxFcrubOifHVP+yNTWn/G69EDxAlYKQ3lymBKKrO1wzpdve+9tYuvVUzLNitAwq0grCsDNk5JTpTP2OAU77NdE+hPtsDLVD7SA8/f5SL9ZPtyBQkpBdBYH5FvB/HggPcbB0H6zWX6JF1LgbcKTPtBpon3HhDvBXb8+Z7tpSwYGKgCKAyCVfywfdNSZ98mQL5TPxNV+sv0yUZVMhKATWC1Cm54mSwrtQdlmtrVeXJbmsA+txL4FgNvJ7ahy5f6XNkUl4UHoGm/dV3gmAf67uzsrOgY+WXgIPkflF0auxKxv6dtBGmFnT9P4nhHvlIb6Zt+gQcKvF+kNmB7pboyH357gEB8J/su+XMrCPliWRV5/Xt+2pCOe5qZZprp9kdzgOAINGbfYyKfwUj3mKYHnj2f5BzKcThOoqPQm70eEyjpLauj46KytDJA15wf7sl0B3tzc7OdP39+ebBTzzHzvYs8uM/BC50Qzgp4HcV/BUrcwaicG8o3OZAa3LnnleDfnU06MkqjPZEVyeHjoWP+rnT+pm663B30OIh0YppqPzbJV6Ao2NNzoDij6U4uV6Y4cHVgkJzeXhCA5OW7gy5emLfLjr8rwJZmUxkkcFn6s2MCBAIvSp/Ak7cJdZ8HLPrst4PDyiaST/Egpzy1d8/R7jnPXu/qXgVqqkCBB3e8D7m+VdfEE/ur99lqtYyDKj6fxjSCUSfXO642SXbU7YS3VRUA5Kcai8aAIfYlXzXAw149oNPa4SAux+bUx1NQhPp9cHBw6KR+9Vl96zpnt7nKQecW0NanffmSbbITzqvIx5VqnFX+VXAg+TT+bALU4nlra2s59o9p+2SLhwIE9AXSM9RP90lSf0/1nEqVzXL9cvlWdZxpppNOPZ/vcvJwUmgOEBwDHdV49lYMHMfzQwGL46YUNFiHBw5YFy5cWC4J5syXBxKUVmn42wffoYEwgZ7kxHlwohdw8Pycl1RWCg64jBwM9kANnexqFlEOC19Tx/LImzsZSYbpf5IDeawCA050vJWmciJ7ZXge1OPk6PacXz1bgcGpJIefVOll0pWq71Uz0bo2BKqUh3Q0ObcEF1W7DjnGDjZS4MJlTqDkwNHBbFW/qh/1aIyd69WXfbQnL31PAbxJ53t1r3SJ4NbTjgEcvXKqg+NS3ZLdqcrt6Vdqg17+FcjzNhsj72S7nafKFnqf8Bl5BRGUr9sQBg5cZkN64XyN7StT9LUa8yoZpX5V8URZjNXVitfKFo0l+Sop70sJKGbgP9NMM1U0BwhuQ8SBk4PTpRwE0iCYrlXAbkpgZMxA6bMHPO2ZzltyInoOTgIni8XF1x9xpt/zFXHWxw8j9HL8Nx2YHqBQOVw2KvJltg5E0sxXKovPMk1Pz3qgtbrHujL4w7oQpDiPU8vyFTlVW1RlJac1/e9RT//0TT3zsrkCpTdzPaZc70seDGJ+DjISoBI/BIAJdJHfCqQyDcsiSKIOJTuj+1yN5Po8FBxZB1g4wEzgckhnUhuwv1QBn0qHx/ZhpXd9o210ftKKGeep0u/KPpNP3pOd8HajXCsZ+O8q6KB80ooBtmlqR5dh777zl4IN/qwv1+c16brXcWNjY7mqLi3db60tA/RObDeV4e3p5G1A25Hajen8ei+okOy8rzpS3UQ9O+HXej6D60Dq7/pWIJ42cgpdygDCTDPNdPulOUCwBrkT6+TXKgM+ZRvBEFXbFq5khHhM2WPr5xF2zhQ6ANHSSV9KTxBI3twZ9Tro/ANfxrlYLNr29nbb2NhoW1tbS8eWh/sx/ebm5vI8Ab6jmpT2bHpdyX9ySulscHY9OZ1yUNgeBwcXtyFwT2olSwIy5l05jV5XXyGhIAqXkzNfgTkv0wFlclYTwOUyXHdQKweQPFROfpJ54iOBac+Lzn6Smaetyqe+8D4P6+OzFehPvLGdyCd1kvosHZf9Uxo+n15j6WDUgSM/aqcEFr2vVdtEWF8CxJ5jzrTkT30yva7Q+zL5TX2HbcDAiIN06gufcdtQ6Y0/1wN/fmaI24EhQEcdYf9ie/iKMOqe23KWOSYIUgFx2kgPEPC1dAkYukypC0kOSuPBXZbtAVwPDjBQwjI1BmnsoX4wcO16WAWwPBhX1cfTOvnKH7cnLnuXaSpP9dLHzyjithCl9/zS2T+8LzuS+qwHj9jPpTfnz59vOzs7bW9vb+X8gd6YTRuU6j1EabwaCjLMQYiZbgs0NG5fLh5OCs0BgomUnDVSFRw46jaCsbROBHodGgqS8N5xdAg5M9XsDB0qzjKTv1OnTq282YCOSAqs6DmBBwUKdP/UqVNte3v70AoCgWsfxLe2tpaOpTvFIgIrOlOeFx0FAg7Jx9+xTNra2lqRq84bcNkyeOA8UuZjjG7SfdZVgZPWDi9Zp2PloL61thLAcaewCgYwcKG0DjIcuDmYIj8qI+l7cuSSnfA2TnlzhQD/V+QBETrerA+BuUi6o/7iII9pfQsAVxxwBc9isVjqvwAJ212yVpuwr4pXyoB1TDYpvb1Auu6BIa024n7sFFD09qrKTukZIPDT7odWEEgOVT9I6anf5M35HurDrmsOmpRfslnUHZeHy8xXG/jsvNIStDtg1TV+J70l0KLeOjhP9lXlu5319mP+pKr+DN7w/JcqX+on68WxzstV3hqz1A85Vqh+LEdjF6/zLBaXLT+0A0rH59Qfq4kO55//md51NI0x2qqoZ+knMEjM/pOCYpUvyLHTA4Ls+5rEOHfu3PJ3NZ5WflRKV5H7S+ynnua4/LaZZprp5NIcIFiDxoJ9d1qmgPc0ezqmPDf6U6LLLLMqf51BYwwPabAVONH9HiAlIFEwQd/uVAmUuIwqICfnQg4VHYfNzc3lt67r4Cc6ne58+IypyqoArs/OKn0C9XLkfEaSDj2dYzkrdGLkrBHceXvS+R/Si6QDlK0CMM6nyqHjqrb1vBQoSM6NAysH4nSwqRsCpKkf9PKa0k8SoNJ1d1YT6HNQX9XZAYQDgMSPZO0AkzpR1Zd9MjmnAhgMJDhgq2TqOuK8+39++0ntzHsMuNX9RBVgoEx8lQL7Lz8EVg70EuBPbeSfircKPFTPO3hKQDX1N5aRZMi2drm7TfC8XGY9YptzNRBXf1E2HghgO/p3kqlTJW+SA2HPtwKH6k/+FhbVVTLm6hXK3GWpunmdU7muN6nelT9Q2Qt/3vuTyq744YeBaB7KqPTe11JgwO/xt/saPnaJZw8UcPxlXXvUCxgM+Vzr+IczzXTSaYyvejl4OCk0BwhmWqHLtQLBqRqoqkj3WHKnp8qbPPQc7MrpdvBWOUgsS2mTs9UjOlJeR/3vtaM7Lw5YVMYYGusQOw3Jhw6q0rMs3us5nQQsaSnoUSkFSY4z/yGw5zO2KZhxHMSgoQP1Xr9K7cXrqW8eh9OagL0DKF4b07+d90QV8Kv6Z8/JX6e+XtdeHXl/qC96fSoeUuCc5adATJWX30+6VvFa/W8tB8ATGCegS4DP06dyExAb0p+qT6XvHiXdZdCw0nGVT1uitvVVQcw36VFvXK/uV0580qNemmQrvYxePj0boDyq/u31ZBofc1PamWaaaaYrTXOA4AiUBn13vDTQOl0KJ75yhtcps0o71tEhDTmWVdkEJBpYh5zr5KTqGc0YyPGpliOmWQc6SJ5OBxUyPZcYqu4eCNjc3IyHCXodktPIma40q+V50SHZ2dlZ5uEfPtdzcp3YRr5vs3Ie/Y0PbF9P61sdkl6zTdUOPMuAlPS7cr6rmUEHoerrFVCr+gvzSx9ftpv0lGCGIMDrrmsVeK74XCxW93l7PpyFJflKDz6v/LTlgPz6EuTEJ6+JjwR8E2ihfSQIEg/cdkDZ9uwi03m50iFuK/BZ6gq0uE6leisdZeernVymbsuSjB0oV6CJW0L0nPhzefSCQylw46A2AbMxwJ15sy09P7ehBHVud5k+2Qh9cxl7L6DA8khp5t55F7FNdAChyMeVtN1C5WlFl5et1XQ9nU39Tvn20rg9qcC5/vt2Qddjbi3w1Uo8f4Dpvc8ku+Z193HUgwHayqezBrSlYHd399BWI6cxvpP3i14+yVZOKWummWa6fdAcIFiD0mBRkQM7XesBd95zB7Xix0H11FnpXv4Vpbo5TYmKV7OfdDK1PYBLARPYkRPIPMWLnleZ7kjwmtIT/NOJ0KFPfMeyBnttNSA4UJk6Efr8+fPLtEqXgB0diLREuZr55z5vLWPc2dlZ8kPQkgAAHf3kzHkbJTBLeTqAZ316Syzdmaezzz3ldI69PV0ukuGYwEfPGWaeyZn0flL9ptyoa9KVFCBwPpmn2pNlOIgjOPZ6+28PQnhgQ6AiAUEvg1tY1Jf1YT2roI3LlkCCdWY7s2yvLwMqnhfTnDt3btCeukzZT6WrBBGVflVtkvgn75IhX6ua6sZ71X2VS1CRAm6yf5S36pxmbiUnDxakQ1EPDlYDNR50YlkpcOBl6L+As+t6pWseEBgTIEhjezXO0sY5H7TVreXgVxUIdZm4fU+BZcnHxxYFBnjOj8C2626yUQzO9AIAqg/zkB30wD7TpADx5ubm8qwgjRcC6JKrTwLI9qbxg22svsztAn42hYID58+fb7u7u8szB3Z2dpbBAtdf1o9lup8zNH4lSnVJtE7eM810NVPPvl9OHk4KzQGCYyJG153cyOtaUpQELvzZRGk2nM/rmvYgjl2KnAIOib+jEHlPfDE4QIcl8ZKcajpBrA+dCgJKnjWQ+OPBTHxGxHdL81m+So2OB2ezxsy2+WoBOmwuV1+FoQCBz6AR4LP8XnDAeaxWL7gDRwDM59xRZ/5cQSCeVDfKlWUzQKD7HnTw4JH/9jRD6R2IKo9038lBm3SNZyv4x51VglPOvJLSdQcRzi/BhfdR8sM+lgCv2oXPyyZ5cCDZFtY5OdPJBogv1t/rSJkoYEFdlQ6O6RdsA/YNBgYSGEwz2iQPAqe6O6hRvXy1TgoQVGCNOkB5uP3kyoteXahLSksZkwdfPVDpPe0XeWa7u83kW278O8mWvLNMD3Sk/k5wLF5SXZIDS9utoIbPnDu/3o6Uub/qz+tX8UTeVG8/u2ZoYoJ8sD+lCRMH7SkAnQIDvE8bSnu8v7/f9vb2VtrI8+PYQTn7CoG0Es/vS1ZcPaAABQPjQ6Dc/cbkK3j7uVzYFp53uu7PzTTTTLcPmgMEV5CqIMFMNVVgbOxzQwCNoCABjuSU6LryTw43HSs6MwIrCdj06kInNd3v5eWARHyNKfOojkIFSNwxrpzLHn/p2Qr4TJG35++/3ZmeQg66nKrAQOUY8rnkAE7VNebvdaQuM50HdzyPlL8HVqbqWZWedU5yGnKGe8B5yH67bniZVd+t7k0ltY2DKlEVTKmo1/+HdCrJfJ3xz/n3PJPu6beDeM7aDvVdpklBhbF64HVOPI7R0zG2mCCZwaUUcElyTfn7tSoIWfFWAWEff1ymvbEhTaokPU+rCVO7Da1scB7dJlb9WkGe9NyVouMY02eaaabbJs0BgiNSZeCPani5jHfsIOJLf8fwmehyDxo+sz+U1t8XPORUHxxcnG3WbAJnl9NMQc9x8ry9bAYa+G5pzyeBYr+XACid2yQvOaGejq8z5GyPz95UM5Ssc3LAxugM6+vOWg+I8dtnSKv20uwN69gDJXTyUp0p7wQSlF4rGsas0GEZBHTSnaHgQOWw657P6PaAQAVMeu3q+sLZYP134ttFWLbPBFc6NQRGeoERv1/pDfPlt8++ViDG+WH9ppL4TwFJ1sHtl/NeASc+m/q+p+/VMQG5qr3UJg5aU5lVulSG65J48plub48x/HtbVnbYbXay4V7Xnk3vjRVJtv7NGXje8/onm+CrXViW2z8/7yCtlGFQpho7kt5WY7HXS+Rn0CSdSPpf2R7aNPof3m4MBujDswf8FadJLlNpyOdzO578yisdrJhppktNV0tQ7qTQHCA4Ag01dOVcJ0e8tcORcF8W2yMuXUzpK6dkiMaAnB6NHfB6QLe1ww6IQJi/ylDPJTCwsbHRNjc32+bmZtva2mqnT59efm9ubi4DBwwmsGzlTaLDyfKVZ2u37s91p8IdFZ+J6e1R1tLInn64g7K/v992d3dXljxWsvd8JU8a17TU04MbnKFj3syPMtO3B8YEjujIpSABt4YcHBysvMueZ0SwLilg4TJNgZkKWNDR83eEM31y4Ll9hfXqBUG8Pty24telE74knEt9PU9vU6+jylIdPC+frWT9KSe+GlT9zpf2VoCoAukVoHDi60fdSWew4NSpU0sbQbDputRzxL0ve8CJxL5WgVf99gABr/N+eoYy1x5zpukBuR5IHqLUJgxws2/4femddJvjn/q+9F18Mjiq/67TXnf91hYy2oEEONO3gz/KKtlM2n7KubV2KGioe5U+sHzaM4436rceMGFbJL1l/1UeGxsbK3LVmO31U/6un70+W+lgSqO+ur29vay3+BJI5xi2sbGx/CQZs5+q7f3AUdctBeX39vbauXPn2rlz55ZnELguOlU+05i0Y54d45PNNNNMt2+aAwQTqZphrdIlQzw2j6lER4FlOA++PzU5tpeK3JmZ+ixBXzU7kZ4TGFJwQIcLbm1trTj+PEuAMw90GBw4ORCmg+LptALCwUWa5XAHVL/9cC13siQXnTegFRdceUGiI+51SXokPlg/Onh0PPmc8nP5Ov8+8+RAxs8W8OCB2oiyYkCh51DpObYb9Y3OL+ui5/xQqylOrRzU5ChTnml1AtuwAj38dl1hHh5I0e8UHGF+7JOuSzwwj21LnWFwwQ/YSzqbAgcEjUk+iQjclAfrpbY9derUMtjHw/gEOLws7y9sE5cfieDR7U4lBwZ8Uv18dUB6Tr+rYEQasygj1qWn8y4f6mJ1T+VTx1yH+Ww6DJIH/aU2STZH5dKW0Y6zvbzf8RrHEA8oi5ivj8sqX4HOSh8o+9Q/KB9/wwt1XfVO41wKepw+fbrt7e0dkhPlwXZRfT0Yz+BgGhfIZ0W0p5ubm8u8qBMiBpcZIPBgm/j1YAB1yX9z9cDu7u7y4wcTVsB9yE/yvqLfLp/kcw3dn2mmmWaaAwRXiORkVvdEdL7HkBv7BGaGnj9uOs7Bh87cUGAg8UGH2B2Bagajx39yjFmWnKDU3pXDzzrRmfSZujSwq1zOltBhcWc6BTwqJ6WScSUfOpFJRuLFwaAHYvTN9nNQk4A4gZ3z4nX1IIzKch2j/L0cLuevQG2SHT/ptYyslwf3dI0ApNcmHrioiHlW7e7tSflSnslhdRuXPj2Z8ffYvl/x7XmlMtmXGSxp7fCp+gkwez35fwzv3o/8t7dnWnXSe4b9y9smyYrkdZpi7739Uh15PfV18s0+6su408y/yMeTSg69NvS2rMBfb9bYgWavTVOZlXzdLvjbkcgrAyOeh7+u0VffKL+0so/9xYPv1YGFqY+y/KG6pyCH5JvGlBQYIP/8+Co/lsH06S0Hrm9H8ZGSHfZ7Kf1QPjPNdFujsWPupebhpNAcIFiDqsHpKKsCfBmlg5B0reLN/09RyKnpp9JxDD7u7BHMkaqBn46WeBrDl6chgOJsiDuudGAT+HWngjw5mHZn2nn393TrmeS8jgFffi8BHoJwOnw8rd75HHL42aaVPCsA5GUl4JlAQnLop/aFtOIiyTHJYgzwZf6t5QO6qrZNuqVAC+XiNIavKhDg+p3sGNP4M55fAstjaMgJJ+/eP6v0IgYcuWoigTwvpyK3JVXZ69hT7zPJHrZWg/QeuQzTPf9d8Th0L9m/dYg2isCRlAIEKThQBQ6o/0znZSQ7n/jopanSq4769pUCHhBles8j3Xc7LWJwTUGFXvpkQ6v6Vv26AvnkZ6z+VHKubJm+q0CQU1X+kA0ael73pvp/iYeZZprp9kdzgGAiVcvc3FFPDl7PYapoinEem5az2um5q2VASPLRTMPu7m5bLBbL/fiqD/c3arm2zh3QtoLeLHRVvgOSBFxYJmeCNzY2VoCC9mlylssBK513X0HA8ujgEFjpUCTmr3yHAAqvp9ejsTyuTvDXP6ocOmQ92bM+nJlyR5LP0rn0b7ZVmk10AOcAlTKt2oQyI8jWKo4U9GA9/F5qh8qJpc66jBOI4XPMn7OvDnxZTz/wkLylsniNM4Z8loEkzu6pjc+fPx+DQOwHifx+CiyQd8oj5UO5uU6IX4Eu6hbr7/bW+We/dn4qR9/7FHWoSl89J5kT2LCerL+3iZeVXrvqMktgfGi81DM+c52CMXomtUdF3gdp4/Scb1VI/JIn3nMeko2i7FhHzsz3giQpKJXq520v3nhmQE9WLNdXx7EeOtdC/SDpaA+opzGRskl8cSyi7MQr7UFaOeDP6JrrPq/7Sj23wUMydR/Df5N6ts/745A/R12qaEqQYaaZrlYasmmXi4eTQnOAYA1KBtgbvRq4Wjv8fvSxKw96qwj8ni/T8/tjViOsS2NXOzB9a/3D8kRyYBQY4N5Fd0q1p3Bra2u5H5EA3t9kMCXAQodHwED7Qx3wunPHujgw0vJL8eNtprKdZ/GjNxV4gEBUAQ2RH8xIp8mdOHfMWY7kTIdeARQRAzZ0uvjfgwApTQKQzqOApi8zZhu6A+dy43fSWQeD+/sXt5V4QMDPGnBZpzJFCkC4k8oggdI5EFEbMy0DVawL9UHXfAWD+KMuu/xVhteDgNSDe9QdfXhQnNeJckoONtvYKQFxgjvKm+3ONlBbO9AjMPUyqwBFAn+exsENZ2V7AIT9hzbEQZI7UkrTA+IekHEa4sv1V3J28n5CvfQxQHylg/96+Xtf4LkvyovB6cQP80/BEdczbQdL4ziDE7RBPs6zzrxW2UcPClGOfsYCiTwkXVGQ2m0F7UwVZHF7wfxpFyrieCP+KUe3nZ6eZXJLRSUD2j71e39jkNsBbx/Pdx0QMSSXsZTKvxqA1UwzzXR5aQ4QrEmMQOt/uj8lr0Q+wNJ56d2bQlXAggMal4uPKXMsL2ODIyLxI8B3/vz55cFh7kjo0EEPDiSHeKxDS6fOAebe3t7KzDkPMmMb+2wfwQTTJGc5Oe2SgxyatNdxDO3v768AePHh5ald/bAnL4eAWHJKwL4C+wrg6Lfk7wED8sZ28vYSz3T83HHnNcm/CkAkp9gdKQV83GlPM749J3QspRlQ6h95oeyYxu+Tl8VisbKH18tJ+l6BYwdJnMWkLUoAOIGgFBjgM/473ePzvWCNzzh6UEO6o7czpBn1NHb0nPyke+w/nBmtyIERn2cdvC3TcwnIO6AlpXGrsr1ej9TefuZHIq/LkC1kQI9A1nU19XUfR1OZ/puBBALyytak1QFu+6oAg9ta73t6Vrrq4D0R8/Lr4tXtAHnyNKQEUlOA0skD0aoX9Sf1Z9ch5y/ZA6VjQCG94cR1wmXVq/NQGpfxmDGjarOZZpppJtEcIJjpEB336oJ1Axc9qhyXBOiGZpt7wK8q04FQz5EaC9A97zEkh8md0QqckRxYOaBPDkPVjpxB9br0HI/K6fIVAz2wNsax8YBBctorR36IhkBZ9cylcsjGOoj+7UGD1vr9rEc9h7UCflVwodd2VRljKeU11Gc8wOBBhsrGEIRUAQsvq8dHL5AwVAcPsPWo0pGxzw+Rgyhdq34fVTePSgR/ThUQdLn1+kAqj7I/ir6TCI65jN//T83Tg9tu1z2AsY5vkGTgfWIokJCeH1tWZTc8kJTs15Ukt11Xmp+ZZrqcdLX1waud5gDBRHLnxA2uqHKQXTk88u+DWrVtoEpf0dAgXN0X7z1guE55TDd1FUFrqwBSMwbaTqDzBvjKIm4p8HMI0uyBKDl6PjNARygtKUznDXApqYMMPUPApDqwTM6Ka8WAfrvDTUqOUVp2qfbx59KsBlcQpBkuluErCXz5dmobznDxf6pTctb8Ov9zligBIM4MVyDV6eDg8IoJXzUwFFRKIFPEJe6pbVwuvM624pJyyoR8+G+fXRU/aYuB7okXlkU9roCR63qypb0gXVpRUf3uyYFlV8BHz7N9df4IZdRaW84W9/oU68b/TENb5mmq/ub1oQzSzHglA++HXhfXBV3naopqtj2BrPTxWW7ni/bZV6e0lrcTOO/e733sn7JiwOXQCzYw72QzKCOmqYI/Ssv+73Vnn5NseiA++T/SNV/toL6Rxs/Ej/sGTOPjP7eqaaWgE/tEb3ysyHVSryvUZ29vb/nZ3d1deb2hthwk/RkKEqZxyfnq/e9RZU/T/Zlmmun2RXOA4BiJRtwHszQIpGWBvUGr53z3eBqi457dn5rfmPSVU7BY3Lq0dnNzs505c6Ztb2+3M2fOtM3Nzba1tbXcZqBv7XvXNX9vfWuHHTg6oRVApFOkYIACAnt7e0uHQvlVrxxMTqzqKDmQL+Wj/avcx+pydWDj5y44gFAZvbYiOOktl1cdeq+X3NzcXGlfgho/tDABX/Y5d+jTzJ7q56DIQT1BX5KFO1a0A1wizw/T0QGkM+6OvoM8LkVOjlx1qKC3H2Xh/FMuXh4d3mrZdSLvQ74VR3knfrVkn6tm+Jv1dKDojnkP0CV9cLmxXSizZPPVt7XdQPLyvp/qzDoNBZ1Y995rQFNf9z6SgAK/077t6jflynLERzXbmkB5OgSO8mlt9SA6ydmfS2OyA2ZPkwK8fr+1fC6B56+gbpKTU8+We8AjBcXYd6vAjQcq0kF/Tj2fRmXRDtHOSIYezGFZlGcKXFDX5QekoFlrbTm+eL7JfqZxRnxp3NU5PwoC7O7utnPnzrW9vb129uzZtrOz02655ZZ2yy23LK+nszCo2yrT7eFQkEA8+38fm4YCren/HCSYaabbJ80BgolEY+0Ds5M7G+74r0sp0pvKTuUMLenzAX/K4OADmP5PDRhUPMrZUBoC3Y2Njba9vd22t7dXVhHIUWBAQKsNBNyUh3j2dkvvO3bHSeXQefSVAwQGHiDgYK5ggtqPMyJKx9UC+ihAMFbG1UwTy6lmmJQHnWi1Two6+Gym6sRZHz6bgJB0QPfTDBUd0cRzSitHXc9QN7yPV85dAhvpALjqMKzkpLM/Obir2suvpd/sXx58YLkOalz33dHvzYQKyPecX3+W7UYHd2NjY2lX3B7TsU8gmDKt6sffqT6er//Xqe2UpeSltHoLi+eT+OM1DwhQxxgwUZ9i3xElUKSyPCDoPOkay/W2cN498JBm/VNQT+Q2SAFXtrfycf5SnXp66vKgDNKnCjxJzl6uy8EPrmU9Uvu77U1+BYN+rtNuM73O7G8eZOnJSM9Q3/Ss7KjaXQcK+2oCPc+3KKg+acxRGQzAcsx3HaeuMp8UAKT9oJ3geKEAAVcK7OzsrAQKzp07t7yuMdrll2z3USgFEsYEGYYCA3OgYKbbAh1nX7ut0xwguEKUjO1QhPhSUgV6PM2Ya5eTfBbalxvyHsEanQcCl1Q//nZnjDMdlXPss6tjnVMPIPjHZ7PGOL5OlEMCJ6k+FdDyfNOsZnI+6FAmQOzpmX81G6bfLnN3+NzZT4A16fdQ0Kv3bHIIXfcI0tfpX71gAnlgOvJcAdfEZwLTLm+mqQCVUwU6K0oyH7KzFf/pv8vI0yT5cLbTAbz3vYpf58HtVqVjvfx6cpnKiwMpz1PfDmiZJgHvXj49W5dspVZujAE9vb6fVskkfRaPKUif7FLFTwoSiA/pVA/0M59KZ73OPX5Svp7Ofye7nwK86VpVnvNYje0pHfvpFNvKdvVAv/SC31zhl/yDlH8PvF8uP+tK+3QzzTTT1UFzgOCItO5qgHUG4ylpydeYGfwEEseUOeSMr0s+a+BOAFcBDDnIKVAwhqrgQGt5KaqcAs2QJACanEN32BxcDznEXu8hB9/lUIG2yoF1YOnyTTPmDNqkukl+fv8oVIEWT5PAGj/uWPeW+45xPhMAGXKKHaTzXu+Z1lZBqsriEl2l8bRefz2bdELt1gM8rmMO/qkLrKvLKwG06r/P2qZ0XqcE9L2Nve6pvkk+ki1fNUnbkvQtBRX8fw+UTaFKt6pxYQj09PSW/wWidI9A0dspBSlFBJluS7laTH1AsmWfTiA92UIGcL2OHBM8jzQG9MbcIdm31pbjDvlK6dKqqyotefDVT2ovDwLTxvhKpaptPKBycHCwsnrL7ZT/HqPr64wpaSxkYIArA/nWIJ8QSCuUptJx+YYz8J9pppnG0loBgv/3//5f+5M/+ZP2sY997NBg9D3f8z3HwthJoGqJtgYCLjk/LtDD8nwWO9GY4IDn3RvIpkSXpwxG1XYIX1KrwMD29vbKmQLMw515LkH0fbnO69Ag7oM+y9KyQzqyWpKYnAZ/DaGDbDobLNv5rHhyuVYgJzkzzJvffDaBFj/bQe3Dsx+41NPBry9PrQJAPUCSAFYiX2bqsvQ6LxYXz4Jw8jc4KK2DnNQfKwfXwSKBk64rv8RXcqq97qIEyKR7DtTTsmDfopDqSV2mzHwVDHn3VQRMozrztWzcKqRrBweHz9JIcko67t+VzRdRnyVj2R/K6syZM0sZcrtQAhN8zvsc271q72SzXeer+qfn0xL2tHSaebEM6Q/PvOA1t2UOolNwlnVyUE1gysCM5J2AatUXUrAgjR2sC+vqQWYPAvV0MBFlpVf/et11zftHD1gzD24nId8awyiHNPb6+EaZaztOCjak4Iny5blCDFy4Pni/YRoPZvA56gDHcT97QN88oFBnDWjrn59h1KMqGOW6kNJ4Ws+3uud9fQyfM810EqnXby4nDyeFJgcIfuu3fqv9k3/yT9rNN9/c7njHOx4y3reXAIEPxMl5IaXZZw6IPsvHGb7khFU05MCmtNWM6OWgocCJnAg52QScm5ubbXt7e8VJJsCmg8MZEJ9BT6CS5IOynK39/f0Vx19OAfNhWjr/1QnWyTl3YJWCA4lvBlZYD3eEEj9MQzDoz/vKAO4DPX369KGDIil7ylL5M9gzxpD67F/VXhVVQMllXIFG6pp/fKUE6zo2QEXA6WCitYsAWnt6vS6UteuVBwg8GODAnbJ2nfW6kqhjbte8LMqH6QgqUiBMJBBUBQiSveHMq/cX74/+PO1zIvYL2ng+JyCxWFzcfy05MhBAfigjT+t894BWb2xJ+uIyZxtSV3sz8q5XBN8OqBwoOqjz+im9ZqDJDwM2BOxun13PPUDgNjvJytP2ykjgdgyx7VxeAtHst+wHSaaeL2XqsuYZOuQ92TQGK8gP2yvJJtkR6TzPEuJhxSQGB7zPka8kB/ZBBggUAPAAgb+twL/TmJJoyJakAEGvX6c8qr7M+zPNNNNMkwMEL3jBC9r3fu/3tle96lXt2muvvRQ8nRjyATBRAjAid0ir3zTaCagd5+qEo1BvRUO6lwZtEgd4BQnkEOg1humVRu7Qu6PgAQI9k8BZBcYJdnhf+1wd3KTZUXeueU/gnTLrORXubCYQVelrcoJToCKBJQfJ3l48GNIdfNbLZ4aHnBSXfaIhZ5vyYD91cOBAbWhVRtIv5sfZKT7ba1/qDEFAchIrGaQ8RD4r7PXuBQD4vO5Thg4EUnn+rAcPUlAhBT08mMK+R50jcaUHy5LMKG8PXFV9JIEPz5skUEsQp3TVqezkJwUInC9/1nUg6RJlmWwA043pkwl48cPVVq2tHsbHN5n0AjXUWQJR1w0GJpNtcztA8nGMwQivnwIf7PtsE8rN28rr6frrY5LbNILtqi3ThIUHEGg7+K32Ybk9m5R8Fp88GROwYHuNsfMpbY8/ryvbUit+uPLHtxz4M0ehZItSmur62LROlZ07SfR3f/d37e53v3u89773va897GEPu8wczXQlKdnyK8HDSaHJyPIjH/lI+6Ef+qHbfXDgOOhqAfaXg3wWXNQb/N2ZGHII0ixPAnvuLPF+j3qgzgMH1RkEdCAqPqaSA293KJJz53wN1dnbxQMtycnukfPi98hbktOQPPh7yKGcyvNx0pS6uXPu3ymQlPJOQY1KTj2HutfmlUNe5cm2TnxX/df1RHKY6ghMSTsmGFPdrz6+Cqe36inJPMm0Zy97tpBpquc8Dwd5UynZgKo8lVHVYYwddzuWZDx2fE6BBJ9dH/pdAclq3CSlca73+yhU2Ysh2z/GtvTGGh9z0rfzdxSq9GpMvxFVOrAOL2PyOKkg/lLSQx/60Pabv/mbh67/7M/+bPuar/maK8DRTDOdHJq8guBJT3pSe/e7392+7Mu+7FLwcyLJB/rW8hJCn3VIVEXz04wwI/XumAzl77+Pg6bm57yybpyJ5kqBra2tFce5tVVwrlcOaYWBlpOePn26nT9/fmW2UI6F74UVJafFZwIpewL/vb29ldexJUDjSw+ZH/N1/fFnTp26da+/nmNeHsTwNvJAhj9LGaS3QxDI+OsYVbacXM6+Vs7wYrFYmYFReZIl8670zdvJy2M9daBkJfvEo56lTOmsshx32qgraVY4pfVrrLv45mvDKjvj7ZlAmc+q8rryoEyrNvBVIMrTX/3o8qK+kGfJTPmmWVuVm16j1qM0KzsEaLyvJXmqvl4/1zHmRVtEPlJbeR+vgjL8TiubvO97WZSzt5nrbzrrIQVKWQ+Xj99LclssFsvtXL6v3uubdIkykF1Ks7++8kRlULeUF7ezJPlWto/6U+lYCv55X6fuiGe3Mf4aWi/TZeRE28txh7x4fWkLkgzYX5Vf1TekfxyLEu/pv5frdffVC7TV0g1+3LYMrbKqqEqb2mmMPRtTtveDXpqjBDeuNP3oj/5oe/rTn96e+cxntp//+Z9vn/zkJ9sznvGM9hd/8Rft137t1640ezPNdFXT5ADBN37jN7Yf+ZEfae9///vbQx/60La5ubly/6lPfeqxMXc1Eo1lAusidzp7TlVvaWbPCff8U6DiOGnsQJGAUY/Eq0AgAcTW1lbb2tpaOZTIwZhktLe311prbWdnZyW/jY2NFcDQc6i9DkxDMMkD1qo20v57OjhcRcDBXu3vTgZ5kCOrejroEp8VME1LHunQsvwUHJBTpkCA0nI7AduGTjgBJp195zEd5sVlrF6Gk8tL19yZT45dD0A7MGf7p7L5fMpPeTl4qXQxgXYvM4FI6Tv5SFs4KGO1A8EA+WOQYLFYHAKFFejXgWRpNpyyVP4JHBCgpeDPxsbGSn28fRK5Lni79exERZQRy6mCEaqP5ONp/R3qqU7Od0pDeXt/820clHcCXyxT39QVEe1LojGBgRTAoJ4oPW1SD/h6XdUX9/b2DtlnBZZZP1+6v7+/v3L+jC83r4ID5I99tbKRnj6R+q7OteAqlORnpHJ65bZ20YborAf/kKjXDLjQ3nD7SEX0NX1VgZeXdJX11XXykGSqtvQtBX7wsPeRtBrK7X+vT1APXCeqepFn9nPWWc9NtWUnlV7wghe0JzzhCe27v/u728Me9rD2yU9+sn3t135te9/73lduPZjptkveh64UDyeFJgcIvv/7v7+11torXvGKQ/eSs3hbp+MC5dVs5xjywWYqQB9DlfOZ0qW01fMO1AkCeQiRDieUo5YGZJ5mvre317a3t1ci/3JmHGjoeVHlXNBx5286AHISGfTQrIi/Fsl1pwoSeT1dzgLnVTsQBLgDR5CgvKrgAN9Q4IcTOg8JQOzv7y8dQQe4BCUeTGAZCXhVMmObVX3KAeEY/U5gqiqjChLQUVY+zDNRmuEi/6pPlZ51TICgqof3T+pFkg3vMUjB2X/mx+cpH36TNwINylR5emBIckl2kTPMTg4qXVdT4CA58NRjL192if2HNollKTBYEXXH9YDXHBgzHfuLg5RkF73uBNDpeg/gJN2jjXWSLvgqjbTKgfXkAYasu64JWHPcoKxSv/cPzxxIdWI+SX+8Lya7VNkcH8suXLiwHIMYhFceruNpTCQP7AspaE3ekr1x2TP/ZNvdL6IeOU/+ewolMK429LMGPABEXvg8/w9RZfvFl/fL3jPkJ+nfkHxOclDA6cu+7Mvagx/84PbWt761tdba0572tDk4MNNMI2jyJvgULeas6EwzrUO+FJq/3RmtHIAeUNN9fo99LvHk1xzcyLHozSSMAZZeTo+v1mo5TqEEBvjxrQZjynHZe5BizO/e/yn1Su035rkeVTo1Ju0YqkBGKnPIOU3tNkU2VToGcnrPpuequqQ6pP5T9e0h8pUqPZ7HULJVKQ/9T6spGAxL13u8rkNj9bSyXUPXe3Z3Kp9Dn7H5Mojgch7ThlVwY6jvjbF1PRpKR/vK4NqYyYt17WlrObBcjde9oOW6nyrvXv3GyL837qxrc2a6fPTHf/zH7WEPe1j7wAc+0N73vve1N7zhDe25z31ue9rTntY+9alPXWn2ZprpqqbJKwhmqqk3G1WRz+CsQwkAHDdNdZIrh7i1vARQ+w/5yiK+yoivM2IedJoZMefsG8vxa2k2w2cSyLfyZuReeXI5KQNnmk3yZYnJsfVZ31QOZeazAR6QSHLwNiEg8RPTuTqA2zvcIeT/irgMt7XVZePefpVzSZmldmM+PUr6lxxcyp9pHWBwlouOeWuHZyyZp69G6M2upXrrfw/gV850JauqzvpOs8Eirzufd/6rtl0sLs78M+js2zGqerAfTXHevT2TPMfoWOLNtw0wjS+v1lYMlUe5pP8izt57/uQ9tZHn7+Q2xetKu8f2a231bQEJVLkdSTPXPWCd7DxP9OcycCfXRdctb/+0IinZdOcz1TXx7nklOZNHr5d++0o7l5fnybKZVm1ZbU3wOtFOJL8k2Sf+T3Yl9UulYXkav1KdVb9Kv5mOabkCsRq7NbZr5aJeg8itCL1yU/lTqLJFyfc5Sn4nkf7BP/gH7Yd/+IfbK1/5yra5udke+MAHtsc97nHtGc94RnvoQx/aPvzhD19pFme6jDSmH14OHk4KrRUguPnmm9s73vGOduONN7bd3d2Vez/0Qz90LIydNHKj6sv0fPAZymtKsMAdv+OgapnhEA+t9QcY7oXUQM4DCNMJ3gocOHBN4NTL9ll8XwKbQJcDQzqHVb48oIqBAS5D3N3dPVQWnQ85OPztYJIAw51pBiYcWHFLgzvFKQjAvdxsi7QUmukq55CAj20oXn3m2duW9dP9tOSebert2zPM1Akuk/dn3BHldQ8OOJBK4EMy4NYLB6fOQwI75N/LqYI3U4ID4st59f4nXffXulEnHFgkPW7t4pkd0j0CPa8feXfdr4Ap6+ffQ9s9HISzTtSjChDxmtsbvu5QdWb92Z9ZL+XhQIxycb30+kl2VeDOt3w40PXtSpIDicEE8kh98LJ6bchl3kqrbQLknYA3tQXbn9dTEIFyoc1N472X4+3tcqCtJhBWWvKQ+jzHNtfRtN2E+Sbe2T9pExNQ59iXeKj6fNqulOTt9fTzd7yfsY/wEEfyz+fUxzieq113d3cPrZjV1gMFBs6dO9f29vbazs7OSpAgbUVgW/g9b4d0fwxVQYKkG2l8OElgJtHb3va29g3f8A0r1+53v/u1d77zne3/+//+vyvE1UwznQyaHCB473vf257ylKe0W265pd18883tuuuuax//+Mfbtdde277wC7/wNh8goBMvkhObjPdxLQXtAfbjDAywrDSQJ+o50Wk2SPckM72Z4MyZM/H1Xr7fnbwlB8mdK59V5x53d9aqvNxxVL5KQ3AuB8+DBjs7O8u8VScPEEi3EqhjPZgHgxV0UslbCuDwW0EYnvVAZy4BY8oo1Su1AwGf8kizqmwH72tsj6R7qf49Sg5oz1l2ObAsOqGaxfQAljvJdOgpT/JXgesUVKhATnK2ybvny+c9gOOy9fb0gBSDChUw9H7Kcrh3OgEO5kGA6fmkFRqUGdvWeeJzHmAkqfxKn7x92R+Y997e3jI998ET6LNvVXaMh6umbYAeXFB+nIV22blsaeuUpwdRyFeySdIxgmDnzZ9zfVG558+fX44dHkhxMOo8eGCHv2XbSAwOsBwPbDA/1wfec375zYAbA3ZeBxL9FbWj204PyDA/r7vn723FAx3T+K88yTftqftY9Bk4xrR28YBc2hTWhfWrtsBSTxnU92+/xs/58+fb7u5u29nZWVlBwOdcpj1ym5IAvF93XRtLvWfS2HOSSMGBD3zgA+3//t//2x7zmMe0a665pi0Wi/aSl7zkCnM300xXN01Grz/8wz/cvvmbv7l98pOfbNdcc0377//9v7cPfehD7ZGPfGT72Z/92UvB44mkMYPApaLjCEokZ3hdXjhjzGsc7LWFgCsGuJrAQbNfc0qDWZXOnbr0vDtKlSPG5wna6VQwf84KJjA/pj4eRKjq5c4E6yNn2uXNgE06mDAB356ckxPtYKOq55BcpgYDxl4f+xHRcUxtm5x/6oOXPZYcOFf3xubhfCR+2B/Tq8dSHn4tkctrzGfoWb+v36w3+3cF8Ht8D8nJy6rsmfcxX1nl5aQ8q3ar5DJErscOknwmPQGpVPYYvR3i368lcDqGvK0rHkgVL+sQ7UWS1zptNzQ+ku80Tnk51QqM9KFee9qhZ5Nt4ScdmpsC664XTpRz0uUUkPOxS0ECDxYNjetj2yvJeoiGyhsz5p50+sQnPtEe//jHtwc84AHtKU95Srvppptaa6193/d9X3vhC194hbmb6XLTOn7FpficFJqM/P7sz/6sveAFL1ga5Z2dnXaf+9ynvfrVr24//uM/fil4PFGkQepKKsFxrChYl/8EVlurD+Mi0Pbfnl9VjqdhVJ+fvb29Q85rciZ74KGqQxq03algmuRA9/Y6Kr8ho5NWVDjY4CsjuVrAn62cc34nGqM7nqZXJ57t4I6c/67ySHx7u3rQKn3GOGcJmDl/FYhKshiiSveq/718XecTVXqS+Ep8JoAwVKbzmD6Un+tERT07MlR+qpfnTbB5cJADdP6sy9eDch7Qc3CU+E31TmA46YmvVKgCYGkFyBgHyWXJ+vZAp9uoBAyTbaj4df6YJ22k24MULGVbLBaHz5GpbNkY+5poyB57nX2cSWNgNQ4xTeoLreWthL2AcgoYMB/m4W3jz1TjNe95HVhXUvItKjnofqKxoF75ped793vXq3zG8LCuPl4t9MM//MNtc3Oz3Xjjje3aa69dXn/605/efud3fucKcjbTTFc/Td5isLm5uTQyd7/73duNN97YHvjAB7Y73/nO7cYbbzx2Bq9m6jk6ouMA60P5cIndpS4rER2glFcCWgKonA1wZyttLUjOIx3v1lbfGX769Ol25syZpQOwvb29PPRQ15Ljkspi4Ef5c3bDAYA7Xf7qNwYt9IxeScXyRQ6UuZyXAQLlozLFF18fqeeUP+9NBcPMp6cH7iRzuazAcgJVLluRZMD07kRWDk5ySJWer8vs1dvzlYzFk/PM/MQnl8i6E+jPV2Ao8UK9Y97UbW8Prx/rQgddfHl9SMxf99jf/Bm/lp5NK3bYbrqmczyU75QVUJW+V7a+57hXeVFHySN5rvqT0hHYtZaBO3lw4JvqNxQcUnv7+QcqP+mT55VAvN9jm0kPHeSqTOWh9G5beChqr0xdk431GW+3cbLv4oN9g7askovzn/p7a4dX76UAsJ5Lti6VJ37dVookM8qG40jqt7QxOmQzAW/a+2qs8LGeZ95QP1IQxoM7vKfvJHeRn1NQUQqGVfcp32RrPU2Pko5MJffXKv9tjH97tdPb3va29nu/93vti77oi1au3//+928f+tCHrhBXM10p6vW/y8nDSaHJAYJHPOIR7d3vfnd7wAMe0B73uMe1f/Ev/kX7+Mc/3t70pje1hz70oZeCxxNLQ0Dbgf1UoE9wO/bZCmhNHXS8PA4ydAA0UPPtBAKi+njAgMEBOgEePHBSur29vaVzuLGxsfLu4oODg7a1tbV0AgUm5JT46c/JaW3tokMksM3DBU+dOrVSnq7pXdR+4jEdWqWhE8SghACsOzoO4CgTBUO0dWNra2uZH+XGYAhl7lQBoZ6jkWanknPO9mZwyUEVnTOCA7ZJAiKVkytdODg4WDq41Qy0O+TOh/Sf+5/9I1IdGSDzoICDleSgJ5lTjnyO7V4NmKoD+3kFXpwn/vczK06dOhVBW6onv9UelZ0jkCH5/6SjlQwcFHp67yuuL+qLDiRoV/ifQCjxk8A1QZgCo/qeYtNdpmmMqLZJJSBU6YzbVZe9rqsPUid8qTef13NuGxlA9P7gPFOW1McULFVZ7Os6sE5pHUS6DUz2oLIBSX7iTfk5APb2Y7soL66MUJ7qn6w/x0uW7cEGpVH+BwcHbWdnZ1kmnyGvHjAjT7KNPjb7IbJeNw+0peBaBfRdZ5Is+X8oSJDsTrItFVV2q8pnnSCE58drJwnUkG6++eaVlQOij3/84217e/sKcDTTTCeHJgcIXvWqV7XPfvazrbXWXvnKV7ZnPvOZ7Qd/8Afbl3/5l7df/dVfPXYGr0Zi1FzkIHtMcGAK9UD8mMGD11S+88+Zt2rwmRpIII9plpoz8HQ0fIAnGHHZef0JzH0GdHNz8xDwdkeIMnFAmZwm1sMdxAsXLqw4u3RcfcsDZeBLO/Xh1giuPNC3g27KUUGYra2tpWxYV+aVZuGVbkgHKlCdfvt/d/J0nwGcFGwQpdl4L0f5sW3d8VabeF2SU58AjjvC7pA6iGS7OUBIs3wOML2eyku6xHwcXDkQTjJxgJT48OspjfcD8TUEaL0uXo/W2kpfp3wJKP3Zime/nuTUo9QmvO42xVdcJN5oG3yW1k9Jpxx6vFZpHNiwHNodB3kMiiQgzr6c5EqZpD6mPH2GVn3GZ4Ddrnob8NuDD7QFDCAqzcbGxjIITb1kAMz5TIEBD6YMtVfV57w/JGLZbld8FYb3EclX8pQseqscWlt984GCKfpd2Tb6AL4FTnlS1yQTjv0uJ29nfjyN0g2Rjz/+3JAfVuXZu1fZqTFjs/sG6fo6fF2t9JjHPKa98Y1vbK985Stba21pO37mZ36mPe5xj7vC3M0009VNkwMEj3rUo5a/v+ALvqD99m//9rEydFJoykx/9fzUIEFFx2W4j1qn5NQ62E91TgCXlJwIUhXlpqOaABqfY9pqBu+4qAKXztuFCxdWZqHTlgL9pwzdQaID3wN0BFVTnYd1KTmiQ+nHpq2oJyumWdcJZxlDVDnjVZk9UNu7l2bnvYz0m/+HwKb3w8oZdX6Og6p2SeDMqRds8XTHTWPyrAIGfj8FH8YAxvSbzyVAKxt5lDFjik2pAiZT8qiCRGksEPWWow/xOOZ6r9+vo29DdsT/uwymlDk2vdshX9HkaXSP49BUWQzZuN7/KfIT9bZMXK10HGPp1U4/8zM/0x772Me2d7/73W13d7e96EUvan/xF3/RPvnJT7Y//uM/vtLszXSZaciGXy4eTgpNDhDMVAPpqQ3v+azjbFXLbisQOKYsOkvVAN17frG4uByQWwX8zIGNjY3lsnc5BGn1gJdPvhJYJthv7dYtB8pb+/7Fgy91F6CulnW7wzgkQ5cZ3w+fAhuapdvb2zs0M6hv3xvvKy0cKOg5yt/by2di/J7Xjdepg5W+9MCb5EHH0OvMIImncRl7Xu6I8/kKfFF2DNxU9aNzqed6/ZKya60tV4awfcib51/xyzJcF7xPJR30GXr+diBFvdFzvn0h8UvZK6+h5cKJqoBO0gu99o7PUUdcNlVZvaASKQVLnNfq+THBJ+/bBwcHy/6t/9UWGefPPyyDaTnbmgLcvnTc21T5Jpl4UCnZRs9DbZfsDld4+T3X9WTTaWtpe7iKgrrOcrkUXvlLJmO2aFR6nfQ7jcNjgm89v8H7PVdt6BmWwbZObUs9YL/3LTipP9JupXqlNvOxwVcL0F553Su7zvbjlkW+ztAPRe71vyGqbFl1Pck3BQDYz91+OFVlnyR60IMe1N73vve1N7zhDe306dPt5ptvbt/2bd/W/vk//+ftnve855Vmb6aZrmoaFSD4e3/v77U/+IM/aHe5y13aIx7xiK6h+NM//dNjY+4k0lFn4Y9a5lAUfIh6A8ZY4iAv8L+9vd0Wi9XtBZubm8sl/7znDldabup1Jt8C0GkpPvkgr+Q9AZokn57zymeVH1+DRGDFuiiIwOd13/dz6yMHbbG4eHYDAzN0piugUjlMrKvLmY4uZxU9X9fJ5KgnwOSzTVz+6041fwsMUpc8X19uX6VJS1GT41XJLS2fJ7ijw8rtKmxv131SqmMKskk3XO6uzw7w/eN1qVbl9MC6O/rJ5gyt4mG/oP7rP+u+v7/fdnd3D+231m/2FVICswmwpXpWtiEFB3qgxNPpt7YY+JJvpdvf318GGb3NlLe3a2pf1z0u4U42w+1Ckmfqv25Ph8Yh9l+/Th56oNKDtR4ooC328SUtTfdxxOWU+kqyY95Wydb0AmiVbUx57O/vL8dCJwebtFMeJOD93jkgPla4rrsNTONWZbNaW11t6G+KUXt7gJ1ydx1M/UMBfE027O7utt3d3eU1BQx8zKh0fIqvltJWwQE+k/pT6oue5rZA97jHPdrLX/7yK83GTDOdOBoVIPiWb/mW5YEe3/qt33op+bnqKc2c6PrlojFOeJV2TL4+AKfBucpPstEMPc8dYBDAX7OXZvF6S+J7A7musU20amB3d7edOnVq5ZR/lpcGWf/fG+yr/62Nm8lwMEoQx/MTWmsrARXxKdmeOXOmBCLVCoSq7qqr73PWb4EUXU/t1XNEqGcOngkEvOyqLHcYWTbBs+s2n+EKk3RWA+Wp6y7nVGcvj4DcgwSVU+dUBQeSbigPzYARRNN5rmxcT69dnkOAx8FcpXueh88o+vMk6ii/OcubbE+PZ+Xr4CnJxdvFZZJWLlQBAhJnZdmOkqnPcCdK4Ic8J/tE/ob6ns9Ss2+TaGM8WNAb27zOvNYDzeItvfJWJDDJAAH7iqf3Psgyqaf+BogemO/ZDreHVTrXn/QMVwj05KW6MGjLIAj1hvnLBxBoJ08cS9kPfVwmD0P6qT7NAyv9tY7pmR6QZv+g3viqAQ8Q9PSY/buyIZ6W/AzpQxrf0hg85NP17NDVSO973/tGp33Ywx52CTmZ6WqjoX52uXg4KTQqQPDSl740/p7p6qAK6FzqMlvrBx58JjOBFn37AOTLgYf48OCAg08O2Ok+8xoqy3+Plf1QUIGUAh36XTna5EVpXN50wpluyMn0a56P19PBnj+f0o/R457T4/UbCtpV/PO+y2bomank8unpogcnq3ZzHdDvXvljB06fnWd/GmrrCvAnALMOJZ1jvom/Sv/HlnXctI4t54wu69PLp9Iz5tMLDoylqYHzMTZR1Gvv3n3XeQ+O6Z4Haiu5UK+rLQ+0x/586hMJACaqnh2SA39Xkx5VeUO2xCnpZJWHj1nr2APX/SoY788kqgL44k2BAurRlHF+iJcxfpbTSQIgl4K+6qu+KvoTSZa9VxnPNNPtneYzCG4D5AAw3Rt6PgGVyslP5DPbXCmgGQEO/rxPh6AKDKS66X+1lM8Hao/+05nzZ7hUcsyA68EN5d0DXj3HzcFiahNu4+BKDM7YpDIrkJlmTdKzPtAmYNJbWunlpZmPIf2rAgU9x8Dz8N/VKoj0/BhwQvmktnOZpHLTaoge+KscU/9dzRazT6X6+Owo23YoAOT19BUELIsnxrP+zEPE7QXkIwVLVG6yPUmOQ3J22+H1SHn0bPKYYEUKtPSW3Pd0xvmu5OG8jwUsDoirYN5RyPtSFfSibtPO+6ouBQsODg5WtnuR38SztwWX0qfnvczEP6kHOpN97ckg2eAe+Fd9/DyBJAO3fW47ND7Q/nhQxce/MfVUPqzPwcHFN9bwzR9eJvP0/ix/gYGA6uwBbh/sjf1jaawN8fH3OIIEPT/waqYPfvCDy9/vfe972wtf+ML2Iz/yI+3Rj350a621//bf/lv7uZ/7ufbqV7/6SrE400wngkYFCO5yl7uMNhKf/OQnj8TQ1U4Ewoy8V9HpNGNw3NQDPGPLrgaDMe3ObQT8zUCBf/tv5aMyK2ehtcOzHx65p2PBGSAN4tybK2fQga3vr/Ryk8NN0KP3Yqtsysmfd3CW5K80+q+AgA553NraWgkU9ByINFvke0J91kXPUUa6zlUNdPgkW/2vgj+Vc5xmtnrA3fOks+dyZ/DHnSulS4GNCvSnPugy9XrIeU35E6Qor9QvnNwmMX+BHd/GQpklYOwy47Jr6kfVji4jLiP2+9Ib3XP58NuXrjOty4sBAW1v4gGprtdepsvJl9JTz8aukqryd9mzTXp66cvXk74kwM70BLTV2OZA2O9V/XIItCQdGrMKqLWLtlUBYIJQz49LxdOHs8L+KtkUjKralnXa3NxcBhwkc73mNq1u8zHH7V4V+PBxq9Lr1D+dPLjkwQ6OWa5rlBW/vQ28PpVNS7/T9jPyxTLkk3jdXZZ7e3uttRa3Eezt7S3PHDh//nzb3d1tOzs77dy5c8t73p6i1C96fb/XV6oxMNlKT5Pyr/zHiu+rnb74i794+fs7vuM72r/8l/+yPeUpT1lee9jDHtbuc5/7tJe85CW3+y3Ttzc6jqDdcfBwUmhUgOC1r33t8vcnPvGJ9lM/9VPtSU960kpE7vd+7/faS17ykkvC5NVGdO57AHroPtOJKoeoZ8SH8tT/sc7W2DKY9vTp08sDAAX+uUpA++cdxNKBUF7JASPgEyVngOlYXzl6e3t7S/DOpblyKn2ZaXLWhmThQFgBCL7ZwWem3GFyMEV+KDfJnWc69JzVtN+aebP+lCfbwXlk/qwzHW3JNoELyZ6Ams5tChxVjq23EdvPt7rovu9p53PJqSNATQCuAnjUR74L3PNX+S7/sUvIOXOZgCxnwpSnyz0BFG8fB8bpOf1OQNn7ies5qVdGmiV3Z9nPOmF/YV7JcfYy/eNAKa10SO2VgpAs13+7PFK+bgdd5p4HAVSvHOe3St8bNxh89f47Bhg5+ew021721WWjOvtJ9Dp47v9n792jbc+q+s61zz2ve4siBEh4NZaFgFJolISGFkRNDDBUfEexSYJBpFWSVoSGUD5LLEDoDEa1JhSgDDQ+Io74pDUB7CiGiCEatBWGGhMa0rSEVmnAqjqPe+/uP2p89/3s7/nO9fvtfc59nKrfHGOPvffvt35rzTXXXGvN71xzrZ9AnjtINa6qz1BveMifg2PXafa92WzWDg4OFnVOr7FVWpbXm8eZlnlV7TLmfBV3eNGx58De53SOt1zB5xkZzofz4/VNjhAf5zifur3hfZfP0XagI0kOAn7v7++3/f39pUMKPRqFMhlqi1R/HxvTfW+D5GxJ46dTKivZXaeJfu/3fq/deOONR67feOON7X3ve99V4GiiiU4PjXIQfN3Xfd3i91d91Ve1l73sZe0f/aN/tLj2Ld/yLe2f/tN/2n7lV36lfdu3fdvJc3kNUhqYW8urLutEEawykRyHEm/r8NszCvjfTwxPgDb97k1SPuEn/pNhSIOFoMoBSgJLQ7z6JMs0nKxFHmoq4EoQp3QsQ8YPozF6euNA04EPf1cOAMqhB9Qrp4cMbVEVHp3k3aMeL6ku/J3kRt6ZdkgPqv/utKPOpedcJ3V/DIBM4bP+dg8CFa+n/lNXE+AZMhxpYCaZM/qktbyHe8hQdt4SMOZH/YTOkar+vXr5x3lKv1nHHg31YTpHmL7HR0VJvq7jKfqnGpOHAAUB3nHmudSmGnO8n4jcscV+oPnh8PBw6R7z8TeLJL2kbrkDTr/loD5z5syR1WZ3DvDa2HnZwW9PT5LTQfOPyvTogUo+oqrfuVM11dm/fb5JsvJnkuPVne0cZ3jQLstNbxyiU4lbCzwt5b0qVXNCj3rOglXoNDsEnB7zmMe0W2+9tb3xjW9su7u7rbXW9vf326233toe85jHXGXuJrrSNMZmuRI8nBZa+QyCt771re1Vr3rVketPf/rT20tf+tITYepapmqCTmAiXfP/DpYSoCKlwTulS4ZFeo7XVWZKm8hBcFqRdJDDkM3ZbLb0mq5eOQ6gVT+uVIsP/naZcNVI5XIlkfVROKgDWPKTVpvc8GTdne9ksJIHl7HLVnVpbXlljvWhkebyT/xKVpXhmiI1HKRVrwITnw6Ee+1+/vz56EiqgD8/lWwZbq+3FSQDsmofGoy+YptCr9kXWOc0NrCNKV/qtW/3SFsVfFUuHaaVQHIyxPW8r6zxGefb74k3AQU6LHS/p3f83wMnrEN6xlcYXfdJrJf+i/c0tup+cgp4uyQApzxSvXk9vapNfKU+3BvPndfUX5ITucpzaL5jfh5N4O2Q9Ei//Y0UHBPZzlXbMxzc27QqP+mKR7Co/d3ZleRK8Mzxw+WdADzl6Tw6+ThB3a/0nuM6gX3lTPffysfn7FQPl3XKS3k47xUf7swaa08lHlMdUv+v5vCqPkkWqT8mvv1ez3bolVvxcU+g173ude1LvuRL2sMf/vD2mZ/5ma211n73d3+3zWaz9r//7//7VeZuoomubVrZQfCABzyg/dzP/Vx78YtfvHT953/+59sDHvCAE2PsWqX9/f0jAMBBvt9b1TjrUS+/5EEeyotlVgY307ihT2OG75/nc3xmc3OzXbhwYWHUpfBg5z9N/m4EOxhNPKu8g4ODdvHixba1tdWuu+66pf3IXI0XMNW+RPImPuhwcAeEwlUPDg5aa21pZUorD+JFz4t8D3ZyskgO58+fX4S58jBI/5w/f37hPHAHAb9bO+p4SeDE24LGrurFLQbeth6KTV7JB6+5A4D14Kodn6PxrQgWRbZ4ucyPxmcFNKr9pqyf+kgP/LiMqM/ijXVin3KAof8k1iGBPZZbOeyk22xb1pnjIOXlfVttQH4qEJX0hm3A+g8BfHdKaMtLZbjLeeQ80CmXxsU0PrtMXXd9jEr8MJ3qqjFF4wD54nV3ZikvB/oOrFmW81QBLqXzfuTpCfJZ5wp0JprNZkvOXnfccszleHzx4sW2t7e3uE75eX9XHaRjGkcT6PStCImYr6IIKCvppbcl5Z/6VZWW5P2TchTRaagytC1POqO5kfOSoiE4t6ssl5eDa3fW+XjFa9yqRp5ZP5LLaVWg7OcKqH949IA7L1T2kC57/0rjnz+X8qJdMuSU6PXjIUfGaaInPOEJ7f3vf3/78R//8fYHf/AHbT6ft2c+85ntWc96VrvuuuuuNnsTTXRN08oOgu/93u9tz33uc9uv/dqvLc4g+M3f/M32r//1v24//MM/fOIMXmu0v7/fBd898O5pes6BNDHQ2NX/BC6Gyk9lpLKT958ginveZYzpOsEsV4kYWun1SjymyTWBNb9PIng4PDxsm5ubbW9vr21tbbXDw8O2tbW12MfP8xIODg6W/pNX8iRjgYao9ilqr6Jk4Tx7eKK3lRucNPjlhKCRScDkZz9wm0fSifn80oqyGzwEWaoDjWnyu7GxsWR0exkJ1BPk8jeNf/LME+hpxLpupZV1OgUoF4HB9PYKNw693R0Qt9ba1tbWElinfB2UuWHHezKw5ZxMxrEcRJQD82U7JdDtlPojQZc7CBJAcxCvfOWAk+ONabwPeJgzQSXLJiCjLN1xof7WWmsHBwcRtLIe6VA6haF73fXx80VaW+7H+s/nU1tUYzLvSdZ0AngebItUVwcTdOwl8EaHTnJwOM/eL9J85Xwk0OTPko/kENP4q/rIQbC/v7/4dgeKAzTvl+7UYJu21pZAdOqrqe/qAEPNA+wbBMUk9gfvq9VKvbev+HE9o+Nf/9UX5BhI6ZUm8cr6Ug9cN5OD0edKOk5UvsbuNH5UtoXXPRHtGOqSxkF92Gf0HMtwvfIyPK3zNwaspzJ6DoIhe8t5O6107ty59j/9T//T1WZjomuAqj54pXk4LbSyg+Af/IN/0B7zmMe0H/iBH2g/+7M/2+bzebvpppvav/t3/6498YlPvBw8XlOUjMrW+iFfybhLxqCDp14e6Tl/Rul7IIDp+ZxHASQHgT4yarSy4vnTAFb0ACd/X3FI4MmNnrRS5vWnPDXJE5zwDQBaLVTEwObm5mJlXkaff7x8lZv2JmrlygcoGhsign3Ji8YCgYBk7u0io4l1JihOejGfXzpwiwBB5Ks9XL0kEJIM3UGQDEXnXfd0LQGp5BBhxMWQEaZvOlBms9niNw8dYztRBpKPZODyYl3coCY/+p0MOH144FpqN4Fud3z4ChwNfqcExJ1nOUOks+TLwTnTJhDHZxLgTI4UB6pKL56TcUuA4+BD9xxs6ZrGpuQgUFRQa21J9u7oEEkOdBCwLceM60rnYw8jkbxNfaWYcmF/0bXKEabnBISS422IT9d9yilFEHC8S8/R4ZXkmJypajuP3qp45Lyn+xoLHJSq/PSKTuqWt0/iP4Fs5y85m8hzyk/11HyTIm+2t7fLNlKfpox8fOM442MP82E9XMf4rd88TJK2A+cLt6E4Zg4Z5tW84X1AMubc7s6lanwfwwP7Z5ovEnn9qvTOh5dT8XuaHQR/9Ed/1H7t136tfeQjHzmi69/93d99lbiaaKJrn1Z2ELTW2hOf+MT2Ez/xEyfNy72GTvNgK0qAmQCleqYKXz5p6k2QmtzpqND1XnivT9hu1I0xQkh8LgGVZPSOMXbcSBmqS0qTDJNV63ccSkYSjfWTLIdlVcDMDWnyJqCVDPMKPFXk+fKa+O3lRT12I9uBM4m8u5NgbJuvoh9jxwDnIcnZQUAFEBLRaeBAS+Ued7wa6qupDf1+0gXddzBKqrZeiHzscnmmMtehVWU4pjyXDcupxr/LocsVwOqNryJ3xKc5oXIircPbmHRjnrncc/iQ7Hs6LaqiB6q2HaqT2wruCFiX2O+Om986z98T7NGKfuiHfqh98zd/c3vgAx/YHvzgBx+xpSYHwUQT1bSWg0B01113Hdmffd/73vdYDF3rtL29HQ26IWN6zOST0iXjZxVjpGdcOM/+HCcsgQZ+tre3FyuuXI3l6w1VBq/pP3nnRO78uAHsMvbQ2spgnM0uvQuZ2yO46srXn6l+ChUnjw5SK4NBK1daWVEalUeHBWXB/LnK7Q6Y5HTh6rtHD3C1JTlzuBIzny8fhuYrJFxp5fO9fbiuq75yqzqRP5/UPRLCzxVIrx0jwNS3y4NbFCqApLpq1UjhwTQa9Qxlr2e5p536ncYNluWySw4M/lZaDxV2mfu4k/TbDWN/EwnTc6VzPp8feUXlbDZb9Cvm7+3FvunPU//Ubkrr9VEabsHwvupjkI8Laezc3t5e/PZoFm9f9lF3cvXG56QXFaBMMmR0QJWvR8SozzJUPKWp9MZ1dGheZD5sW5bhK9dMn+ZLPe8fPed7/lNYvDvVSMmZwud6DiyXS8qXeqfoBh2kyrao8kuAmP2ztbbUL3k9zQ+c433sTa8v5msF05k4bGvnXXXkYZuSK8cGH8vYT1VuGqe8fT1KgWOnt5miGPb395deh5nasfc/kfejKo/U551P3ks8VLqrdMlBxLniNNGtt97aXv7yl7d//I//8dVmZaJrgE7KqXdcHk4LrewguPPOO9tLXvKS9tM//dPtz/7sz47c94n2nka7u7vdAd8Np2S4jXlO19JgnVa5kxGo/JIRk/hh53GDTZMwDYXKQSCDgZO4g6Vk0LixkhwD+vh75Fl/GoOiCxcuLPEn0KB6CUxvb28vth7s7OwsDjCUPHxVwo0bnrFAgMYtEQKWOzs7i+f9MEDWlwaty9CBH2XKdqAhxbMWHCg6IPLQVH5UJw8jVxmst69kOq8VGKQMmT8PGVQ9aKx6Pqof24U8s+4JKDpxS0FyaOl5Eo3/yjnQA3Rpi0YV2so+62HylI2PTwTdDraUnmHRPpY4mHSQ3FprOzs7R/RBPKetIwQGrAd12tvb65Pk6WdoEMj4tic+q3qmMtIY72MG80l8u25wz7u3u66nM10ICh0g9hwEfi6K2l/bhqgXSY9SnbzOfo11T8DN+1jlfFRaPzSW44ecetJxnrficnEdZZpE5IEOQZ/vkk4wj62trUWo/3w+bwcHB0vnJ/g+/CRL5q26zmaXtq15GvY5jbF6lo5zzZ2c12kX0FHLOYh92x0hrS0fjMs2Y33kKEnzsTt9yR/zoRNCfYllKS+OoZLb4eHhYmFMTgKXo+qm62yjnh3Ws4lIvXtDz7g9WfXd3v3TRB/96EfbV3/1V19tNiaa6FTSyg6CF7/4xe1Xf/VX22tf+9r27Gc/u/2zf/bP2oc+9KH2+te/vn3/93//5eDxmiJf/XKqgL5f43VSMhKd3EGgQTwBi8pQ4yTm/PA5GlYClZubm4sPDQcaEgRfmtgJmiovdWv1q85ofKUVTpEbFvP5pRUYGiniV3zS0SEHgSIJHLCKaGjJiKaBsbGxEU/9393dbefOnVvIhfu5VQcZSQ5yfCWmMjTTqo3awuuVniM4SQ4CGdpuXOkjp4zuVf0gydL1p+cg2N7ePrJq5eBRZdNJROeX80UDN6189YACgVsF7JUuOcBaOwqA3BFABxnBLsGOy4PlOCDVbxr3bki7fvhhjpQLHQxuzMsxluruDhyOG65f6XyAqn+682Q+ny8OqaOR72BbfLhjQHrtZbjOef/UPfaryonB8giASD72U3bknW2dPjwUzw9jo+OT4Jfh70lvHQSn+alyGvghl86vr/q7Dqb+kNpXdeNbZJQHnVzS16QLXh+2GccCjjOSUXVYJfORg0BzhB9g6JTsE+bpjsvkcCawVz+kE4DzvZwu7ghI0QPkR2VLbnQQqP0oOz1TORx8zBbPXk+Vo3nXxyel9TFYDoK9vb2Fg4D6Sz58DBhLPhcxTx+3ndK4zrr35jvnweeG0+ok+Oqv/ur2tre9rX3TN33T1WZloolOHa3sIHjLW97S/vk//+ft8z//89vXf/3Xt6c85SntkY98ZLvhhhvaT/zET7S/+3f/7uXg85qhZJS2dtSgk4HMa24A8J7IV3oq4CcApv801kScDBxscBJTGveG8xmuLPrHVxMoIzfmexMnZekGoMvM28BBGJ0IbJO0cuOrEG7UOMCm3JLxIt6Zl66JFzpXkiGvOvqJ2fw9ZIg7oPIPn6csHWQlQ533UlkyQsm/6uWgy/XNAZW39dCqkYNMlsWICq+LG0VsO/4fMvrcQZBCo71MPadPcgpxpUs8yZBOY0BqcweS3gbeB9Rmzqva2EE3658cBD4+eN1d1v4M9SKdXO790/WQMqZcvG3SOFFddyeU5+fjQ48Hytfv8+NOueQgkMzGOAgI0tL4zbp7CL23n/PBMY1183r2ZMhrTFcR6+TEfNQeOpTW69IL5R8qe4hSH1c56tPKR84K9YUqMquqp/Pv4zvvVx+mSWNwpfepv1D/ffCQe2sAAQAASURBVD5xR0tyLKR5iv85dhC0e5+ijL0dnOg4osOWbdajpDs9/eR3D6gPXR/qSz0+PY/TRo985CPbd33Xd7Xf/M3fbJ/xGZ+x5NhtrbVv+ZZvuUqcTXQ1aOzYfLl5OC20soPgz//8z9uNN97YWrv7vIE///M/b6219jmf8zntm7/5m0+Wu1NM7r311bLWxh20U+V50kSQkciN9J7xwGfGTkrkg99D11dNyzSz2ezIqoVC47nqRIeK/tPIUV4p8kFyk8GZAK2vrjCEUnmIhmTpxlYyHmjo+H0CGaZNNGQQugG3ClWgoVdvb4/Eb8/48Xssv7qXaGy+qxB1wfXD6y7ykOnEo4i64tsJ3BjmM70+5n3fnW0idx4lsEFKTiOmreSegADrncCJOzNSRE9vzHId5gr8WL1mXSp5JzCY5FOR93uvF8cxz6fiacx1l12lyz0ZMy311bdTeF5j++HYOafiVzzRkcR+Jl6GQKDaoLXlt6rwsyqY6y1E9MbQpAPOv/ctXdMWlvl8vvTt86fPHT6WVP2+sjuSXFMkGMdKRtDwNYarUiWvsemHrq+aT49Os0PA6Q1veEO7z33u097xjne0d7zjHUv3ZrPZ5CCYaKIOrewgeMQjHtH+r//r/2o33HBDu+mmm9pP//RPtyc84QntLW95S7vf/e53GVi8tkgDu68atXZ0YmlteX8zqQJdY50GVbkkN2yrsioQR2OY2wr48dUqAkOG77tRXdXJDfSeAUg5VEZgVY54UdigtgZQbtpzm/Y+uzzFF40fyUAh8ARCusbQTNV7Y+PuV0ZShuKLxpFHgLjsHEzqI0fI/v7+EaDJ9u6BDMowRTKQT+dpbPvQ6Ex11W83chO4rPSPup8iKcgT7+mQTeeb5MayeFZ9KqdG4lNtI0dT4o+OHzq4CCaUP7dkUD4KuWU/Y/g1+UtjSgK9+s0zP1rLBxF63Vx3U9vomutf1XYOQAjiqpV55uP65kDUx13mI5l6+HrPCeh9puckSHKi3nmdOFYxH3eO8ltRBgRNvg0lyX4I3FOWdEp5Ouo62071ccDs5amOHrHkEQOpTP1ODn/KT9e5TcwdAhsbG0uvjPRxQOnU51u79ApCjT8XL15se3t75YF5zlMPePY+VdqqrVgfyouvBpR8eN31QXJyJ7rruM9b1Xif+NR1b1PN5wcHB4ttBYzcSOPvGGC9qmNgyCmRxp2UZ68vrprnaaH3v//9V5uFia4hGnLMXSkeTgut7CB4znOe0373d3+3fd7nfV67+eab2xd/8Re3H/zBH2znz59vr3nNay4Hj9cUcbL3Vd9e+irdqgMxQWQvTS8/L5PgLYUVa+L1jx9K5GCLoLgy2Ek0Dr2+6XcyJnjPicayypFjQO81l/ElkN5aO/Leb9VPedAQZPghAc98fveefd3T9gKd6SCd4t5Llc/83CDyyT/JyoGT+BEYpKzFs6/mpnZUXh5h4aGdbnwNkRsyFYASOWBj/+TzlYOgAp4JaLJ+LNv51vMuA7afniHY6QFbryPbnitdnqc+3O7BPkw+CWL4nG+Z8TZNcnI9ZXmUr0fSJBl4vVM7pbasnAPMi4eVJUDtfZ3trr7Ca9RVtj+Bk781gPWhnL0eqQyvswM4r4e3l5ygTOvOJekMnaDKz7fQkBIQ8/ZIYzrzdD3WNeq8OwvcAZN4cZklvdZzaVxNdUrPzWaXHG/VqrjKTveoC7u7u0v9W867/f39Jcd1Gjs8T+9bPf7Sdxo3fN7heHLhwoV2cHCwdNileNV+fq7S+/iQoluUjjZItSBR2QWVfrqDQG8v8LktjTN+rVcm/6c5Xb/T/OXkYyed9BUPQ/kO1WWiiSa6Z9LKDoJv+7ZvW/z+m3/zb7Y/+IM/aL/1W7/VPuVTPqV95md+5okydxoprS4P0ZXw1h6nDBmH1UGENCwIJJMxP9Zzna7ToHCDkZOYf6c6c2IXAOLrCGVk6j/LoOFJY42Gqa/cSzZK54c90dAi4O4ZBm74uXx0fchJxXqoTBqsiQ8aMWzrtIrbA2ljKMmAQCEBjcpoS0DMjV6vY+IhOehSv3fAlcAb045xEiRemdZ1Usa49NtPMK/qT7BG+Trg7fFHnaDDkMYrnYl0WLS2DD57TtEKFK+yqsp+ncASiTrW0zumZ7vo21fwfbwh2Oj1G9et1P+q9vEP9ciBpDsD3Mnodea3y661o05hH9era7qenGLJoZDa2EHZULtVlOTL8cltAo4HdD6RD5epxmAduqd+eebMmba3t3ckfZUP61k5+LxfuGPJ+4XPxw6emeb8+fPxQEi2WSIv153m1fyT5iDyTd5SneQkEM8uM2/zJJuqfzgfzLfqOz1K5YwteyjdaaIXvvCF7fu+7/vadddd1174whd2094bFjUnmmhdWslBcHh42J72tKe117/+9e3Rj350a621T/qkT2qf9EmfdFmYu6dRL3rgWh2gh3hLRvSQwTiWxhhnTLuqDN0I1TeBlQzQ1pYPV6qMi2RU0eBPK/H+bDJweL2qy1g58XcyoNzY81XlKt/EK6+vq+N8foxBk+oylHf1+7i8M7+qzXu62wMu/J2cIUOUwFK6Xz1bUaWz0n/Xics19rmRnfo7+exFqaxSZk+WaYV3TJ7HoSHgUI0zSTd7jgXmm8ZH1zPX2XXGLx+3q7ZOZff0gXzxu7WjiwA+PlEGLvs0d1R9kPm5DKWvcjb7liHqWlUnr0cVZeX8u8M5tTnTJhnwu+KxGhvW7Q+9Nq7KqZwpSe+vVRtuiE4r3xW95z3vWbzp4z3veU+Z7p5W74mGaaydfLl5OC20koNga2ur/f7v//7UsTqUJuXeRL2qskj2Y1bGqutVuZ6nh+pVk3ZVXtoK0TPK3IB2Y4rXE1WGaJVOaRU9oHsKG9Y9RVDoPuXi/PFAQl9dcIeDy2k+n7ft7e1uyG5rR990wXZLIe+z2XIUgR9O6PWYzS69dlEruzoToee8oFw9/Li3Guv1ZP4p/Lp61p0a5GsdRwWdOV7n5KhIW49ay28NYb30nDtmWCeR/1a4t54nDx627OCBq9cp2sdlqvtcFU16oDoxNJhRSK5rkkfaNtPb2jKGHDQmGasM9XHX5WqsJShlfnxjQkWuk06+BSW1Y5VvAnqV84MgM+XlY5jfc1DquutjncpcBZCzPSRv7mXXWEUeGKXBevbKZP7uMBpa4RZp7vD25Xyi+0zrY8JsdvQcGF2XPJRerw3VFjaVp1B+P4PEnQ4p6stJstT5Nayvy1CkuZNbstI5A5zPerqRHAsJpFfzk/dVvy8+0zkWHMsoP+Xhep7mh7HU6/NVf9T/NBZX6dfl71qnX/3VX42/J5pootVo5S0Gz372s9sb3/jG9v3f//2Xg59TSUMGW+/+KgP0GOBbTQpjQb0Tw+D13/NxMEdQlkBE4pvGnK5xQu+tvPm1obJIyvfg4GBhAMmQa235vfCttUVYpzsI0qv1aPDJqPVtCPpW/n5uQwpRZagjZez1czmsuvWFcqDBvLW1tbQn1Pn0Vwn6KpIDCi+T5fWcEk4Evq0djfigUe26WtU/bUNQWYmfBLTcoeP1IrCknnjd9E39OTw8XIAkhvKrPOoZ+y4PTyPQYz0r54LyTnruv7e3txe6ogM52VaUEdvYx62k3z1yoJiMbuqEHBiU81B/8TzT+EViH2L9EpivQPeYbQ/K1/PidQeHDqaZp/qRb7m6ePHiwqGpvu+RV1X/TrL1uSO1V2tt4RSjc8xlxcPv+E3i2KaPy8BfS6k5gvzQSeK8iHid46I72tgfBcbT+Mc23d3dXbQD63/XXXct9van+ZNjrDsnPNKHdeccyLy8v+m6Xi1HkC5+6DCkLPi89xmOve4cSOM1n6vAt57TOKr01GGf81prS1tsXHcTebk+zjmvqb09v3TPx++xzoF7osNgookmWo9WdhAcHBy0H/7hH25vf/vb2+Mf//h23XXXLd2/t+3pGTOgHteb3PMKO/g4CeIE7AY/jYmhVeEqFNHLSs6B6h6vM60bdhXA8TJktNBw4SF9Au/z+XxpBVSGG1dJJBN/naHKkzErI4sGhQNiGUoytAl23TngDgIaSKynGx09+SiigjJlnbwclzdXWmhwehtUYDDpH3kZWtWl06Iy2ob64xAPlZPA+REPdB5Uq7y+wua8+6nffGuGdJX9lZEUDgSVD9sz9WmvL/tGkgXl5ueW0EFAfU4gSHzre8g5wOcqB0FyprlzhOkk297YxWdEHFMof9Zl7Nwx5hwG799sS4JX6gH5ckeAt6vrYXIsOXh2mfTqO6bNU/SAO0u9rdkGzNuv+RjFMY9l61p6nnUg0HWeKEfNN5Qh6y8wnoCi801dPDg4WMiH6egUEXGecqrGIemL3vzAMURtwzx646R4c0dyjxfWwW2MNIZUzgEv351z3oeTY5dRFb0olaSHaVxzOa9iN64yrqSxIPGUZDbRRKeRrgVdvtrlr0IrOwh+//d/v/31v/7XW2ut/dEf/dHSvcn72KdVB/shGgLoJ1lONcFfzja/Eh3JATONyvSfhl2SPydZX5VxsEbDxfPwT5KF8+ROgl6d0/9kLKiuvJ9WebzMSlfcSKp49Wuufx5VcdJUAdZkjPJ/5YRIwKQqt/dfeVTGbnqualfXfX7zmV47p3r2wAzzSDwN0ZBeV/Iak++6Y1nVn/w73b/cc+ZQ/q4P6b63GcFmGqv8+XXH8TFjXpXO76XwdXcqV+2lNHwFYjXWjm1POnOG+hfTJvI5QuC9ilQ6DiWHQQKU+q6AcaoDHRhjaN0+O0ZfHKSrPC//JMocQ2Pnj1TuZJdPNNFE69DKDoJpT88lco/z1SiflCaDdXibzWZLIfNaKeB/pXNAkEBTxQONt+qeX0sTt2hs+G1VFr9TuKxWxyQflak6UlbchqA8aYgm3rk6n1bcGeWQVsfEm9fLy+zpyBAA04fGsq8m6trY1UPdp14xIoN5+v/Wju6D9XTindEYoqTLbE/yxTIqUNQD7mNATdWHWls+c8J1QE4bbjWgAS+ZUGdS1I47f3gvycfbaWg1r6ozv8c4UXqOE/5miLDkVD1XtWd6JjkNyXuvDgSClUNliHp6OCa/pLMpX6+f66WDa46NW1tbbTabrQT6lBfHXUZecSzmfn4+m/a5t5bfKJDK1vdsNjsyhrF+qe1XAXBKT+cF+wB5SPOBE9tGW3okH8lLcvBzaEg+dvaitXwbSZLvKo5A6l9yrKWx2aP1WKZ+9z6MRDk8PGyHh4eLVxqmtxe4rHwbSsV/uj62TddxDPTKGJrnx6adaKKJ7rl0ZZagR9J8Pm+33HJLe+hDH9rOnj3bPv/zP7+9973vHXzuZ37mZ9pNN93UdnZ22k033dR+7ud+7kia1772te3GG29su7u77W/8jb/R/u2//bcnwnMCaaQKSJw0ncTqgEiT3ubmZtve3m7b29tta2urbW9vL0AgQTAdCAlgtdaOGD6J72RwV+GjbrR6+WMpGZFuhMpooMFAw87DqDc3Nxf7rdM9voN+a2trsad/Y2PjyH3foqBXLumT9qtTBnyukh/bx387cYvEwcFBOzg4aPv7+wuDSjKinMiTG3RVGLp/tra2Fveol9vb20sykzwVak9wLTlo376H4JIHnrPgTqDEJ/9XAN913YF+a600fFkPB06sl9pEdZzP50d0jw4dgR3lofycN98G4O2W9Dw5fFj/5Hjwfln1d/+k/iFd9JB0/lY7EHywLd3pqLJSpJE7B1YB6qyLeFQ+aTV4qA3StgmXX+VQpcONTgIvX7ylfrq5udl2dnba7u7uYo88t5g4T7ymMUbvn9/b22t33XXXYpw5ODhY6scEcX6+S2v1Ia498jxEGqNVH47P3pdXKcOjy8QrnYK9/kJS397d3W3XXXddu+9979uuu+66dvbs2SOO61Xnymq82dvbOzLu+5zv/Tg5Z6sxj04f133OlyqP5aYowFSH/f39JX3b29tbHPToPOt3WiCoxrEkT2+DsfbiGKdLNddXaXo21lBZic6fP9++8zu/s914443t7Nmz7RGPeER72ctedsQxvY7NP0Tf/u3f3t797ncfO5+J7lk0pO9X6nNaaOUIgstJr371q9trXvOa9iM/8iPt0Y9+dLv11lvbU5/61PaHf/iH7frrr4/PvOtd72rPfOYz2/d93/e1r/iKr2g/93M/177ma76mvfOd72xPfOITW2utvfnNb24veMEL2mtf+9r25Cc/ub3+9a9vX/iFX9je9773ncgrGqsJZKyhcNxw6Z7Ced5DHn5O0A5ok+dez41xDniZNIzYcWgI6L9P8J63l0FPvafXf5+89c3DuOQgmM1m7eDgYGkVNgE5GixJvr1VGz3f2qXTsFkv7jung6IH7mUMVcZIdS2RG9qsh9dXAMXr7vlRZxyYuFx0TYaht5v0kYfNEXSxTOWjcl3v9ayvvKdoCZbhgFP3vc0rpw6jSJSn55/2YKfDtJSeTgHpT+W08P3uKtf7enLwuIHMbxrS7Mtsa4JR8sY+m/qx8nRQSCcA89Y16igdNNRl7QFPbx4Rjz4mebv2QMLQGOl5sA28z3i7EWClcpNesm/wbQwc76STHhHlfVbXBbIEHvnWgVRnjrsCaWw7OgS8jj5PVBEjlczJA/sI9d1lRvCawLHLluVUekOHQc82SPYGxzGOW2fOnGl7e3tHoiLEi49nDnR9HmZ6ns3jkUVJvmm+9m+f/y5eXD4A1x2zrbUjOkuedZ2HwXIR4MKFCwsH1J133rlweHuUhOuPxgvppfetZK+ke702qXQqUY/XKl0vn1UdA6JXvepV7XWve1370R/90fbYxz62/dZv/VZ7znOe0/7SX/pL7Vu/9Vtba+vZ/GPoT/7kT9oznvGMdubMmfYlX/Il7cu+7Mva3/7bf7vt7OysnedEE93b6JqJIJjP5+22225r3/Ed39G+8iu/sn36p396+9Ef/dF25513tp/8yZ8sn7vtttvaU5/61HbzzTe3T/u0T2s333xz+4Iv+IJ22223LdK85jWvac997nPbN3zDN7THPOYx7bbbbmsPf/jD2+23374Wr9XKi1+v0vH+UJpEV8ILJb5SGLEDOJEbFQkUDlGvXgk8OI0pr2cYelk0PB2EKC+CpiQn/59AlhtnBKCJJxpqQ/LiMz3ZjaW0yuwrd85bBZ6STKhb1f20ckNHgverZOCSx6ptEo9Dn57c/H9Pp/w361F92C5et1Qfz9f5S3Kq8qzk1dOBVEenCsRW/YOOjkpO1Qoz+an4cpnwu+cEqCjVY0weiUc6clYpk/n5/SF+qn6cHEdDfHkbpaiPFLmRPsel1MZpbEhy8t89XR075w2RO+0ZDcWItKr/kHpzpLdNGnfSXDpUl6RDen5M+jG6lXiiftFZkLawOHlEwSr2zlC7rgvMx+TtaYf6zzq8vOtd72pf9mVf1r74i7+4ffInf3L7O3/n77SnPe1p7bd+67cW5a5j84+hN73pTe2//bf/1n76p3+63e9+92svetGL2gMf+MD2lV/5le1HfuRH2p/+6Z8eK/+JTi8N2VCX+7MurRsF/+/+3b9rm5ub7bM+67NWLvOacRC8//3vbx/+8Ifb0572tMW1nZ2d9nmf93ntN37jN8rn3vWudy0901prT3/60xfPHBwctN/+7d8+kuZpT3taN98eVR79VaMAxoQjDhlyJ0009BkO2iv7pHjxzjNkTPTyGDK6evd8JbjXsRM4qtJ5tAENG4KVBEASgGR560zwPVmtM5DR4Ko+NLQTGG/t0gp4ck6JhvpNVf8eSHa++FzKy+vteSReKCNST9cqgDbEm+eXHBEu42p1zs+XqABaKlfXKueMXxsyynt61svX6105SZKTxdsh6a+fPdJz9Hh9xtAq4/7QODh2bE0gzJ0ASYe8//T6e2vLW5cqZ8BxDawx1DPqyA9XiqtxnfUWpai7VLbKIyXwzUiDXl2UxrcAsR28D7Ku/l90nLm/msf07XVLsvW6VvVPYwyd23QSpLK9PdP40esrPRqj00N5HMcmPCkenT7ncz6n/R//x/+xOMz8d3/3d9s73/nO9kVf9EWttfVt/rE0m83aU57ylPbqV7+6/cEf/EF797vf3f6H/+F/aD/0Qz/UHvawh7XP/dzPbf/kn/yT9qEPfejYZU000eUkRcF/x3d8R3vPe97TnvKUp7Qv/MIvbB/84Ae7z33sYx9rz372s9sXfMEXrFXu6C0G3/7t396+/Mu/vD3hCU9Yq6Ah+vCHP9xaa+1BD3rQ0vUHPehB7QMf+ED3ufSM8vvTP/3TduHChW6aRNrvKPr4xz8+qh4Mxx1LqzoWKkqDfDIyes9qsvD9rAnUpufG8FhN5PrN76H6JaJBNDZPBwL+6qL5PL/GjcCA+349skLE10xtbGwshTsyWiHtA3fDhPXyQwNFHqapevBZ/ee37qX/4sHvsS4Ku2RbUFatLYf4e92oh5Qny0xtOXSP4bcEOCyjAkOsu9eN+qN8Enju9XW2v/JPoID1ZKSPZM+yvUwavi5fBxI9Y7i1tjgQMbWJ64zz5SCe9SW/voooWbts2Edms9mS8c/6sp5edwKFoZXpBAI95N4BSfUcAadTD4SorErnPbRalGSf2k9bddKzSq/tTuSN+jufz5dC3RnyTqfA/v7+kmOA52j46wxTmLvXU3JNc3F1aKK3FXVbebm8de6C64+/TlDPVuA66Ql1VXaFzwOUe6oP+dC5BDqnxVfLfUsOt6+kscSjhxIlWaZxXfwnpxznDo8UUxrXOV53R4efLaTzdHQeAbe0ULbadsNrahfd4zzhbavfbP9kk4wB471+T+qlqcofok984hNL9vDOzk4M3f/H//gft4997GPt0z7t0xbyefnLX97+x//xf2ytrW/zr0uPecxj2mMe85j2kpe8pP2//+//237xF3+x/eIv/mJrrbX/5X/5X068vIkmOiliFHxrd0fOv/Wtb2233357e+UrX1k+943f+I3tWc96Vjtz5kz7+Z//+ZXLHe0gOOk9PT/xEz/RvvEbv3Hx/5d+6Zdaa3l1bmggHPPMqvm+8pWvbN/7vd/bLbciToqa1C8njQXOQ8TJWiDKQYKv9Hr5NFp6/CbwkyZ3/a7ySKTrNLCS0yAB7dYuvRv+8PCwtXZp5SgZ61xtrRwoLjPXC4ZDyzhJho3ypeHuq2zK1w02N0YpA1534E/gkgCS0jq41XM0UOU0SCDdgaiDUtWHsvJ2cLBAPvVbRqY7v9yBULW119vLE68Esg4uq/bwAycdYDq4IGDwfsdnuUeaer+xsbE4TJNRAZQP6y0wqLodHBwsdNEdYjT+e+Mf+8F8Pj+yj5dtL1J68cNVPxrrBEjJwckzCDge8ZnUFmxj6oz0m/ykdqOMXAdcN1ym/qmI46fkwvS9lWfyKICvdlfdkhNS4ItjB2XFawLSAms8EO7ixYtLBxBWzqUkO/73fsr6JXk7gHcwTL3kWKJ239zcXDpfQflVtgjHEpYtB6vPTZKZ9I11c9BKfRYPm5ub7dy5cwv5an5TmTz0lme89GypNFandnE5sN/ov0coSC6UM59LeuXjLedH30LAA3V19sDe3t5SJAEdEjqPxHVQPLK9fBz3/5SD62uSeXIwJeJcrP9+zdN7//Frfv+mm25a+v893/M97ZZbbjmS95vf/Ob24z/+4+0nf/In22Mf+9j2O7/zO+0FL3hBe+hDH9q+7uu+bqk80ljnx3Hor/yVv9Ke+9zntuc+97mXtZyJri1K88fV4KG1o4vOlaNNUfAvfelLl64PRcG/6U1vav/5P//n9uM//uPt1ltvXYvX0Q6CN73pTW0+n7d3vvOd7S1veUt70Yte1D70oQ+1pz71qe1Lv/RL2zOe8Yz2wAc+cHTBX/qlX7o4RLC1tlit//CHP9we8pCHLK5/5CMfOeJhJD34wQ8+EgnAZx74wAe2M2fOdNMkuvnmm9sLX/jCxf+Pf/zj7eEPf/iSYTQE/teJJhgzODpYSumriSaRg1l669NhbNWzPUOC1yqvefKy9zpzyouTaAIWbih7PpzguRq0tbV15BmXlxvuDnZdJgJdCaQkQ4d56hlfVXMe+V3Jo0du5FWGHoEQdU8Gs8qRgaXnEhBlWgdRlJXLU/+TzrhRX+2NpnzpYOK9JBuW62BZstMzMjyT3hF8JcdC4sf5Z16uV0keXOFV+dvb20ecgmx/rsbpv+uZgxuXiZ6TThBQOwBt7dLp+t5H+YYOyoA6mcYp/mb6w8PDIwAsOVgkGzm60sGk+p301PMmnyntqkZzNTe5Tvk44f07PSvdSe0qnaA+cOxN4Emrtx5RlQ4AZHneRtW9lKYi6q33X9VnNpstvX2GPKq+6kvsGy7bNAb4fECwznFkzNjnOqtoB/UvgWQ6IBKP/F/VI8mxN14mvU6RAEyfFip8nKzmT5/TGZnibwZiW7BsH+eYzud5vz8WnLjcUh9MlNrf54UqzSqg6X3ve1972MMetvhfLRK++MUvbi996Uvb137t17bWWvuMz/iM9oEPfKC98pWvbF/3dV/XHvzgB7fWVrf5J5ronkAPf/jDl/5XjrZ1ouD/03/6T+2lL31p+7f/9t8u2SWr0krodTY7uT09119/fXvkIx+5+Nx0003twQ9+cHv729++SHNwcNDe8Y53tCc96UllPp/92Z+99Exrrb3tbW9bPLO9vd3+xt/4G0fSvP3tb+/mu7Oz0+573/sufValVZ0DrY2PBrhcUQnVZD/22hCNnYh6Hu91yj1JSkbSSdAYAyLVvwKQnl+SqV+rnDc9Oo4uVrynFekKyFQrWG6Eps/lpLH5J4N23bIqg97TJhkk8FzJtuK/tT4w5Tevj9VDfTwqIoGEsdTrMz3q6RvvV9fH5H85xtjjjO/sc+vwk35X/CY9WaWsXtknQUNO2Z6sTmLsqZyHdKZUfcL7dop+GyI9l+pTlVnVY6ic3v+UhzsH0rX0nfp/rx+kfp0WIe5JdP311y/ZxZWD4M477zyi+3Qq3njjjWvZ/BNNdE+g//pf/2v72Mc+tvjcfPPN3fRpjE3jzIULF9qznvWs9r3f+73t0Y9+9LF4PNZrDk9yT89sNmsveMEL2ite8Yr2qEc9qj3qUY9qr3jFK9q5c+fas571rEW6Zz/72e1hD3vYYt/Ft37rt7bP/dzPba961aval33Zl7Vf+IVfaL/yK7/S3vnOdy6eeeELX9j+/t//++3xj398++zP/uz2hje8oX3wgx9s3/RN33Sc6ndpHefAWDoJ54BHP9BA6J09wPSi3sRPLz+vcx/oGCA7ZERU4JLk132FyQ2k6j3o1Qp0ZTAlI863BnB1g6QV3tns6Gv0fFUk1VPPib91ZJvS9wwgyoPeS66aa9WG8uKeV62cOXE1Tc8m49YNX31Llr61QKQQ3mSUVqt2/rsnz7TK1drRcwd0rQI4rnNcJfS8Gd1SyYurY37quXhx+TJSgFs/2KasbzKkKQuPIPBIAt8nTd2vgL33R9ZDbZ3Cf5Wf8+oRCd62CXilfu39cAwwS+MpVyiVL/sIeWc5Y5wVnjefZ9swvx5Q0/YRbSXglhqNc621pVVsB29OFf/sQymihXVLgDDpayLpkGhj49K2HT9HppL7UDnqUxw7JaONjY2oW+kj/jiu6AwFpeEZMYkfRnf52Dqkm0mPOP6pni6rFKVH2ejbPz4+8DWb2lKhCAqeG1ER28DHbV3nnMR6sd6ue0P9UWnG2kC9tNX1VfIfS1/yJV/SXv7yl7dP+qRPao997GPbe97znvaa17ymff3Xf/2izDE2/0QTnRStsgBwOXlorY1eeF41Cv4Tn/hE+63f+q32nve8p/2jf/SPWmuXxqHNzc32tre9rf2tv/W3RvF6LAcB6ST29LzkJS9pd911V3v+85/fPvrRj7YnPvGJ7W1ve9vS+1A/+MEPLk3IT3rSk9pP/dRPte/8zu9s3/Vd39U+5VM+pb35zW9e2r7wzGc+s/3Zn/1Ze9nLXtb+5E/+pH36p396++Vf/uV2ww03rMWnG4vHpRROe7nL9HIr4Osg2I3Cyuhvre8gqIASqXePfK8yGVZGGOuqehAgETDoHvfU8/nqFYXOkxtwMlqcH4WyMuy2tbb0n/nqurdbApjig+ShkeQ3AT4+l0Co0lOWHp7OewLwXobrHMslr6ovT+oWP2krCHmazWbt8PBwqe0r50BFlF3iN+m/g6AxRiEBKM+l8A+dIvp2og7r1Wjb29ttc3OzHRwcLIWNsx8QrKgdtUWBddJ9tlPqCy4/6ib7idpKhr87GCrnJsGH6x6ddmyr2ezSuR/OX2p3gihdV77uzKj6pP/39MmR4aAr9QuO4ZVOp37Hb2/3am7yevNAOB/v/Lwbti/7CKlyRHm6XnQK049xepNUf/YHjf8qQ4cvSgZpPBh7jTz3DggVEKY+E4Arj9lsttg6J77p6FPbUF4cRyvQTgcf2zTZE94ffOxnWWk8Vdv5ORUcJ/zwSG0lODg4WHykmw74fT7S2ELHlmQu+eh51XXIGeXzUNUnq2tpPHX+q2ecF3++V/4Q/eAP/mD7ru/6rvb85z+/feQjH2kPfehD2zd+4ze27/7u716kGWPzTzTRvZkYBf8VX/EVi+tvf/vb25d92ZcdSX/f+963/d7v/d7Stde+9rXt3/ybf9P+5b/8l+3GG28cXfZsfrXdKaeEPv7xj7e/9Jf+UvvkT/7kpclC5EZSAv3V4DzkIPDVA+ZV5dc7n4B5Mg+tJuzu7radnZ3FaccEzgQX1eo586QhTv5ZTxkJ4ieFD3tdXW3TZOZp00TpK9g0YFT3zc3NtrOz06677rp2n/vcp93nPvdpZ8+ebZubm217e7udOXOm7ezsLDkVkqFPI1ZGiQyTvb29hdEiOet1VFx504nf3LPrh9t5+7rDIjkNXB4iriYJiKWD/ViOG8tqbxqULEdAXrJUvdN7u+nAcZ5pVArkeps6OHbwQf63t7ePGKXsi65Tnqfqrfbz09gd/BBMuTwJsJg29RF3NtChRQDj5VLvzp0717a3t9v29na74447Fm91cYPegaK+d3d3F/3C5ZKAKvPhhxEoNO4J7P2Qwo2Njbazs3NEf9I4Qp1I+XAsaK0tnXDuDkH/ZhmSMQ9I83bzvufnnqhMl7XKSA4611GtEPuYm4BLkhWBvTtvNDZxlZafO++8c8lBQADKA+TOnz+/OLRwb29vqU+4DvGATfHh/Yvjr4PRNLYMOeF9fKcecAW+tdbuuuuuxSF41HHKPI0trrtbW1tH5i/qJp1RPGxQ9dXYLUcM8+GKOh0L+/v7R+wcOhtlLwzJSueZcPzR3MpoEtoZbB8/46OyK+iAcz3lOCyHpw4lpIPA5wPqE50RKovjEcv2QzZ5eCXlmWyDHiXdrGy8lH/lpErk48OFCxfaxz/+8fZf/+t/bf/df/ffDT5/rdCP/diPtde97nXt/e9/f3vXu97Vbrjhhnbbbbe1G2+8MQKsie55JPz2kpe8ZO2D9U+K9vf326tf/er2sY99bPTW9Te/+c3t7//9v99e97rXLaLgf+iHfqi9973vbTfccEO7+eab24c+9KH2z//5P4/P33LLLe3nf/7n2+/8zu+sxOvli4O/l9OYAfik8zuur8cNTn0PeZvHUAL0biBXaXv5DfGxqkwcEHr+yXCu8kl8sM7JqeHfPX5oGPXKcerJ/iSoJ7/Eg9dhbP5ejpfpTgwHYIm/4+jkKmm9nVL7j20nl0dy3LkcKnl4fg6GPA2JRnJPx1P9/JlUdzo0aCj38qr6YXq2R5Wu9dImx5I/e5J9cExeY8ev3nNVeWNkTRDl7TQkozH1Sw50/a/6tV9nv6j6iD/rzqcUvaJ76Tf/j5nTev2lN7ak+qZxIbVDxXdr62+pJC8OflP5Vd9JY0VPPkPzz1C92a/HzCtDlOo51J/G5nVvpttvv7298IUvbF/0RV/U/r//7/9bOBrvd7/7tdtuu+3qMjfRFaehseBKfValZz7zme22225rL3vZy9pnfdZntV//9V9fioL/kz/5k/bBD37wpMV1clsMJjr6ahu/dpyBu1KqNGmN2YagULkercJvZXzRez2Gr5QP80jp9VllQiUA0n8aR4wG0Gp2OlXf+VBYZdIF/fYTlJlWbeLveWb+FaB2g0j10OuZWPfEl75p/LisPES7Ag6VUV/xzRVF5is9TQCtArFsuwrgOiXd8bpSNkODfKXH/Hb5e2QAo5E8PL8Cq+KTH1/pdlmRF8pd2wr8VG93IqYQbvHvZ42QZwcHlLd+c+VNe4arUOBk+PcA2iokXhk9llbphxwH+k5baEhJb13ve2U7f6yHj8t6ttdX+Uzq3xzLPLSd7cXxNa2ksk+7zvpWKtYnAULyV/XbJP8UjTVmGwJD6xnpxDeFMBJC+pnIx2Ol9TpKzr5CzfGjV1fXSf73V1rO5/OlKBnW0eWU8mfdUhu5QyXJmvpLHn31n1sKqq0GjLKo5J/6oI/Hfo3y8PmjIgcO64CI6tkxeaWxaOj/aaAf/MEfbD/0Qz/UvvzLv7x9//d//+L64x//+JXPSZtooqtJz3/+89vzn//8eO9HfuRHus/ecsst7ZbwhoQhmhwEKxInf78+5lqV55gyV3E2DE1IreUQx+QR5+RRgXAZMR6C3QPunBSH+K2AecVna0dfTcX7vh87GaVyCmgrgULglbeHecuI8wMDPRRXIYgMBVVaf9ez6kXDJjkJ3OCkQa+Q4l7buJPFtwJQHgmcJp3xNnCjyssnAJFjQPs99XouBxCttUW4qm9/6RnzpOpeD8D0yFcxXU6UA415D5d1Z5MbozTqk3FdrYz1xhLJX6G/CsUlWFDIL9vRQ7tTJAF5GwJGXGnWMwoFVlkKu/bQcO+DrsdDbehp6BDwVy2KN8rRdZqktNTV5BBynskb06S+KFJ+HOPccVI5CdzBxP6c2rY6PJLjlrcFt7o4oCaopm6xbPUNH4e9fShn1jU5WHoOhNQenj/7wGw2W+or6k+SydCcR6dAcnh4nTk+kPifDlflp/FAof9+xodHe7R26ZBCbgFyO8bHJpXHw0HpHBhyYrqMW2tHHATKk+cN6J62tnCLgW+VScTxtrouWchRoz6nvsP6prlvrE1DSuPNEFW2GH+n8sbMe9civf/972+Pe9zjjlzf2dlpd9xxx1XgaKKrSb2+diV5OC20loPg3r6nJ63srUK9gXiozFVoyAhPBmTvuQpwVfWpnCnOiwMNN4qYt09ouq6y3ICoeJFB4qfsp8gBnsfgB4/5qpE7Jfw8BRmJNGAoPzoIVA4NHt9bSlmQB8lGxpmAduX8qYzNMYAqtXHlIEptw0O9JFOCBB4IKd4IJOS40X5Yll2tEDmxjjQyeV91HaPT/FbectQ4OKMuOdiRcUm9ZDmMbqGBTT2gEe115X9Py8P/WBftKfa9+yQ/UJP9XDxSN9y5IV3nmRz7+/uL/ypD7a92Yz1S2yU9TqAwGdLz+XxJx8Y8l+47uOcq8Hw+X2pDPked8Xs9Yh93x5IDTq+vA8RKTwnGfNVWIEz5cwxlvnSMqL/rHvNN9fNzWJhfagenqk9LLj1nTeKDc4g+Asbsh963XC5+TfXa2NhYyFvnWahNNU/pPx1nyisBcDkzWIc0fuh5jkecb1iet4Hu8Q024sE/lKvLWMQ3Eyh/zrNDDgKmr9pf/Lkck2PAnbeqZ3LIsU4+V4wFEa6P/pzrUM8Zlp457XTjjTe23/md3zlyIPm/+lf/qt10001XiauJJjodtLKD4Pbbb2/f/d3f3V7wghe0l7/85Uf29NwbHARjaB1Af1xaxWGRJgGf+Cpy58C6k4km5qGtDmPyGUNuNDr4pYHq4NpXzzmp89sne5VLQ5qra57eVx6Yr0cPsK3d6cN8PXrCZUbw4GGRST7JSE+UZJH0hcCF7eK//T+Bs5wINLpdJquSOznoSEkOK69nZfRVhpx/3Lnh/cR1k6v77ijiKmwPbKZVYBH7BZ03PlZwhZoyc92iPHyVU5/Dw8NFWm0xcJ1I/Y/9w1f9eyCvGssIzFJZq4yBqX95REfqAz2+PYpCPI5xiFT33QlSjTu85vL3CACfY6ijqgfBpm+N8jkutTf5HVr1H9Nu0r9e2jSesh66rvqynr320D3fmqD6KRLt/PnzS4cAqryxc6vLm3rp34xC8HGdY0o1hrszPUXg9MZb6qc7q+gU1fjl41k6kHEMOc++GMA6cNGgZ2upHomG+mnSxyEnQUVDaU6rw+DFL35x+4f/8B8uDjt997vf3f7Fv/gX7ZWvfGX74R/+4avN3kQTXdO0soNg2tMzEelyThwnmTdDWAn+E/iUYUXAlciNU4J63We63mpFMqIchKQ6VcZNMqpk4KVIEMqkR2OM2VSfIRoy4CnfMTyMMepZRi9PN+a8nqn8sTRUH7aPvn3lTdfcKGceDjgJXhycsh6UDQ1t3eNqaGvLobWsnxv2qZ+QT65Ci1I0yCry7gHssTRk7K/Kg485dKR4Px1TblrpJN8O5LwdhsBK5YzxvFId120rz4tj+SoO8ZT/WPDU43OVvFgHOkVZjr45VidnVG/sH+u8Sv3d+UzP+Kq4OweYdijvaq5w3fQ50a975Jc7O8fo61h+SD7vr5Ln0DOrzicVreNsuCfQc57znHb+/Pn2kpe8pN15553tWc96VnvYwx7W/rf/7X9rX/u1X3u12ZvoCtOQvXWleDgttLKDYNrTc4mOEyVwtQfkofJXWdmvJr+hUGymoXFBw8mNC/+v3zQ2knffQZQfYsffCqHWq9r0yjw3BhXGKAOpijDwfZLcdpBWWvz1YP4KprQqURk0rqMJaCbQsgp5GemcAm/XFD7tILeqD18BRmPZI0TSflbmxTyrNDSCaYS6rFw3dI1EOVSgOU1gbnCzXgz3pwy9X81my6HGlGXS2bQirO0Rd91111JoreS3tbW1tEVGK5zUw8QH5Sx+7rzzzsXr4ZhW2wpoPDNiYYh6gNWvpbHHoyMIDrz9ma/IDyfkoYebm5uL/k097vXj9D9FE5Avll85CKgj/jx5GhOinaKhKvI+xZVYvmJPdSAP5DE5SVI9OH4kh0MCt6Jq5ZvXHNj6nEr+/VWO8/mlwwd5CKHKZhQanaeHh4dHXmeYeONvnxvJu/NJUhvoQNMUgeZtwzGK/YhzEtuBUUycc3VP11wf/VBTvl6T9fK2dhmxntRld8ZpG5+3U4qoWoWSk4f/q/mG13p1G8vDaaXnPe957XnPe1770z/903bx4sX2V//qX73aLE000amglR0E056e45ODpOM4Gkhj8kmTTbXKQOPdDVY3itKEpfueZ0U+eY6Z8KrJMTkJfK+2rjNSYDabLd6hvru7u9g/6sBVk74MEPHiodIy/PwQL/GsvbY0yuQU8HcpO5iSkejkRjiNT4Iwr1MC7Wz/qhwCPfHUA/pptTsZlySGdrq+Jh7cSE0gWG1B0C5+XA8JknldbTfGGaZnqJsVYHInBFdN5bCiLqdQbM/HdUJGrwP1CgjKMFeYP9+BrjZV31HfkIOgtXbEKJccBC4ITv7iL/5isU9Yz7OelHdy2CS5JyO7chJU46T2FNPBKGKbKi9S5RRzHl23FRrN6A3OHcnR5zJK4feJUr2riASGaCcHF8ERx6qUX2obyVdnd8gBxb6agCHL97rxt8uN7efzTGqbSt/odPPoHHfkCcT6andaBU/jhEeEpWigBMA5j9AeYR/kPfHk9dL1dAhl4oljFvtP0i1ROoDQ5SIZcp7U4aoag/b39xfPpzmS7e5y0m/nVTrOg4BJqqvatXKaOPUcCb1xztOxftVzyXarbMLTTA984AOvNgsTTXSqaGUHwbSn5+RIk8AqoZKr0qp5jwU6ycByY7f3rP+nMUMiSE3PJvIJnMa4Owj8ugyk7e3tBdhJwJXGJFdwOcESVBJguSNBe7lbu7RaIseAAJI7FriyRtDAA+NoBBHM6r8Dz57BLkorLs5fD7D4aoqDpWSEq1wB2gqAJQeKp3MQUwHnihxESOaV/pISv86T88fnVKYcBHp7g3SWDg/KLQEmArfW2tKp6srH24IgdTabLVbzufeZjotkgLd2aTVURjXPFZD+7+3tHdF/vUnE81Sde2NXAnaVc6BHjDZxMFStPrN8H4/4n8CS9UsOSJdvpX/sl2nc9f/uYEtAimnptEjyVB2HAJE/Qxk5CKaut3a3PvGNCJJPoqou1fyiMvwgX/9N3ni90pcUeULnAJ0vlDF5l4wEUJWf9IWHFI6Z16sxWY4M1s2j4XzOZURDemMDdd/nHjphqWc8NNUdBH7mgO7Jye4HZ7osXRc4V1E+/ptt54ftqo4+Jp8kuWNjKG2VjnbWGBvrWqbHPe5xo2X9H//jf7zM3Ex0LZHPZ1eLh9NCKzsIpj09V4aulgf3cjkqhmho8jouOcDnNf52oz09V/Hv30OfCjC2lvdbj60nfw+Bgl59VjE6LufA6+3k98hLAgBj8/brq9QngbVVqNKzSg8rh06vD1W6zzYcqrcb07y2qrz8eQdWXJnm716e61DlcFq1nDE64+3YG2NSGud3rEN3qA69fpPqxHap0pw0MWqiJ7N1eLmc8y31fNX5tQqB9/GmcvYoj55MUmSLrrujhmXymXQtOYy8vIoq5yLHmmp88PFolfGjx5PXiWPmWLoaNt0QXYs8HYe+/Mu//GqzMNFE9wha6zWH056ekyFO4GPSrjOQr2KQVIa/8vGwcH2LN65UVCsxPTDB1Z/KMFqFuB/aT3vXaogfRjibzZZOZ+85B1hXvr7OycODk3Gr1RGFnA4ZOL6Szn25blylKAHlxdVvX9VyfeDvZOwmsOPySDrkefMeT8v3k/O9LuKJbeEyT2VIfpSFrtOY7clDq1K9bRIuh9ba0iGYDrbYH9iGSpuMaF8t9LaogIXzyy0v0gsPu5X+iC5evHufr9oqbcdwfVQEgeqjfBUenMLRWZ63sa5VziLJiGkSuHLj30FUogTiK5Ju9VZSW7v0KkfWj3wmgJ76KOvt6fi/p9usG8czH5u8rxFkKn2PHIi6E8T7os5uoLycpwqsjqFVnDDV3Jb0TfrNrRSeR5oLXdYVz1wt91Vztgl1MTkI9E0+eCaC143y8jmKY5nbDa6r/O3fHi2g63zdIbfoVZEYLsOhcZtzbTX/pchKRhOMGSPWtXnIS5XvkO6fdofB93zP91xtFiaa6B5BazkIRNOenuPTqgB+zOA9lK66T9AoY0V7Pj08vMqTAKUybJIR5cBmaGtEMmR9BUOGjUKx6SQQMPNvOQgERN3oVz2VljKjgSJDYjabLQH+BKL13MWLF9v+/v7i1VUpjNLlyfq2din8NoWw6reHyaselbyVVw/Qu9wTpbozH+oXQ9Y3NzcXh/GxbdxJ4KGs/F0dWMh2pEwqcpk66OL5C/x2fnRtZ2fniGONeTsw9+0DvMc2TO2vPuVhz/z23yqntda2traWQLtkrjqrTLUbgTv7s4drazsBdZ6hy2p31xnPX5S2N9ApQH7Yj3x8c11N/0nuHHXdIFHHCc5SGsnUV0wFflq7pHepH/MZB++ezsfv+fzSQXnUTT9Xxcd1hpjrP7dh0YlXOWt8HHee3XGhsZv6487W1I69Pu+OIY6ZiXoRFRWwl357O6RxkpE1vO4AnwCae/hVHvlIekingQN+9iX1I8md/HErkefn7elgf8gxIN3n/OvbCDSm+OuBSdU42HMk+FhJOeiaHKR+1hEPMqycAJyL/FqiNG6MyT896+lOu7NgoolICXtcDR5OC41yEEx7esZTMgCOkxeNJx/4E8jq8eETjgMNTqC8xm9Rz0jS8/6/mvC4EtVaXrEZ6lQXLy6/dUGTdIoc4Eo090zToZAAKMmBtU/6s9mlE+Z56rKf8C/eZczs7e0tDBwa3+lsAYIdN+LcAHPHANvHV6eTrrH9CRJaa0vGbXIAJLkNORuUVvvt6SBIB8Rx4PdIANbTIxgSQKFDhPJPlMARDy2sVp7TqhKB/Gx2ybGUABRBlv47+KccyUtalXfAxPrxudlsdmQvMPlXP/RV4MTLxsZG29vba/v7++3g4KDt7+8fWVWVYyDxxjGFOuEGNvsR82Kf8nZJMhwa83iOyJBBT2CWzmxQft7mDr5ms0vnNiTHgD/nMqRMOC6oLTkWed4O6pg3xzbXPzpo9D/xxrS9+c2Br+TjoJHg1+fFyulTXSP56nclE4+Ioc6yju6QZ/7JWazrfpiuyvNxJ/HPfqY0HmUnXaPzITkleKgu+7I7B7xNGfGQnCG6RvBPZ4KiBrz9k5Mote0Ym436mOYEjxLg/EznPZ1bqT9W48dYHlM/ogx6+VTlnyZgI/rLf/kvl316d3e3PfKRj2z/4B/8g/ac5zznKnA30UTXNo1yEEx7elanMd5XX8m9EmX2nq2urToxDEVFXO6JxoGWG2I+aft1GpG9ydrrJEOFBpPuufMjAWQaXj2DPtXXQVQCyckQF59p1ZW/q3SJhpwDPXKnBtvKV7hSWWOAivPkwLFyCvV4dkBAY796Xagb47wmY5wGo4MQ8u7tlQzEHnndk/MgOU4cVLozoXLU8LocZHwlmd6Q0DNqqY/kpRrLXF7sr0w3RFW90rUKfPKag8AqP+qy3/exP+liJcdq3nCZsp+4Lo6RhY+rY8n7o8su6WaKoOnR0Nw51LZ+3ccEkUdOsM/49Yofz9d1urWjb33htVQ3LzPxkpyZXgcfS6u5NTl8Ur2S/vq9FAnk2/qov06p740hdwZ4Pr6gwm/9TnxdCSB+UjbntU7f/d3f3V7+8pe3L/zCL2xPeMIT2nw+b//hP/yH9q//9b9u//Af/sP2/ve/v33zN39zO3/+fHve8553tdmd6DJTNV9daR5OC41yEEx7elandQyg6vpYkFoZlPy/inKepgnEQyMrJ0ByFgwBUQK0BFJaOxriPZvNFic/6xrD3B3McEXEtxK4cZYMX+drjNHjTgLmM9ZYTqutQ5TAJ39rRWvIGbBKOa0dNTjTyp9+ex5usFft4Gl9xU4GO3WU6VI56XqqU3LwOFDsgdBUD2+D6lnlL6eGVrjT6iflJlkoUkTp2f4EHyzLy+fKa3K+JmeK61aSf3JMJX3xfH1scXkOgYJqrCYg5kn1ohTCnAAZvxkNIjnxfwXeerxy3OrVZazRluavSn9Vrr9dZowuJ0ryc969j3l/S/qSVqETYK8cDkN8+nWPBPN5s7XsrOR/5kmHAXWSPPsz4sP7Jvtta8vbDpRezkQ60znu9La9VG28qnOgZ0dVZaQxYuiZXvnr0Lr236rPXUv0zne+s916663tm77pm5auv/71r29ve9vb2s/8zM+0v/bX/lr7gR/4gclBMNFERsc6g2Cio3RSoLoHOioDZ4xX+DiTy0nkmyaaFPaY8nYjzyd+hiVvbGwc2b/urzLUZzabLZ5xcMqQSJbjKxb6eNgjwzdZPg2eixcvLsKr+d541p/tn6IDKMMUmprawI1bhuEOAX/Vh0Yjrw0ZFKwT85GM1HZpb6zLwwFgRS4LGsv+fAKRKXoirVRSp8bIjEa0645/E3T4dwIo3r4sU/yzvsxD/CbnkYNbOgak365H0nW2+8WLF9vu7u6i7T3SRuUxMiGt+gswkEcP33e99PGkAvAO8FO9vY1dF+mgdLm4/lRgguOe+Nje3j4C7vld5c+xi3Llu9w9P+bjEU7JYcMyXcZev/S6vETJoeDt4tfkKKgA+ypjRmv9+crTJwcCf7tuatzg3KB7BMTOd3Ie8LV7rK/qwDGXWwx8G1zSWeqL0rmjwLegcFXfz0UQf9xiwK1MvCdnOg8f5BlAzlvST5a5jk3EZ9wWUV9n+1Jm3r+9/DFgvDfH9p5P8xv5Wcf5cS3TW9/61vaqV73qyPUv+IIvaC960Ytaa6190Rd9UXvpS196pVmbaKJrnlZ2ENzb9/SkFcHW+l7ooTTrhriNMXCc36FyOMF5OV62AwWv59h6JcNy6PkECgXGeb7A1tZW29nZWXIG0Njh2QR+AB5XdysQR+MlfTY2Ntq5c+eOGGEeVn1wcLBk6LTWjoBjyicB1dlstijT26AyCBwo+J5vb1/eowzZLskI8ftsBz8XQu3QiyRI/LlOep0lHweGrIvzKvJ3XLth6TzxHALyofpwlU0ARnnLMHY9dccB68EVexrjLD/VmwY/9VrlC7TTSeAAWnqrvcGSM+WQZK8DULe3t9uZM2fa9vb2kvzn87sPmeN/8ijexAedc+TNxwoHUw7+k8OAIIl939uXDkGWy7elOFAmb94mPsbqvviSg0CAyvdcV+DIZUlgpTJ83KjG4gq0ik9/mwXr784e5ul1TuOWy8MBrMrXh8C1B/4T0PeyKUPnMTljmC/Tca+/9zmeL0Ge0/jnDk/d821r7Nt+Rs9sNlva3iOZJIf5fD5fzFsijx7g3Mi5kn3VdVG/U6QAn08HEboThfVwufB+da0XAeM67ONr6rspr8r+4b00PlTEedD7f88BkGRxGp0CpPvf//7tLW95S/u2b/u2petvectb2v3vf//WWmt33HFHu/76668GexNdYfKx4WrxcFpoZQfBtKfn+EQjZGilVrTqQJ1WVHTdvfbJAO2BpctJPoGlCbh6jka4A04CdObtIZbVac5uDPphSjRwaACJfwJGPSdj3g92YhrlwQnejVfn1Y1IJweMNOAJXnvkAMqvV4a/pxNQpHMnvWYyGUdjDCY3vmigE6QRpFdgR6QTqtl3aJTRmKaBpmv+akN3JHi9/NtXxli+8uR9T+PySvrtbcRVxZ5sCegZ+UCZ+ZjD6B0atr4q7nVy+eu/Tg9nv/S0LleXi+uc2o79K4E/5uXg0Z2OiXycS+MzeVc/8VX+1PYpAqa3ouvjSNI10lhwkZwEzJ/5JarAmrcZ5w590oGL1VzJ8lyWvK7+6GOJj9VVv2zt6Js93DGcojhSX1b+1EHnmc+rnOQEkJOP/ZLjAO0XHzdUVpq76SxgBIvPpQT9KdJF86bGHbaFy2AsuO5RD8hX6UgVOPH+5fdWARRDfXTo2dPuEHD6ru/6rvbN3/zN7Vd/9VfbE57whDabzdq73/3u9su//Mvtda97XWuttbe//e3t8z7v864ypxNNdO3Ryg6CaU/P6aXjeK6u5uQxFIlAY8mNT64Kep667sbY2Hpywq8MOBKNJQcvx6EqhDbxmyg5jVgPtT1B9BCNAe0JhPmzDsBXLTOB/QTAvM7Vs1V55D9FPHjZvfoksON8VzQmYseN+fRMBYp4P4XLVnn00vX0gfrnn1SfxJ9+J4DsAKLirVdWRc57IteHMfmPSccyvX7VuHMSY9FJkvPsbZWcPlU+VX/U/0pH3BnA55O8Ul9K0QjeJxT55cBe5XErQqpDKmvdtqzmUy+70mteG4oSqRx//LgTIX2G6KTtl1XzGhqXT8I5MNFRet7zntduuumm9k//6T9tP/uzP9vm83n7tE/7tPaOd7yjPelJT2qttcVWg4kmmmiZVnYQ3Nv39HgY3xiD3NP4qoKvYKTJrJrgEphiGUNbDNzY4cfBbDKm/X+1YuJlOY+rGMf+37cIMGTZwydZXhXeXkV1SBbVXkqudDA0WSG8e3t7i3ozrFf1rhwhXAWrjCIPRXVAlgAaZe4recqPK0YK1/Wwd+bhZbj8mNa3ESS59wxH1WEM+UpWAgGUC4l9yMPR+bzayMPRaVDP53eHzqYoIuZDoMJ+2OPT25bPMg37oeSSjG+GBHvoufT38PBwKVzYy/G8nD+GVae6UM+od2kFXrIUf7PZ3a+K5Pgl2bINKQfy569O7K0Ak29vx+TsSJEj7Ofevqk9KyCpwx6rPeDV4W+98Te1ndc56RopAXxGiYg8isnnJOpVkjnLdsDtzgUfD5I8mD/7K1erdc959mu+Qt5aW4wHGlv9YNvW2qJNvX49W0Fp0sG8QzSbXdpqQP31V9pubW3FsUnyYL9iv/NtD74lSuOkxhnKk1tG/JyCnv7x2jrOgqFnh/JM+lTxWdkfyQbz51ynx9a1crxVjqDTQk9+8pPbk5/85KvNxkTXAFXz9pXm4bTQyg6CaU/PatQbzEVjvP4pnzGDNldFxnixNal7ubzmxm5r7QhgckMm8cUyHRxXIbgkgozNzc22s7PTNjc32+7u7uIMAhpFOvxJz8jAUVqeU0Dee2GP+j44OGittYWRJ+ArQ3I+ny/SKO9k5DHM3Z03DAX3NvPfLmMv02UomTv4ER9bW1tLYJK8JidXRaoHZU4HgQNjr1eST6oLy6vAi1/3V5AlMFc5M2hIeTg+t47QIE4GmdqBPDCE3MGj6yr1z0Fl6supvSvwqPxktB8cHBzZGuPjAPsO+akcKSzbHQceDi1wkNrbedLZCOqXypcrnORd/+mMSCCEbSCSvnjYNtuJeuV66eHmSa9dn8mz+hVBGA92E/ByeVXUAxwV0PG5wXWIZfvc0lpbandfQfZxim2S5Kw8tfVEste5HWmfv4N/lwN1NfXLamWcDhF3jnDeoPN6Npu1nZ2dpfNlfJ4m8bqfu5OIvHPskYOAcuQ2PcrBHYyev/J2hxudAN7WPHiQ8tKY03tjgcqt7C/pUUXejr00Ke/qOnl0R1fKN41v7jisyvN6JEdZRW5/nGYHwcWLF9sf//Eft4985CNH2vNzP/dzrxJXE0107dPKDoJpT894csNKdK0OtlVkQzXxE2w7VZOWe7gTaFH5fgqz5yNi9IAOJuRBd60dBV0CH3rWnQnioQJO7iCg0eeRCPP5fAGolBcNpgoIuIPA5cN7bmymZ92Y9TZh2zB/toMMKzdiXF+qVQfyJ6BWrSIzLzdCyfuQM8rLdZm4nBwoEui4oZyMKN1Lsvc90CkigXqq/4n8OsFWT/6pD7osqE8OtqT3Oj8jOVaYt0CNr6Y7IGlt+TwMT+eg2x0E7KMe9cDIlyQ/j/bQNT1Dx05Pvq0trzIrj9QG/O9tw/xdv3ugQLpJubMt1W6pvV0mzHOob1VzQyVvf9b1zPsDxy4fn32V2svnPY5v3q7Um+qNARz/vN7pXupTvmrO82rUZn5Yru4rHwLqam6QLNjPKt69jTjGUe7+lhrx6/x4u3i/l0w8EoDy0rkCdBBIf9lGXvekA/zPa8ehoX5BSvqQ+nXv+Z7jIPGTnklzxlhZXKt2a49+8zd/sz3rWc9qH/jAB47ITPPCRBNNlGllB8G0p2c1WmUAvly0ygpva/VK0EnRKvmlSTiBJwcSBJxuWLvxnYyXRG7suXGb+ExAkRETPbDu5Yp6oazrtpfLuVrdTPytU5YDQ11XOaRkDK1qmI1t13Q9tVHFe6pXVd6QLF1fx8h8jFwSqK6eHxttMAQEe/fY7q6HSc5D4NxBiL7pdExtncYU5y8Z9mPqPFZf16EKLPRkVen85aBKNs5DGtd5PelGrz16dVt1/Ep9ZOzY6H1G3z6HeMRX4ncdB84q44fPjV5mykfjeZrPxlIaW3g9yYoyI61q75wU9ca2MXScefVq25jXKn3TN31Te/zjH99+6Zd+qT3kIQ+Z5HQvp8oxeqV5OC20soOgtWlPz1g6qcHoJBRqaHsB0/EU8NaWV3Dk9Sf4HZqQK/6HDJsKcOt3a21x5gCjBvzMAaUn4KUjIQHWBKJ8tYbX+eyYfZ5Ve7hTg2mrLQMJ7PRAZ1XH9JttrN+Jx9nsUsi0l61w2eTE4TXnMRmjyaCudK8Cri4D1ataze+tAnNrTG+Pbyrb6+Tpex9/3sthm/X6vhvZ+s+wdIaqa3zgGODt29ry2RWUaQLdzh/lynB7yjbp+Gy2fG5Aa8t9JwFMhnS7Pio9w5nTdgTKrgceVSb5TmMnHRFMWzlnWE+/z2vc2pPGtHXnmd5Yx7LZT9LqMn/7GFUB5NSPfb6qPt7e1FEfY1if1P+oW8l57FEDXAH3VUxFuxweHi7xxX5G/qs5mLLz7QtpTPNoNtfbyqnrz/gbXqp2S23N7R6UlUdfKI3z73RcG8x1tWfLeN2qOW0dHn0cSLJNc8hQGavI5zQBG9F/+k//qf3Lf/kv2yMf+cirzcpEE506WstBMO3puZvGenyHJpfjludG1Dp5aBJUqKCuce+jytjYuHtPr+/P9QmRvDmtsuLgxiEjBLa3t9vOzk7b3d1dbC/gwYTiwZ0G/kpEgrvkBEiGOY08B0u9cGY+R2BVyaICAbrWW3lK8vO2Sc4BN7bYzysnRvWsG6ZqIw8ZZ/2rrRcJCHka5y0BrfTf+Um8KD11ggZ8Sks+KiOe8nXQQgcUr3n+5CXdd91WOj8jQd8HBwdtb29vcdaA6izDXX1wNpst7etvrR0B6nJUzOfzxRjjjhH2Az1fAWWmZxv56zEZjqxxgYBfEQU6fM2BkPoXw/IdoOl65TRg/Xhuh+67o4vbGBhi7vJieyQAzD7J17xubm4utYW+HYAlSuNUSu/AXTz4GRmsm29DceeC2oqgWG1EPigDP5CR4J18aoziVhTvG5VzgO0p6jndFFLv7Z/mCD/IdWtr68jhhj73JqDIrXTcAsf0PneJL3cqsG30W3z0nJHubPBXdEo+7kyhI4WyHCLXo3WdBRxTk6ODbxBie0gurLePGT3y+y5z8jAmP6eevXFcx8q1Qk984hPbH//xH08Ogolaa1MEwaq0soNg2tOzGvW8uNVArAk0GWuVkeKAphdy3nM0aFLWpKhVeRpkKoOG2BhvdaLK8HeicajyFT2wu7vbzp07twAA6ZCvtIrN635oWTLEaWB6iCPBr9chOR0EwGS0E1xVRmh6hzfv63fVFpSHG9O6x/rQ8EhOBDdYCJrYTnTE8LwIB3OpzVz/ZSQmUO76444b1c8NKnca+Wp4MsCS3hMQJ+CedD3JVvzynAMeUMbxgfInnzSiK4AteVQA8+DgoN15553trrvuWuwHplOAbcczPwjUGUmgMwsc7FLnKocZHQz6qM8omsGdTqyf3rYgvRMffpaEO2II6Ng23q7sA14/AgU+6+OMxl2+QcTrnvTQ9SjxIPloHGU/8sPemG81P3n5VR/hM/rowEi/5w4hH1+9r7A/ON9pnGY9ybM7v+l4YP5p3EwOgtQW1EPqE9tddVTa8+fPt+3t7aW+pT4iviXL1N7UVzoIOPaSZ/Zp8uV9wp03ep6yplOT7dzLT3X2tnIHAds36aSP217H6n+iMfcpax9zWc/k/GIZVd/xOugZtkFlh6X0zr9fr2zD00j/8//8P7cXvehF7cMf/nD7jM/4jKWDN1tr7a/9tb92lTibaKJrn1Z2EEx7ei4vVfI8jpzTRJiu0THQmxAqwLgKrVMfN+Jl9PorCtNKnk/YBDpuKCb+3ADUdzKCSQRyNP65gkc+kiyTUeTg3Q2f1L4JRI+l6rmKX3cW0EhysJycA0mWqYwEmkjJSE3yai1vO+Ezqf6prCHD1fMkDw5EEpDqGX4JqLIeTgnI6L9W9A4PD9vBwcGCt52dnSXDPjkEuPLJ/Ch7v6ZVYpd9kpnqVYFQL0MOFp5Oz3Dtqh8T8LBM8pzGG6ceaOH1BDRdx6kjCdh7fUQ8bFS801FQOR+H5qRq3OLzaSzy/p7yTteGgF2ShTuXnH93vnFMqJwEol4Eg/67o8IXUrwMPkfQScco+3aan1x2HiHgz3n/GZrbvA1V9ti5JY3zqq/kpGtyEDgNjctpnE1zwKq8e5kJZHMuqfp/ojH21FCaqv/0nhu6fxrpq77qq1prrX3913/94hrbf1rQnGiimlZ2EEx7ei4frTpBXU5ykJEm1hRytwpVRqmIoXpuTHLl3ydj5i/ic1V6rz/lwN802LSaw20NrBMNUxo/brRIlgobdZCS+OsZKLw2ZOAzHQ1iz7cytlK+lXyTUei65XrnRL1I4K7nLEg8J7CS/rvTIxnH/pEujO0rVZ76zXRD/YdUyVL3fD+0RxY4b85nkovf50omHQOV4c+2dNmlyJNKF5M+JhBGkMaIDZfdKkZ0Gj+dP9aX+ZOf5CTwvKr/Q6BAH507s26f8mf8t1+rxptq3Esy8PvVPZ9HnJ/qmvM41PbVGJC2NyQZuxz0vCIFfBzyiBS2J+dIB6t6zl/ry3Irx2JvHPN+kuZOv5b6F/tAb+waGlPHtNcq4H2I0rh8OUB3NZdNtEzvf//7rzYLE11D1BtLriQPp4VWdhBMe3ouUW9wHmO895738OGhfJIBncofM6FoIvfDyJhHMlSr8tzIZTnitXreV+i0yru7u7s4f2B7e3vJEOIqC5+jIeyhzB5uyW/nWRMzw8DpqOAKkRuICqPkVg7KmUaer7S7fHp8+spQtSJL2eiav25QdeaqMQFeCsnnqwvT6wvJZ1qpr/RFZSQwl0CrP0fdYGQH5eB6kZwdCQyLF+Xr71LnPv6qH7LM9Oow1itRr5+l8FfxfHBwsPQKsfl83vb395fOJKFzjf3Mrzk4YRpFCXCMUXRCD/CxLIZYS87eh0VDujebzRbnCxwcHCxedyq5cE+0y7JaIaSO6pp0lPJ0YO0r0R7xkPhPIKsHxEiU2fb29pLjrQK0Y8Faz3EjPeDWNa7ak/9UDzqUEiDv8cRyOCawDTj2ViCffCY+vO/ylX2+1cH55Fgm3VS/ZIg0z9QgL5yb+Ppf3+aVIro4PlEODkg5l3p7Jb1MaZI8JTPNiWxvHzfHOAeGxsp0X/rp4wnnjGSXpfF5yBni6YYo1b83L7DdKn5T+nsK3XDDDVebhYkmOrW0soPg3r6nZ0w46UnT0ESYjAsBulVDqDQxatVCho6HNnLSTzJx0C+DgqtFFXDlpOpRABsbd+/zl4NAhxO6g8ABg0cOpPMIvGwaNTROVYczZ84swq3T4WM8ZIny9IOY+JyHuCtE22XkRCPBjZAUis3fnpb5eYir2pD/CQL98Me0euUGJ/NjfbxOXn+1D/U9OQpIbH+/5jJyoEvZJKPMQY2vIiUDm0R5qu+mlfxeOHjPQcDn2ZYXLlxoe3t77fz58+2uu+5acmYxBF2f9EYKnv9Bx5BvGWjtEhilY4J6Rl4F/iUftq87ChLIYfkCaGxvgo/9/f2lMcfbOY1fyVHk7UEA52eNcJz0tnNeWEdd8/HJ8/K2J3l/VX7+bnqBW5FHw7DveP92njnO6VBAB5lq9wTAE6DsOQmcF+kT+yIBoe4pmkLfcu5wvKmAMEEwD4H0sx4cjBPIUcckf/IkR5b6HnVZ8+H29vZS3+SYvL29fWT+5XjKj8/vbm+wjTjfJVm4s5xjDNuSzrmkt4noaPL5PFGaUxhZkcodchL0eEu6uYqTIc0XQ/9dl3xOZXvfk+l973tf++AHP9gODg6Wrn/pl37pVeJooomufVrZQTDt6cnUWwW/GnRcT3AyzDip+IoPdcBXFplfmqR6xrUb1jKKtre3F683TI6B2Wy2BK7JD4GDG2jOg8tC/5U3nRMyghyo+IqJA77WLhnE7hwQoFHdVQ/yQ351j/2wmvyT4eD5pRUy/qdB5kDOIzp0j2krXXBAXfEmg40g0Plxo8yjAvTbX89FXnnAmwzY5IhI7ev9pgJXpI2NjaUT+L29em1WycvlSfmcP3++HRwctP39/aWIFt13wEA5puiBdF19TqBJclIEQdXGrjPUr6H6uzMkrZbqGZ4Kz0gQL0uyd71imczff1dOBecnOYIS76kcv9bacrROtUrqfcdD252HHrhI/cPl5M7DKipC/Lssk5ydNx9XKycPeaQTuJKVl98DxNR5Pse5lN8cM9h+3g+1XYfzq6IFdnZ2jvRHyZ2O26RL1MGqfdl2rA/bwa+n6AEv0+dKlpd0iLrh7eLpU5ohoO33kpOgGgsqnoaujaHKDhhLPicc12a8Fum//Jf/0r7iK76i/d7v/V4cw+6teOXeSt5XrxYPp4VWdhBMe3ruXZSMMU6KaZJyB8JJkYMTGkv+Ufoqn3XL1zcBzxANGfC6zm83DIf4vtyDzliZ9oytsbJat30SAE7Oi6QnCSToO0UlpPp6G3hfYZ+pAE2qU1W/IVn476RPvrLldXCZrNs2fN4NbF0TOFon3zQWudFeAXNvQ4I8B4deViKOf2xvB9ZOQ2NCejalPw65nHycTWmrPI7Lz3HqlsYBvz4mj5OoQ9W3CJrpaKUOJlkyT+8/dAik8S31r2rsHtMXe4C3clQNPX9ayZ0UbN/W7ll1PS30rd/6re3GG29sv/Irv9Ie8YhHtHe/+93tz/7sz9qLXvSi9k/+yT+52uxNNNE1TSs7CKY9PZl8heFqRRKQj3V5kGFCL74b9JXnX4YJy5bB4qGpbuz6ihmBuFY8dnZ22tbW1uLD0ElfqXSjXmUkIEijzA11vr+bEQP+zmiFRSqclO9b97MHPJzaVyS4guzAIq3IMy/xTMPM5Zq+EyUw5wang4jeqhPlnNrAwfOQQV+tylMXVA99J+cSV9PcOcBICAcaLuMKcLOvsE1dD8SD731nGn6Tl1ROay2uXqpu+/v7i33Os9lssSLpK4x8rgK3HDcSuPC6SLbqU5QLXyuYdNzLYBqPbvIyKTOOL+qne3t7Sw4C5uvjhYM18qdrPiZLptWKuPc31sPHUNcf5lcBPo4xjJJguWob6mly+vZAD+cJyiUBpt7KclXPVH5yYnj7cEvDGGLajY2NpTMvWBdui6hWx71ctZPrs9Kntx34GKNzcEQ6X4DtV/Vb32rlUT/kUb/Jm+rCeY3zKGXi1zlP8lnyQh1K/PfacMjBQ1tmjOMo6SJJ+pBk1IuM8fx718by2at7b26+p9G73vWu9m/+zb9pf+Wv/JWFTn3O53xOe+UrX9m+5Vu+pb3nPe+52ixONNE1Sys7CET35j09KfSztXricAOlot79sZOY8+HPrDIZCqjM5/MjrytzI9WNTZav+ym8MxnwNLr0nMImz549uzh7QM4Bf0+0r5ZwNU/lJrkkw9TzkTHmBowcA3rfOp0BAvr+Dmw3JFSGZDabzZbCy1U2DUI3Kt0g9FWMnrMkkYNsdwzwk84b8DzEJ+tO8ORGIZ9prS2A3BDPs9lsaZ+u33PHgOtOSkuD0j8J3KQwVAJEthnbwV/vRfJyvb84L653HrarNGojbstRn1Le1avZyCv7SwUmqQ9bW1tHANN8Pm933XXXwimnZ1gm+4i3FYEJ83Q9FG1tbS2eOzw8bPv7+4t71B93FPmYQTlJDtpj77zq23l0AElnAnWlcgJT5r2+nfqo8mOfmM/nizbSVhAHxeSDPBL8OlhknfV8AteVY4D/fdyrSDJzPWY+TmkM8rLEq585o3mBaVLdKSfxSX3lliW+rlO6rK127uSsxjKWmZwCaQz3tqQsxJeD4eQw4fkWmiv5rMY0nunDMocAfeWcdKocJikd2z/1Tf5WGp475IsFPX3zMnvXEnnebL9VaN3nrjW6cOFCu8997tNaa+2BD3xg+3/+n/+nfeqnfmq74YYb2h/+4R9eZe4mutJUOeeuNA+nhVZ2EEx7eu4mN8yHBnCmWQXsex4iPk/P9Tr5JkqrjwKsbnhoUnQHgCZ7pk1RAj7Jsn56Ricx8+0FMmrkIEin6dPQdWM6ycqNH/Iwn8+PRCtw8mcEQTqQicaC88PVV+eHsknGm0cLkF9vH+ZHMEDZO1XGZnIS+OqT5+FGMu+ldujpdO+ejEyeHZDS0CAWIK7ABmUkWboRXAEAr4/3AZbrq2mUFfOpZOLOCumjDgSUU5f6xMPq9F8OA5XHMxGctwSAnFzfCHDYnwhGE5hmX1E+bCsHbi5n7+Oqs/qnIipaO+oU2NraWqpr0j86MVprSwfxOR+JX9cVgo7Wlh2VyfHn+ab28D7N9H6d47o7n8Sn18fLTuCffCW9rfSfVM2JCdhxDO3paaLenNDapT7L8T19lDbVg85h1oP80uGkPDQvSieG3pJA4jipNHSIOyD3fk750kGQ9ITfdBC4U4VjA/u5y6tn63h/SI6F3pw3RFX5lI07CFK787lencYA9qRTaQ4b+3wal04bffqnf3r7P//P/7M94hGPaE984hPbq1/96ra9vd3e8IY3tEc84hFXm72JJrqmaeUNn9rT89/+239r586da+9973vbr//6r7fHP/7x7dd+7dcuA4v3TFploF83zUlRMubS/aGVXaexzgwC0qGT8avPmPKqSdDzSiC4MgirD43gnlxT+sT3GOqtxlWUnAIVuEhAfywN6VDPsOrxMqQTKb1HE1RAKvE2xpDqgYeUxzp93Z1PvtXFo1xEHhGSHEFVncby6iCLTgq+LcLTezlVWf78EDjmbweq3k97xnLPoK74TnkNXaucUImO0y/HrC6PzTeNYUkOvfFtlX5Q8bbu+NQrR1TpSOKbzsQe+RyQ8mN/ZZ+t2ij99+ip3io865UcAIl/H4+oy0O6O9Sf16FVbA/RKk4lb/8h2+mkaZVxeOz100jf+Z3fuWi3W2+9tX3gAx9oT3nKU9ov//Ivtx/4gR+4ytxNdKVpVTv9cn1OC60cQTDt6TlKYwbUVTy51fNDinU5BnYaAa21xYqiQh058YnHHpgjr3qG92kQXLx4cWkls3p1XjJgXSYpcsEdB3re92ozv/S6Ow+PTf/9usujMppdXnqexp8DPPLmxlnVJqnd2EaUYwXweN3z1f9q1WXI0Ob9qi2T04Zp/HdyBIyhXltV/bTqFw5Oe6/8q9qTusaVqp6+qWwHgPr4GygYuiv5p0gR8lm1n/PgkT9cIadOpbd/+H/vD8rD9dh1lbL3tpRcxYM/79E5aSz0NmM/5Upt1cZsQ69jT75V33M5+Njr6cUz9YBypa65o6SKCiCldkk8slz/7fWufq9qoFX5p2gav1/1+Z4TTJT6JPsl9UYy7o1hYyO+Ur/2cdz7NyOpfLsBV9TZbiqbb0zxsd3HoEpWPerNOUN2VdV+SRasH8cTH7eG5qWxvFQ6Th5THmPLPE1ApqKnP/3pi9+PeMQj2vve977253/+5+0v/+W/fI9yhEw00eWglR0E056e1WlV58CQZ9cH7h4ATGBqFdKEIsOYBjInfoZH0oDs8eThvm5gb25uLl5nqK0F2m/podDuNGBZCbB6GKWeEV9eDwLQM2fOLMKtfY+hby3w0Et/RzRJ8nOQ64agv3qMAMvBYHIeMG+1qRvj5EkfOWh4CBa/U/40INP+b6Wj08PBUGtH30vNOvtrLlk268HnkkOpt2rmefK7t3Lm10jumKiAvSjpjXRAesioAH7TaBdx5ZFna+ib4F6yUT7ip5KRgwOV546FBJYuXrzYdnZ2lup78eLFxfvg3eB24OAOIKVJTiTVSfm7ka+P+rWcF7u7u0tlUYf527dk6RltY0jAnOOqO0bY3i7HHrnOpOd6ebCfsV3UX+lEYZtpywb12vsQefHtQGxjd/RUoEv/K8dANTYkUFWBLD+AtufQcXCdZM028XYlmHZnuQB20gd3tEt3ebCvPtvb20d497HUxzp3/LC91Z84L/o2AtWJc623g+Y317uezVORO8NSW1S/NQ9TNkn/ND9z6wT5rYA7dZtlJnkk501FHDP8msskPXtPpPvf//5Xm4WJJjoVtLKD4N6+p0eTbTprIQ3eIgfqFfXyWIUIbseWzXTutVd9degSwQ0nP3cScOJMAMz3U6psGYtyCuzs7LSdnZ22vb29MJDcQcBnfaKno8MBhBtmPoHSuBIl48eNRl9VSQ6CZJzKGHED2oEz61gZ1mOAA/NLq4OttSMGJVd5abx6vgRL4jPxoPq5vooffw89V78q5xANOOpUWqEmH9X/VDcRDV/XZ6ZVP/K3KxB0VPmn1Uo9z/3z7hTwFT09J9kRMGxtbS1krDwJyFhmJRs6OHzF3cnPOZD8BFikCzoLhW93qFZMOTa5s1KOLvb1vb29xRkNzqv4Ojw8XOSlccgdJ2pTd1w4b/qmPBNASs4F54ugugIOFRj2uqo9es95OWyfjY2NJSeLryY74EnjWHIaCyRy7mE+Dsadd5dZ6l/OF8mjNZLjN4FWjvMuS7a/15/6y3HTD+UlcD44ODgyDnNecwcB89ra2mrb29sLPilnjuGsMx1VvE9HW3JaSibiSX2I7cZ+7fYDx7BVnASpb4y1tZJO8LqPeeq7Q+cPeB3T2FD1/eo/dcsdPF5mcg70nplootNOVV++0jycFlrZQfCd3/md7Y477mit3b2n5xnPeEZ7ylOe0h7wgAe0N7/5zSfO4GmjNOlwVa43qfUUZ5VIgKEV/B4l45+Tsox5X6lOk5aX706CagVMsqJRU20xIFDks8yTvPgqZjLAk9FKw4t1TkYiQV4yEocM2bTKwPYnyFNdVEfmW4EAUs8IcMeJy5v/kxyH6uk8eB1ooCbjynmpAJLS+zNp5XqI11S3oXTpd5W2AhUE24nSAWGumxVQcUcB5U6Q6hE1yZB1Q98BmbeTAK74VDlyVHDl0A8jdLm6ziuv2exSBFTqy74KnCJh2PeqMdx1vQe0K+o5rLys5BxIY4fn7TLqEfNKTkvvs36P+jgGkKm9fWxe1aiqxhCOy+S3BwATsY+NAZB6hlTJIjkIvM38NaQOrL1eaeyj89UjhtJ8zn6i9Gnu87EnjUWpnhxjWBfWU7z4/Ez5VosRrEtyco1pmx65g8B1v8fDmHIrHVuVxwnwTzTRRGNoZQfBtKenPyhXMnCjpHq2Z5B4flVZDhpXpd4Em4CuoipoCFXh5IloFPKarw7TodDaUQO3ujfWI5+MXAdDDvz9+fTby6KceoYMyaMHmB8NavJPY282q9+1zeeTzjjY4rVEQzIe6gvedr127uUxdC3VdQyIXwX0r0oJyDu4qZ5zg5Tp3QB354qTt3lqE/3mM36t4pXAr9c3Ez/uqPC8PV/Pp8o//XbwLXI5e9kOaFK+/F0BM6/bSc+xx9XfBELTOQ1pjPd80u/j0pj+7L8TqPcV4kSse2vL+jlGzu6I9f5HB5l49G0d+qSxOvXhISDNOicHC+WS0pF6c3X69vupHyX+h+bUpF89e0eUbLD0XTlkT3quaK1vM0400UQTHYdWdhAkmvb09Af/CgheCW/uKq+d5ASYwiVns1m5otjackSAjAYPnfUyPIScIGB3d7ft7u62nZ2dtru727a2tpZOaq4m+uRQSAaVrov02wGInB/VSfC9VxuqnsmwrHQitUsyNP26t4PkTcOrt/qpezQmFY7NkFbf85+cN1X+vl+X7c1yU4QIw1LTx3UtyXeM0Z70Izk4pBOVETjGKcJ7HopKg1Mhu26Aqy4HBwdH8hBvqjNf0Sd5+ms7RR5qznyGgIUDYdbRV4jZTyT31Fe0/UG8M1+2gRvlKlN6Q5BFXZSuO6mevi1BZwhwPFT+4oMr7kk2FbkTjwAwjct8bgwA97wr6ul+1de4GstIkNZa3D5D+VSgsXIguW65rJ1vAtnWjp4TkMbs6pPGDvYNjzbzedjl531L+sZ+SueY5hrJd3Nzc9Gv1D7UB8+P28Vcrg5wOZ9pDFLdeL6ERwuk0HpGHui/2pjb/7SNk3MW9SzpD3WvN7ZT5tU9Uup3HJv9DCJ/hWMa06t+l/hexwHgjgO3g/z6ccubaKLTQpN+j6cTcRDc24iTRTXYethaz4BJE9I6Azfz84nyuI4ITeDKSx/ySiDhYMCdCSJFG9Co0naCc+fOLZwEPHsgAUry5fkReFA+NBZJDibkGDk4OGiHh4ft8PCwHRwcLL1b3l8bl84f4GpLa8s64vv3RW4g8b7LX4akrklOBHepDdQOWgFj3WVEbm1tLf4TLKnc1A5eH+kP+Rdw5bN0QPir9mjQVkYeHQyelnrr5H0lAQx9tE/Xwc6Qs8DBH8E8DwBkGj/jIjkSqoPgWmtLTh5Rki/1ie1PQ1dpk6zSuMVnyDPHhPPnzy/Kc+cH+dnZ2VnsmfYDQVMbzefzBXDa3t5e1Jf9klsPfPsU5aStF6qr+v/+/v6SLBk9lZyzDhyT4Z4coC47fpNXXU9tkRxjY5wE5I3gmuWJZ8mQbSq5HBwcLPUdlpGochKkPuf652k8AiB9OGarP6XD5ryPDbVHcg5wHHBHK7fUpSi61u52CErWOq9D/Vvf/sYD6qmXkcY3jw7wMaqSj3678zQ5QtSX3Wkj/iubyds3kV/38tlGaS7xcdSvu+7INpB90Dt/wOvCecl1nWmrPu11THVPZXoar/Nx7caJJpro9NLkIDgB8sF2KGxvnUG3mgR5341qPjemzN7EQJBHo6+1ZaOXfNCI7PFBYC8jUwcn6Q0GXOl08Of5pNVmARUaugL+TjzpWWVwBUWrA9VBcDSW3MAeMoZ9Aud/1yu2M+uo+jN6wNMncuNM3+ncB7WXyz7VifWiwUTwRSOJdXBHRLXy5v/9XpKzA48eqQ0dmLtBVf3uycX3qzrI8YMvpXvkx1f2koyoz2zDVHe2tcpg26hvs38kOSYZuV7qubQ6qHLJLx1ZeqOHl6dy6IDUmKA+7xEE1YGpHEuUvyIIWrs0XvgBri6HHlVyZpkcw6gjPrZ5O4zR7ZSmcg6I+J991vsx+U/OgdQHh8YS1/WqH7IOY50DBMbV4bIVAEt6XM1TIqWnnuoNPnSyKE/xqD7PPsFyGSngTgifS71dOab4GEQZaUziWzmSMybJibJitFOSK8cMzm1jnQMpT3cOpPlKZfN60ikfm9PBjGNtME87Zh4ZouRs8OsTTTTRRKTJQXAF6bQPxMnxkNKsSm5QtlYbNwkMej5jyhvDTyI3EFpbXt2rvlchgS8HsRU/lVMo3R8LiFvrr66cFI2Vj0egjDEA1+Gl96zLNQGFdXlIbcbrFbBJ+lhRz5nSM87TtbFgrlfPVe6nfu710fcqupGAXm9MSflXbTFWB7z9es8m8LCOvq8yDoylIadcuraKjMZcG/tsuu9t4EBwDLlOMtqmSt9aPn/A50SmX4UX7/OJ0nw1ZpwZmpsS0ZlR8drLY12dvZxz2Kpj8UQTTXTl6Vrom1e7/FVochCcMPWiB8Z4ay+HR3fViXHIwOcqRmvLq/FahZORw5BbPU+jiI4Ahj3qtYY8d4ArHlzhZj4eNl3xr9+iFJnAFRCPGhjaW5gMP1338FLy5tec99Q25OHChQsLo5ROBuZbbTtwI7UXpi+qjM/0m3mKv7SK5ZEKY5xBzMe/JZsUJp+AeCV7ffcMZOaXQvEJyMUTeePWIF1PrypMYDSBZcrYefH25jOsl/oaI4aGzjapDP1Kf1XP6vm0t5jh0nSq+RYBPs/XQKayhkAV20ykvBhW7H3I86c8UkSFUwWelJfXiXX3Z5hnz3HoThfKknmnSAIf8zkPDAFOXhs7H/YcN86jr3CnLWDOQ4rIShFdvEc56fwM3WN7aosV50Ift7y8NCbzGT3nesh5eTabLVb++WwVJeDzfqqv8+b6VvHNOUu8eb29vGouJw+VjFK6lI/fS3qTogeSHg9R0l89y3qyrVax7ap2GUo/0UQT3TtpchAcg9KkWN0XJUPeyY2QFCree6b6PURjJzE/TEh1TAYqwRCJoetyAuggQn2fO3eubW1tLe1512dra+tIqKRvK5AR4eGhKfTRnQsynrQfVecNHB4eHgFrkosbQ5SDyli1TVpbBmZDTgIPm57NLoVl81nXQ8qS8q1Ws9zIZfh/MgrZTjT8WK5fc8OuMi5T2zk4k+NE72tPxqLL0v9XK0XOl8tfROBN4OJGZmWIHhwcLJ5xPXaAT0CQQp5TOt1TGUynfiwn4MbGxlKY/RAlvSVf3K+c5MR6K422TPAd7u5AIbijQ5P/k15Jlzy82OtEgH3nnXcugTyNbdoTnkCK2o5nIXgZlJeDMwciXudeW7gTi5TmqaRrAsEMoz5z5sxiX3xrbbENxIEvz7Tx/dppziAPzqvznGTIfH37APfWc86inPSb8zHnGdVJ8tB47c/6GMrzMTgWunOA8y7lmfqx6lONC9J/9mHlzXMFuJWh6jPumEv2De0YPqN7ySmi7SiUKdvDdc8p9Wvyk/TG8/H+z7FD9oHsgoODg7a/v3/ENnCe0ryR+OZ/PpecBMmBkJ7v2YarODMmmug0UjWvXGkeTgtNDoI1yVeGxtBJDbxVPul6MsqHwiV7aTRJC2jxWs8ZUoHGra2thREtx8B1113Xtra22tmzZ5cADr95ToA7CZxfkQM7XeM+Txnz8/l8cfCgH0iYVnN91dKNIdXbV3OHiOl6KwbOg9LSMOAedPEjfh2su7HKdnMaAtyqt/KkYejAgdfdOeFGKXlKhrIDm6FVb5cnn6XOJBCTABUNffHjB3JRj/wMC377AYbu5HIHi/oFDcuDg4MoI7VNqr/aR2W2dunEdBrMNFK97YcmZToYtZrqBjHbkI6s1triJHfK1513vNYDExxTzpw5sxRxQHBHB42e39vbW8pDINl11MdCX5F3ch1z8Ko00jO2ZTUeJkdEBSLcweT8uxwd7Cm9nwnDfD29j3uVTFwuvXR0DtBJwJVfgvmqjqmvOIBWOystnQg+/mn+oyOch3BSRoycS+Me68yIPs65rS2fMyBy3Vb5dBCktpSM3FFU2SMcHxWNxLGKusG24ryqMe7w8HCRH+e/5Bzwtk388Z7rU9Iff2sB2831uKenFbEeiR/my3G4GuOqNuGYUjlLJppoonsXTQ6CU0BDoH4M6F+nzNbyqw81kWjSpuGjlROlGyJO3ASlBDi+uungxledq3J7qwM0Iipg4auTlcHs5SSASzmOlVWPnGcRow56qwzii/J0wyqld0PMy0r5E8y40ZIMu/S/SusGoa+4UmdTnZh21XtVfs5nypOGJ/Wu0rPEDw1vXy3stYfzRWMx8V/Vo0eeZy9NVb/Ur7jdwfltrS0ZzfrvefC394GxzjwCI1E69NDTODDn+Mk0yYGQ+HL97jl6KyeBKMnTqQLT5MH7pNen0r/jUq+/+Dju4F5pvK6J/DplwvpyhV2ycaesZEFnYCWL1B85n1TzkO67E426yDFnKKrD82b9Ev8uLwf+qn/SRXe+9yi1S3VvDCW50Fng18ZSAvXJiUEnwFh+h/ruRBNNNFFFk4PgFFBl5A0ZgZejzJROkzlXLESc2Pmf993IqRwC/O2r3BXwStd6hs6QM8D5Jk8eNUCDcAhYjQUhvZVGpanqq1BN8pccPDREfEUn8ewr/TQ0k8NBMknyJB+ULXkcApn67vUbb5shGtM+LDsZezQk/S0EbqhXgN7zZJ+pnCQiRZBwJc1X5lwXUtke0TPGYB/rWBhyiPh1d2SkeovHKq/kJBiTZ+KHddDYeHh4eGTLDMczB9iuAz29741xym8sje0LvecrB4+PkSI6EuTs4Uo2x5KKks6kcYDjYEo75ABwXtIYzwgppvVxTM+zvTk+e/k+P46dSzxaQs8wakn/U+THELj3fpLa2ME9fyfg39ol51pyrGxsbCw5BVOfqmQ3pEtD5OM3f/trHRP17ru+pGd77d5ziFS8TE6Cie5N1LP9ryQPp4UmB8ExKA3mPgEel1bJww1NXqdh4NfGlOnXFF7HVUoa0DSUaBBRZmmvLsMslQ+jCfStPfJpfy8nbzcUU7g277d2dA8mV1ooXxq1NK4kD6e0mlSRh6oO5Us5p3xYLh0DvmJDg80NdP53ZwhDm8mHePO3UbgcqZ/SK67g+gFnzJ/OBdabOujy0LMOrF2erkM0gpnWZZ2cBKobdYv/q4MIRS7f1AZK5wd70rhkWuXjvLsc1FbKk4Zya+3I6+tY7zHjDPtnGlcT8CRwUL0diCk/hUlTT/yb75130JEcOVV91S6Hh4cLHpSnytje3j4CXNhWqRx3lHkd2JfVx+kQ6lFy4CTA4U6LyjniTgrKkvelSxrHGfGUVmJTv6Lc+ZvX0nhOvfe6u24lOdAhwMgPd5KLKie5dISr6OLN+6w7+dLYT/lqjFG5ep5jjmTlebr8XVd5XR93qqd+6uOn0rh+aE6i84RzkM85vOe8eful32m85nXVzcdsjuNKU40zlGEqt6KUptJNOnkomyqvofH2NAGaiSaa6ORochCsSJw8OUn6IJsMhDQQD5FPeGP+s4wEJnppk/HiPLNu+n3hwoWF8asJXe+3p4FKI0mTPPf80gBq7ZKDgGk2NjaWTn4m726YsE4EIRXAm8/ni4MIuZeQshDJ0KFRO5vNFgaZ+JARIyOYDoyUr8vXDR83NJIDw/OjvhIgaj85+ebJ8A6ok+HgDgIRDUd/CwXr6XrJFVeG3+oZ6hLzc+PRV7IoC8mDjguu6JESEKJhm3TO6+cARb8FInmN+sny2LcoWxr+klmKrqn2TpN3N9ypazzvgzyqj1MnKO/khPG0zgPrwnwILhy8sP1UjoMg1xXlTZn5Hn72sZ5jIAGCCxcutIODg8XY6GemaOyYz+dL4wP7WpKTftMxo3ZgH2Cfp+z53x0VlGlF3ifoNHIe2TYE7Bwb5WjS2OhjdpqXOI64Q8DP62C/8739qmsVIUIZeZ057jOty0H9kwfVSj/29vaWxiTywflQusn+7PM8ZUYHAcd4yk375tlPOZakdq6cSQT27oBx50dyGLHMixcvtq2traV+q+c4VvCcHJ+ryaPrf28sIrEd/dBGnT/AcwjobBFP5KdnY/WoSlP10eQkSN9DZU3OgYkmuvfS5CA4BvVAmdNxBlpOLqs+k8oem09KRwNd31rxpTzOnDmztHLhBpOuc2UkbRdw48gjB7SCnybdZFjTeEkGgtL4ikBFycim4ah73CvN55znnk4R0Iw1cHRvNrsUJUDDKq2M0tBP5buRQwDgQIOOIDcsk+xUhoeQJn6YB/lyXUty8nBQl6fSpnKTYUzZ0ch1QOoOAgc33h50qKm9qogAd5zw43yLB/YLfXtdqW8EOcyfbZmM4ETJEHWnkTs1vG2cD11PgLjntHUgy2u6PsY5oP8+bhC8u574h3Ig/16WfzNPr/uYNhnTZizPf4/J1x3ELl863pLTIpXvH8rOr/uY7mPAUH0q/db1FCXR2tG35MjJtrGxsXAQaB4lQFfe7GcVSHf5UIYE5XqODgJub2B5aYx03jhGs/yUJo35/tvtnVSGz7W8lpwD3lap7RIl3eJ4WenVEFVlpusVqO85B8bafN6+Ke3Y8Xyiia51quzIK83DaaH+huaJ7hF0pQb3Clw6WEtGjk/oNKbcQPKJv1r58Uk9TYYylHrA2J9hmavINhm8l3uwGJO/G9Tpm5QMv+p6uu+/U96tHV3lFD+9NlpHnqnOyUhKZadnku5Xq6uVUa36O/VkW91LeXhZY2XS60d+7TiUZDPWIdsrP8nIx5WhZ6v8qjqkNieoILiodHvsuHRcSvVLNMbQqsaQBNjSHDCmTTz/yjnQG8+cjyGq0iVQX6V1Xa6A/1BfTsT6VtsquLpf6WgFMqvxI/E85MyoyMeT445rJ6VH/n9oPhpT1lgaO8aetE0xOQcmmujeSVMEwYqkFTynsYZFomRwp+d6nu6Utiqb+YzhaYg8fFETpofvy2Dw1xsqekD/t7e3F99bW1uLb76GkKssHtEgA1yhgDoojPuQvd58H7RHD3BV08OYVU+PEHBZSp5Jd45rYNBIGQJH4sEB9/nz55e2GzC/2Ww5bJ3hsv5aRJVTGXisf6WrXGXj9gJ3rHBl2x1QSR78Tx7Zvh6KzrB/kjuV0gqSG5ke6uxnZVA+5I/tQB1k/StwkSII/Nt1nDzznl4pxv7N0ORqlZ7t7fwNGdl+tkHPiedjmufr5TM6gdFL/gzl79sCOA7wm/yIb8qaEVOUD3V9zMon98Cn1XmnShdSOV4P1pkh8apfbwzze9RN6ZLreUpDWbpTpeKT36mOCaz7XOv/Gcnj+sV283pze5Ce1Zwm/ePWgeRkSDaI8vLDTzUvi1hGkqP3L6+frpE/ffvWAX8VItvZtxy4zDgeMj+Nw7omeXokYc+RkOYFylbXOFZLtvzo9cdpK+K6IH2sLZioqtM6ZU800UQTTQ6CNWgIiCUam36dvFlGMsQqZ0CaUMaUn4CAQLgMEh44qP/cTrCzs9N2dnaWnATb29tte3u77e7uLv2Xw4B7MGnoMmSbxqG2Cuzv7y8mdTfixN/BwcFCBhUIIYCgASYeqlBeB7MOYEQOKCtwy2tst4pobKU8FF6qEFfPm84AOnTkKNje3j4S4ZGMSTfa+NtD6ZUX9YZ8OQhgnkm++q4iPzy0ndcTEEkARHpI0OZp6XBwnSU4YFs5byn8lyDd2yLVmcBI7Z8MdfLoOu6OHPYfysBBnwPQXgSLgw7XHe8jDvLducdDTV1fHXR4eayjt6/fS317Pp8fOYDTeZAeUb7ihYfCkmc+kz4OOtL4zrEs3aMsqe+sX6IE3tmXJTduW0l5qF2UJvVL11XJ23nk4aUO9H3scLlwHKHcnXd3wmp/uhzRTKvxtLXaWZrGpVQXyknzMXVAfOkMH+kcx3p3FkoGSY84tvjZHdQb7x+uAz6GawzRWUbu8HD9V73SYalJr70urqNaTOCYzTaUzSC7x8+NqebjZKM5uR6mPLwctvMYm6DKY6KJ7sl0HOfdSfJwWmhyEKxIycM7tHJGWiXtmDJ6oD9do6dfVClsz1lQOQm8PBk4XHFitIC+GVUgh4AcCPpPgzoZkm4g6uAgTeQXL15cGEbkaz6ft4ODg9ba0VPukyw5efPVXEmODlLcWHHjjteSYdbLXzz3jAuvg9qFp1vTQGO+dBLwPAg/gLAC6UpDeTioc5DrBnLlHGBelI3LoDIWk6wqIMJyqW88aM3v8TkanQRdlCHBkzsCuPLsBmJyDrgxr/Sqn8BV1W5cQeNqnrcNx6oEmrwdKnJQ6Xy5c8AdX8lQTvLQmOLPcD+2G890LKqNK/DhDgJ9b2xstP39/aW2YnSUnEypbpK9eHJ+KtkmQJSo6huu8w6Oh8Yon0vYHuy31Gvqc+oP3rd4zfus88E+ltpQPNLx4vLh8z43ETDLUa3fypd9iXXnvOTtX7Uj68BDct0J4PJ0BwMdBGmM8f7Xk43yZr08fRon3KEgIq+uO2p3Hhisa2zvRNRvjgH8zY+iBg4ODhZ2huv4OiBgDKD3tkjp0nxW2XLMx8e6obImmmiiezZNDoJTTFfb4+tOAk4ibpSJEpBIH6VNhtcYpwjLriICSMn50nPkXK5Jc5U83TmQyFeF1y07Gfe9jz/rhp2vUlX5jqWkb26wDumJUy9yoCrTjcRkqHHFjvmQkhGd/rNM9hGvf9Vn+E3D2nkjiFhFp6rynVyWlTzH5NFLO6Svqdzes2MpgVoHLwQZvfonJwl5JK8VrTp3sP15zfmrnCX8ncbOSta9uiQHjF8b0pneXJLk7HNZa0cPXtS1BH6ZL/ttVd8K3Ca5pz7kDgKXFx1d1YGgPeqNNX6NoH9jY2Pw0N6qHDo2h3jpUTUnuM76hw6oMbbFOlTV4WrbfBNNdJrpcvTVdXg4LTQ5CFakIeOQE+5ppKGJntSrIydSD/PVahlXifnfV6XT6nQyiHziFiUHg4wTrRCQbzfs3Jhqbfk1WlyFSsaey9fr40ZnBXQSWEttQj7TO93dkCVfvMfBNIHlRJXsXB6+n9QN66qPpWvVilcF5klu+CX5e2i1y8VXLD3vnjHrr8hMxu+Qg6ACvVXfcaDJNKn/kAfqBqMgEvioZEwgkgBlAjq+kqv7Ko8r/knurt/8X8nSr3ubHAeIiGfKSpEl7Du+oq7rrOsQ32Mptbs7NFKdqjarxogesPOx08dW/1+VM+QgInE7jKfrRRCo/MppwjZWGYz+8XmJRN2oxjPOeapHa8tzk66nM1TIo29ncRn2eEg2g8tQY0wiH2OrNue3P8v5g3wPOTJ9rPDx3LeE+Zh3ksa+jzFDfPfqU92r2ipdG5p3Jppoons2TQ6CNYgD5SoraWPCbavBPa24jiE3aodWxdPvHj9VmZpU9Z731i6FR2sfu7YP7OzsHNnb7tsPUqi5l8XwbRovCt0l8QDDMc4chma6zHoGr9/b2NhY7KlkyG7K0w1tGjP8z+fYxh767w4XAiYeOEhQQvnqYKtUpoNS6g8NRPYBN5QduCUDpQfuaES6LNguqpvLWkTnEclBp56T4ejtlxxk0k06ZpycJ5cTn/OxiOcCeHsmpw3D1dl3PB3loTonIJ50mu3AtnPDnwesudylfx5mLrp48e5tMsnIZ92Tjnm/SmDbQaue0UpoGrdVbwIYysnroTGJYNJ1VvIiMHJHTzUecTxJBn8aW+bz+VLIOr+9nT0vH798XCN/BHh8XtfYZ1IdvexEPh4rH11P+XrfIb8EkZIF9Y7ladxXPdPZAg76KQvqMvsenyOv3sc8fzou0rhNne3xp36ZnDvqj6Ktra0jZUpGPp6wzdlPlb+2agw5MSry8YpjD+0J31bAswfSq3Ir+2AMwO49zz7k971OQ/Xu5THRRBNNJJocBGtQL0qAhs4Y4JnIB/E0OVTOhnXLXGWS8NX5aiU7TXYE/zyHwJ0BdBjwhHGXi0/qnNhVPoGS7vP9z0NyobHVMz4S6ElpVCfxUsneQQCBqztIXB9oiLozIK1g8S0FnpdAQgXQKidBa5dCV9NqGY1nz8MdQdV95kMgSkeBy0R86ZobmTygivJqrR1xKKlddHAWy5Fe8mA6PeNOGrarg4vUbk4uezoLHGjKUcH2oCODq9jpwD46RhLgdNkR4BA4UB58zsGJylA9XP84XibeWmtHdJAy5Ooh5ZwM6d74nsYF758+NvAZHYJGJ4GDcoL4qt2rOcBXZRPvLNNXStN4znZlXr028jyo5wTtrS2fW0LQyLpUdU3kIJbOAfKexijyqD6ke2nVubVLb9tRPba2tlprLTp/qLNqfx/zOaaoPOmN8tUbf9xBKLlsbFw6OFiUHLscB/i898HUfpQp9YT663ZU6vsE2D4uskzywbGM8nViv3cHpeRLm0IOAh1KOGQ7kMfqeppHh8jtQR/7VqU0j3pZE010T6B1+8hJ83BaaHIQrEHJ03scolE3Ju/KOeCUvOtXwltMY85fPURDlsDUARMNWQeEqY5uyDpwUVlujPQcKm6o+ERaPVPx6qC1lzbVkf9Zb09XARsHOOle4sfBySr1T3X1e+78GZIJ73EFl8DcjSZvu9Q3aMAyz+RY8PQJsFAPfUXQHSYE6VX7VcCV6bwfucPHgZrrgxvbNNJJBC9avff71f+eUUzdTm1WjQGV3HmP8mDeFXD1/873mPqJqDdsY46VkqmD4qoc/medCKYSr1WdlB911mXp9XcZO/WcJp4X/ycdHRqfhqjXhomH9L/n1GPdvH3131fPHWz3HHIOsjVOydmtMaQ3Trgzg2Oc9yHlpyijqq2ZhvKiHqrO+u+RVK4PqZ3YJ5KziGnHglz2O/FBxwGdBr7NIAH1Ve1C76vHoaFxkunGlrdOnSaaaKJ7Bk0OghVJE9PVpGQ4DlEPdJ3E5ESi8ZMiAVSmA5nKUOFvN8zSKpfSsa2GDHzmmdL7/SFyQ8WNYr/X46XK3+9XhrXfT06XIVCe+Ev/EzBL/I1xHKQ6eBmVwyLJ2/mkDN0AZxo6lVwfqzZygM3+OsaIJW9D7VTJsgKN7ox0Q77SjQSC00o4eXLniMvaX/XocnFZVPeVL9ud+fnqaOo/vdX31M4ua+q916UX9cEyEvBMACg5RRLPCYC43lLfx9S9KsvzH3ougete+f5NmXhUgSK0fIzt9Z8x930F3YGtOxC4gp+AezWG0IHtQJX/vd+MGcf9Pst3wK26VO3bA5s9vugsoLPU52/vjx5hksqm07jSuRQZU9kSaYzq1XcVWvWZsX30ONRr04kmmujeQ5OD4Bg0Nsx0iHxVsmegpGfGOAuqAb9nFI+hCvRqm8Du7m7b3t5u586da2fPnm3b29tLry300PbKSUBQ01pbCvs7PDxcep2h2kCrmg5eq/Bn3qtASQXKE6BzZ5IbJGPCfFOZzDdFArTWFq9zTG3jq8s0Yitw6Xx6eKbrkQMjNw49asBXktwwpRFHA93vOY8sk+CYPLnc/R3YDtrYBjRoExhp7VKYsWTuZSfD0x0KKbomyVVtmsKLyVsVtk0wMwTyqAMkN/ZbW14ZFX9qRxrmTkn3KhBUOQf0nRwFiVJb6rePCQwF91VZpVVYeeLL82YdGMLskQ8uD/+dZEMZ+bjFenlYu/c16onqXPUltpeDM8orHXipNFohT4CYfFB3FYnBbVwue66Me3/St+uTxgSvo/KjXKlz1TjtMmMZOsNH37qegKzqza0L3gZKw37AthCf0tdq3uQ11iGNBSL2FUUcef8XP2ns8bZ2+bJtqzGL/LkDRmclSc/8VYZsi1T3sYC6mtfT2Ne7znK97mMdRL2xiPmlNBNNdBop2TRXg4fTQpOD4DLRcUD3SVPPOdCj5Dzo1YvG1ebm5pJj4D73uU/b2dlp29vbR84e0DUeRthaNlBFCq08ODhoh4eHS4cHyXCQocNVFxq0NCxoeLm8HKxWzoMEeFmX5NShkeQGWU/ubnS7MZpCPltbPpOA+2N7INTJHQIOuhkm7XKQoSgdcTDGFSKXMw1oGkNuxHjbpPZK8ucqXdUmlDPLSgZ/a/lwS08rw5SOG6b3sGR33lDn6HjzUGhfBfPTzTkeuMMgGd40sNV23t5+eONsNmsHBwdL+unAmuT1VDlJNz3SI/WLpNcsIzm6EkiWjCh77gunHNOzSWfdMcD85vP5kh6QHDQn4EYZOVhUmfzPelAe7CcCdKyPO+lYR+kK82Hd6Zhzx0E6hDZF5Sg/jg9JT9XPnE/XLfLBOpJH8cHzc7yNks6l+Y2ykNP7/PnzbX9/fzHnsY5qRzrbfXzifOd9gbJRHtvb20v3VCb1hG1XAU7+9/4reWm+4KGDzpNkTgeQzy+c19PY4OM69U0OAZYre0Ly56GEqa8lpwT5oDOm0ol1gMPQXOdUyabHO/OeaKKJ7j00OQjWIE5WJ/ncmAkiDd5j+OF9B5u+euvpq/ySs4BGy/b2dtvd3W1nz55tOzs7S28r8NXO3oonJ2FNgH7KsLz7OnzJQbIbzTRaaKz1Igh6kyTTE1y5wezgoaonjZBeexHckM/06i43EGkouzHjH+eVzhQaub4CVK3SaduJ66W3gbefG9R+z7/ZlvymTFSu7y2VQeiHUQmIsww6AVxv2BZM65+LFy/t5XWwnoBuSsc+5XpMoEZdkI44AHcQT8Pf+SYPbrQ7UFAeyt8Bec/pQ3mTN5HrxpAek3oGcNW2yfnjfSk5CBKQpkzTQZEOSDQ2VO+vTzrvzgKXY3JoOCCiLhOAUhf43+eXBIzd0cB0DvBd/uk5yS05AVwXfExOYxLHAQfNzM+dL2MPsvM6ay6j81ur2iqzteXDDt0xWOms193BtfIQ767T3q+9DF7js9QXvnFE9fCy3KnA8ZPfaQ50PsizO5xUJzoBdF/ylzMh5e/1dVoFWA/ZgFUZKmeMDTmWj8khMNFE926aHAQnTJcrcqAC5Lo3li5nZAMNlerDdKLK0KhAICd6N1SYf2+CGwL8XmZ1b4jGTrLJgD8OOUip+EmOgVVpjLGY5O2GY6IEivi7eo7ApbpP54sDluq7AqyJ556x2GvnSn+r/1UbOqgcyos8p/sJuJN6dWJ7edtV7dobJ9al4+aRZEDQlaIPqroNAQ494zy73JLeDtEQAKjKrJ4d0/aJf/9O9RUN6bLLVSA3tU8ae1YZ+1Jbp37Yc8y7A4TXmL4nk5OkNI/25oTk6Fl1vvMy5KCiQ0BlVe23KgBP8k1OxsoR4u18Uu2zbh7HAfOTI2CiexNdqbF0iIfTQpODYE06ThRBRWMG6uMM5r2y/d6QIyGtauuj7QX6aCuBPr56oQgA5aPQc91zMDGfzxdhf1xV0rNpFUUko41GAq8lB4Tq6qu35MfL0Hf67WHdXGH2FSet6LAMr1dyzNDw8nMevB5Mu4rhpZUWN+5oNMmwS6trzKeSZQI+bJ8xPLa2vC1B11VHhi67UZ4MR9cJfot6xnXSM+lgeoZ5pfYVsX25sugGLR11lRPDV8YpQ4ZqpzTUgZ5jM/Uv3pOsWAc6dRIxvTsmXWeS8S8+KvCX+p7+b25uxnG0B3hTGelZ6pnXkXw4WGNdk4y8P3C1PsnJQbh/sy2riAEHaRpHfDxn3an/Gg/TvOBnhsxms6U5RDrpbepy97pRfnzdq/7zm3m6w4Kgk/vbOd/wLB1v/9QfqAdpvCT15K/ICL6WlZFILhvyTp5SFKDLWnLRXL+9vd3OnDnTDg8PF44dH28o7zQOM101j3s0Cu8rauPixYuLiI1qEcIpjdms/0mRy5GyrdL3ytf9yUkw0UQTOU0OghVpXccAqWc0nyRxcljFObAK0dhSaP/u7u7ic/bs2cXH38+sSVmGUmt3G9l8v3Rr7YgxQzBHUKe8dUBfMmTZdjQ+3Ohg3ppAk4OAhonLRXXkidpubLhDxIGs+HSwKn5YdzkDnE85TWhgO+BUnsqL5TgYpTG+sXHpndoEFb73nNsJ/DAvN1pFlWHGssf0RQc4rd29v1v1l5ErJ1UCU66DlJ/CZSsHSwXIUpvyQ+PXAa+3FZ1zSS5qGzoi2Da+0krAqNeD0piWHjmQVAi074X2erbWlvqwv0pN6dVOrpOUN19fKlIdec6Fg+dE7Ou9FWIn9nf1BYaiO/D1/u15S5a8LlmzvaR7rLPn6/pM+abtCe4g6Dl42PZMx98MzXegJseAwBhD91kHHmqZxkPVSzrL9k76kYCng0rm7eOs85faL40j+q15TwfsEni7TFprR8ZXEudTpnF9IF+yY/hbB/VJr86dO3cknF+8qpyDg4PFWMBXnbpMCEI5NulZ9bfNzc2Fk0LOHekEX+XosuQ4w3bkVgLlo3He79EW0ZZFOkBSWzr5mJ/Gm+Q8GsrP5eh94bhUOQl8zp9ootNM14IeX+3yV6HJQXAM4kSlCYr79npUOQnWyac3SQw9P7QaN8azTPCyubnZdnZ2Fg4CnT3ASAJf0ZMhxElexoHSEdhx5YKgRYYGDyfU85RX4t2BAR0EvqKSDC/ml+TC+jo/+hAQVE4CGgUEYA74Ccp5eBXBVlpJq1bXkqEi+bqxnYwjvlXBvysHAcvy/w4GKkrgiIY0V6vGrBZR71QvdxpQlizX+fHxg23ocvJPOjGd7cyoE/Zj5k+S3tPxQKDF8Ur9JTkiOG5Rt5Nc6SCgTNhP3CGrcUH9nWWxvwvkeF+lIyTpYZIJ0/TONeH4RUCi8cP1luWwf3u7ETRrL7TrPAFkD7Tq22XlQJ/1Sbrr7Tk0j3ibOoATGPN97/x4FEV6wwhlkOrL9N7v2QY+TsuJlZx07gRzB0OSncDo/v7+ApRyvOQcpzLYl5gnna/UsTHtwTq7zaFxhPOp790XKQ37SQU4ve+pL8sZKacD68Ey2Qe5mFDpJ4E+nVO0P3joMW2S5FgaAtM9mXvaZLv5eK1rlJ8/OzSWpbwrSmPHRBNNdO+jyUFwwjQWVLd2/EiC40QyDD27jpeLq9M0aBxYu0HqRpkbyfzvaXzS5aeSLQ1O8uJGBstKKy7ir3LQVOCa8iUYrJw97nTwe248pPQVaOg5Anr8qw6VQe1GcsXXcSjJfgyvbEM3FpW2yivpp9OYug31LzcEx7Sf67WXU+lpj4ceT6lOLhc5YBKlvuVtRBDDZ4aAkDtZWOYY4z7JqlqR9ecJbui8YJt4X0jAI/Unr/sYp5bz67LspVu3n/acCdX/Xh2S7NJY77IWJcdw0sukX2k8Tg4Llt3ra67f6XT8tNWMZffGnx5Rb/wgW/HOficnQZq79YzqPVYPe3MSnS/pwzy8bw2Nb7Qh9D/JkW1zHKA9VP/LSauO9UN0knlNNNFEp4MmB8EJ0yqD/3GcA6R1Bu+hsocmGE7iWqnTqwt3dnYWrzJMxkVPRlxRpKOB9zmBk9+xnm83AJLzQXWkoUZjimGNupd+O2jzVSASDR7mVaWVkUKjKjlk3BHCPKpvOk38mteNxnsy/t3gFPkKFmkVwFOBqpSft7e+kz4MOU8ciFdtlYxQtvUYg5jUi/wYQ963h57z+icAnPKuHEfuVHInAfOiflCPWFYCf3yelGTn4HwV49rbkZEpLh+uYg/16cS/g2T+57jp+pScAim6yvW0AqHeZv68/1Y7EwinvtLTw3TP9U7fKfIhjUv+XPVd9UvXWY4nHh1DXVcIfQ+AuqPDx2PWqwLcY8d1OjqS3qToi0q+1VjHsioedZ/RBGkMIbk94I6X1BbiU1EDvqVjjKNjrJ0xNu0q5I6rNP9V/K/Ly0nXYaKJrgaNdWJebh5OC00OghOiVcB+L211L133MFV9e/joutQDKHIIbGxsLM4WOHfuXNvZ2Wn3uc99FtsM5CzgQXnMg8BGIaMKMWRoP9OkurvhkYCGnvNQSTcuOPHKaKGhpHzm8/lS6Lx4cf64f5b3WZ7K2t7eXgq59RVU1c0dA9q64a+5S7IRnwmI6r/yofOH171dKFsCSPF/eHi4eD6V68aut6F4I1X3K0O1tXbESJTB3nMQsA11nXL29k46WAGjqj/0DHdvR7Z7ih5guVWfJtDVMwQKKkt73qmDfn6H2r0qU/f43vvZbHZk/zmJ7ywnGE8ROEnvHXx7+6hN/bofEOoyU13TayV1Tf1ZY1qP2L6+FcjTiVeGRPM8B41NSQ/VD7RvvAcy2I5pHGSa9Gy1hYdjr9fL+56f4ZKcH2rD+Xy+BC4J3FP/ZlrqFfVFY3fSZXdgX7x46ZA7vjaPsic49bqL3OGkNNQ76RX137feeN9IDgPPW/nTKbe1tdX29/dje3NepROC+ZGX1N7Om2Tuc6RH0nC+lPNFZyXoAGS2AbcU8MMxyXWetIpzwH+PoSHAT55cR1N5Q/xW949rP0400USnmyYHwTVOyahNgzYNlV5Yr69QD5EDXgIZRQhsbW217e3tJQeBv8WAz1XgtLW2dB5BesYnQYIBN+DSREkDjYaA71Fk3gTzkivBDct3IpikHOmkoKy1p721S/vdK1LeitwgYHWwRFn35M9n6NRJBxv68zJWufKluhweHpaAh6twQ0bZGMPLQVC6J365cpRCfVkuDW85TgQu6HhIukpnEOvkhn+SK9stGd3uICClFbE0fgxdI688RV7jgDuH2GecLxrqHi1TAQWuQmvcIaBTP+AhqJXuu7MmAUWXg+sa29kBjzsI2Pe9fyR59wCUyhYRoIsf6abn5enVBtW4RfDneegZdwr4p7Xlc2MS/wm0u+5Rx3jPr/HQxtba0rjO8lzerGuSf/Xf5UNQqkMI0+r2xYsXF/ecH9dJ3uMZI3IGSX6pzR30p3E/jSeS3Wx2abuDnMSpjdU32eeYv8/lSYbeb1UnAXzVWZScA/qmg0BztTsIDg8P2/7+/pIjh2N11d4VjbHV/P8Y50Eae6oxaYh6zoBVHRkTTTTRPZsmB8EJ00l5XNMEcFxKE3Nr63mKCSI3NzfLVxv6ymYyUtwwEnCunApKy2crwJvqqm83ThOQSg4HrdjJgOEzLmPlQQMurVRSpp5PpQcVQKyMwCqPxC9XoxKQrYxNl6E7VpKDKhnG6X+iZFwn47UCNFz58gMIWV9eTwCWvCS+vVzXfc+z13Ypra9gDzlSlK4CZKn8pAPUfy/f24b8UCcIQrwMb6vZ7Ogp5iKCqd5YQ5BMInj3caDXB6trdJiwXmOoGsuSbkmHXQcqZ7A7qlKa6ll3rPScAwRbfCOMy8hlnWShb/Lluke5JT0ccpoz/9QvenKRDFQOV6h5+GJyFLCelSxYL0biKU/yl8D5mHGG5PJzB3waY1OUCMtJTnyfG6XHrS0flJp49bKpY3II0LGob9964Ns9fA4YojQ+nJTt5nNLskfG8tmj3hg30UT3FLoWHGFXu/xVaHIQrEGrrsKvS1dq0F5lgqHBQXCaDPFktCWwU/FAY90nSi9D95LRyvtOlYNgXW/8qu2laI+UF18vl55zGevbr7vTIa1aV3WiTMfoibfHGNDfk9lQuWN1N4F4ApghHgT2erz3Vlad50qPh/pHD0BdDkpjUA98pz7pYMJJbcx+0Btfe8AmlatnUj7+m9893VsVPDjAqyjp2FhiX3UgT16Uls+sUxZ/p35FSrJ2nqrfnk9aIU/5+X85FFxf2T5KV+lfAsC8x4gF178kk+TkqORUjdUVAO+1wRD52Oh1qebZVedQ8uXtlhYI0isrK95bW3ZAMYKl147k6Vqhavy63PbhuuPDRBNNdPppchCsSWOdBMd1JvSMBicCFE9XRQ94Gl+NUF5yAiiMVxED2l7A/1zN5kGFDCGkUyGRr8aIn54x5BM/9x5WqxtuTLtBlIw3yYGTZ1qV9HBKGqA0YFRPPS/56DfDY5mvVpLSYZAsl697Iw+eVuXSKKOTpgcEq/ZjqKZAIFfrdI3kupqcDMyzR264eoh1AjZVnu4AaO3oaw9ZXzfeHIiwDt5mqX4pCqeKGBG/PUM4GeZqc4+MSSB3c3NzSW/TKwR9K433V7UJr7Ne1E1GLA2NZ8w3gX+XASltAxgap1K+fn6B6sRV0gpoUxZ+31dVfQxyoJ3q7SvX/E097vHo4yT7V6qPA8t0vden07jg/6u5No03bB9GEOk/68l8FRWQItAYjZRkTCetRxCIXG/9OfZ9nSGh+ui6j7HVGOG8q+35TaeH9Jpb7cizflfjjvPhusvxR1sadnd32+HhYWvt7q1qHGeYp9qNURoal7jVQHlwi8cQ0K7mINaB1ytA73lV/aFHY8alHt/VMz42J34nmmiiew+t/568y0Dz+bzdcsst7aEPfWg7e/Zs+/zP//z23ve+t/vM53/+5x+ZAGezWfviL/7iRZpPfOIT7QUveEG74YYb2tmzZ9uTnvSk9h/+w39Yi8e0wjNkrFb77lK6VXlxqoyOHl8E2/zf2rJRra0EOzs77ezZs213d3dxEOHu7u5ie4E7BfQc97NX2w5U1nw+X+wl1PuJ9/b2Fu+NltHC0ER9Dg4Olj48NTqFEnq4Z2Xw0uBSnagP3P8o54QbEtxD6vv7VbbaZnt7eyFXOWL02dnZaTs7O0dk7nLX2yT0dgm2lZ7n9hC+fUJGYgoPdgOvcth4SKcba+lTHSCZ5NlbMUv9gvVxI78X7kz9kH56ndJBWfownN77WYrCoYx9X73nk+Tgep2iJCoj1vtmuqezR6p+rX4peWg/9sHBwVL/435tvhde6dkfVIb6Qm+89LZ2GaSxz+vo1xMlvXR+1f/EN8fN9MYXz79XLy/74sWLS2MmZclwd9dVgt6hD/t1yi+d5yKZpLGen8pxqf+cT9xhxLaj7PQ8Hds+hnJ8VXsoX+Z34cKFxVx05513tjvuuKP9xV/8RfuLv/iLdscdd7Q77rij7e3tLZ09QL1ynWD7+7zJuiq979P3Om1vbx9xGrsuuz77eOHtK13SeRXiV05E1w3XUdbfv9PH+/nZs2cX5xttb2/HfujOCY7NHI/39/cXdoTGZXeApf7d65MVP2McM1U9eo4yLyOV2SsrzePJCdCTy1j60Ic+1P7e3/t77QEPeEA7d+5c+6zP+qz227/920v5rmrzTzTRulTZnFf6c1romoogePWrX91e85rXtB/5kR9pj370o9utt97anvrUp7Y//MM/bNdff3185md/9mfbwcHB4v+f/dmftc/8zM9sX/3VX7249g3f8A3t93//99uP/diPtYc+9KHtx3/8x9vf/tt/u73vfe9rD3vYw47Fsxt0BKyaCJPxqDRVPlV+6blVIhSYjygZDgnY0rAhMJVRIsNB6TnZJ0fEGF59RYen6rt8CNwuXrx0TgDr4500Xe91ZOedTgU3iF2GBNNqB60kaoVE5MaUZOGGYXI+uZzdmeGGhBwtajfx63JNhgXbIK2KuHz4vOrjq8uUGWWZ7jOfauAl+HcHUbXalYyltDrKvNi+5E91TGAzGXUVQKqcA3IuOFBkfSmjypD0uqexReWqL2o1nPrpuiVj3fmkQ0jpOH4wisb1fijUuNeeVd3Zhkm3yHtlWPvvCmCId4JyEWWZeGQe3uf0HB1SHEP42+VRgfaxY6XakvOenvGojGo8SX3e7zH6wmXL8YaU6iM91vjHQzPZRpIbD7mTU4sguJqjnTQ+c27TM96HvM6pP/qcyL7v8lX5LjPxo/owSsAdZZzPq3G9GlPTGMlv/Vab6PkzZ84s2ke//TnpmDsr/DyI5Lxx6s0nYyjZUb20Y9Ol/6keVfnep9blZQx99KMfbU9+8pPb3/ybf7P9q3/1r9pf/at/tf3n//yf2/3ud79FmnVs/okmmujK0DXjIJjP5+22225r3/Ed39G+8iu/srXW2o/+6I+2Bz3oQe0nf/In2zd+4zfG5+5///sv/f+pn/qpdu7cuYWD4K677mo/8zM/037hF36hfe7nfm5rrbVbbrml/fzP/3y7/fbb26233noZa3V6ySduTSrVSme18sP8kvHt5YmGQHxaEU3Aj9cr4v2TmhzdOKqcDSIZNw6IkvHuwJFUPcP0FShN7eZ1SQbdGJJh5zJJchkCR8wv3dP99Lzr1LqU8nEwyfuryku06nMnpb+JUp8VcPJ0iackFyfKsAfy1pXnGEpg5bj5OAn80Aky9KzLr8rfnRkErkNt4O3ba6cxfXkdcieB33NHTQI9Lid3/qSyeuRRTA5Cma5HDrYFhN15Uo3fzMdlMkaHenNHRa5PY9KLkjx8PuK1ql3H8Juc9e4Q9jngJMeRk86vR1eqnOPQq171qvbwhz+8velNb1pc++RP/uTF73Vt/okmWpdOcp46Dg+nha4ZB8H73//+9uEPf7g97WlPW1zb2dlpn/d5n9d+4zd+Y/Rg8cY3vrF97dd+bbvuuutaa5f2C+7u7i6lO3v2bHvnO99Z5rO/v794529rrX384x9fpToLGqsMaWWf91KaVSIH1iU5BBTSy/BCDwusIgbcecDJPhmsPolXnVrhtMxnNpstVgi0ysC8/DwCX0kjUHdKhqnfp2GTIgqqMqu3BbR2dItKOtPBja4UrTFkSKY2qQwzGbb+fDLuVW+uLko+Xl56lt/k2V9NNYbYPlyl4m8PUfa6sQ3dAUB+KR/Vv5LVWIPP+5GHDjsPFaW+NpZcT3xF1NOxHMrO9THJXcR6pjw8DJz9pQKzlZOH/FdGfwVyEpjz56ry08p7yovAP+klddrHJKVhWvJePZNk19OzdXTK21EycTmk1WkRo7Mqh0pVH4am89WMHq7uzgLm1evH7rxleo8U9H6dov50P73i1OeZaqz2+YHyl35pnKUuSFbu8OjpovOexr/KFqA+cN4jP/P5fGnLjG+fYbRH1ecvByW9Gyq36lNVXidFY/L9xCc+sWQPa6uO0y/+4i+2pz/96e2rv/qr2zve8Y72sIc9rD3/+c9vz3ve81prJ2fzTzTRRJeHrhkHwYc//OHWWmsPetCDlq4/6EEPah/4wAdG5fHud7+7/f7v/3574xvfuLh2/fXXt8/+7M9u3/d939ce85jHtAc96EHtX/yLf9H+/b//9+1Rj3pUmdcrX/nK9r3f+73xnhsvaQWB4blKx2tjwb2nW8UpUDkTnC8RwY4mIoWn7+7utjNnzrTt7e02m82WnATcX8vXG3J/fdpiwPB18qCtAZzMfeLiFgJfwaShlwwNGoOVvCgPycQpGTg0iFQXz8vT0/D18ufz+WLfZXKyuINAdXCHA885qPiu6u5UOUZovBBoEMy58yE5MpSHnnUQznzHAutE1EOGv/ccBJVzoOI9gVo6hNgurKMT5ZkccExHYEMe3chP/Yr/UzhzkqHqL9lVjhDyRrlpu0DVnnQ8alsD68W9+6xTclBUTgvvG+k76YP/Ts+mcaQax6uoJ3da8nBIhnoT2DklYOYg0sGiO2aGdKaiqr4+5yhMns4/J9Y95cF5VmW7XlNedBprr72czH5eiTsJPO8hJ4HrjX97+1TPc9z2sd5D//msyB0vyaHmB+eqDzBv3wbENJxnyRvnLG9fdygwL9WV2+U4pvDcl3T+kI+JvfZy3fLfQ0SZUPYV8PffPk75NVJvnEn8pHtjytH9m266aen693zP97RbbrnlSPr/8l/+S7v99tvbC1/4wvbt3/7t7d3vfnf7lm/5lrazs9Oe/exnn4jNP9FEE10+umoOgp/4iZ9Y8hD+0i/9UmutHtjG0Bvf+Mb26Z/+6e0JT3jC0vUf+7Efa1//9V/fHvawh7UzZ860v/7X/3p71rOe1f7jf/yPZV4333xze+ELX7j4//GPf7w9/OEPb63VAPskyY2cdZ5fhdzjL6NBZw7s7u62jY2NJbDKlWw5BvwAKX4TCNK54kaFG4eVweArPT7RpSiBNBlSxwhw3NhM0QW873rqxj7lSqPMQWkyrggmaRD4ddbDnQfkkcaZG2xucFf6wnI8vQMvyZSGCtusMlz8LQH+8Xrxvxu9vEfetN/WV9lSfsqHTqlqFZ88+JYX3quAJvlmGvUplu19qAfmvI1YTnJSJR7dYeHleF1YjnRBujPmRH+m5Zswqn5Bnr18UdUelU7OZsvOLv8koOr1YP/kf3/W289/68A4B20OTLzOVf+hjPlfjhny4JELLCPNO73xV79Vtt4O03MoVCDPxz/Vl04pjaceji6dErjkqrPkrT5MB0GSscp1qsYk12OeA+Mh8qI0p7IcAvyK6KRPQJbjr8jntEqPaU+4Q49jlh/eyrbnHKiytEihc6fYfnQS6GBOHc7pUSerAn/2b79eUeqLfr/3bPpexXGQ8kxzVcrL25PkZ3el6IHW7taVxz/+8e0Vr3hFa621xz3uce29731vu/3229uzn/3sRbrj2PwTTbQKJZvoavBwWuiqOQi+9Eu/tD3xiU9c/Fc4/4c//OH2kIc8ZHH9Ix/5yBEPY6I777yz/dRP/VR72cteduTep3zKp7R3vOMd7Y477mgf//jH20Me8pD2zGc+s914441lflXYFKmaNJzcg96jVYD9mAliLI+952m8uSGSAKqDCX5oHFQTVWUYp3S+MlAZM36vmoTE43GcM86jflfkIIRGeGvtiBFI0Ml7DiKT4ejlJR7If8/A8Tx7eSSDh4ZfBYwd7FZAblWjwp9Zpc0dwKSIA5Xhz/XA+1i+K5Dp5QzVIf0eKjvJvAc6vcyUR8rfy02AtLreq6v+D40vzlNyAFT1rgAX/6e6uW5Tx5LBznmlp1OsKyM9XPYpoiqNmyy3J7NU394zqn/Vl73Nkv5U7aBnPMLF8/eIAf/Ng2+raI+x5H0ojdneBpwD/Dk+U0WR+Bjaa0evJ685P6xTSudp2D/YltUclfoe71FGqd1SJNqVIK+nU6U7x+FxzFzYswuTPcK0119/fbvvfe87yMdDHvKQI9EGj3nMY9rP/MzPtNZae/CDH9xaW9/mn2iiiS4vXTUHwfXXX790Sul8Pm8PfvCD29vf/vb2uMc9rrXW2sHBQXvHO97RXvWqVw3m99M//dNtf3+//b2/9/fKNNddd1277rrr2kc/+tH21re+tb361a8+fkWuIp3kREegz9U6biVwwMptBL3XnaWV7ESVgevGAA01rh4MGcfVvZ5MEt+cXHthnJXh40CeBncCXh6OXoEzL3+IqmfcQEjyWMXwd0oGtq9kJUeCaAigMJ2IhvaQoygZ2NXKi/JIujvGEcD7KX8Hj0n2SVbuVBnieyyw7pHzSP3u6UHSqTR29EC58lPfSKvcLKt3rTKeh/ioxonUn9KYsM54TtkKBDn4F7ljxO85nx4tMYZcFuInbTNKeu+6mOTF+vlYyGv6cL6QE2A+vxQVwGiBJBsS68LIo6qvJYe6y4v9pgLcLi+PxnOdrdortU81nqTn/H41vvTmo6Rr7vxJupqueeSAv854VeeNzz9VHXrXU117fIzJZ93xoSpnyC7q2QRj6clPfnL7wz/8w6Vrf/RHf9RuuOGG1lprN95447Fs/okmmujy0jVzBsFsNmsveMEL2ite8Yr2qEc9qj3qUY9qr3jFK9q5c+fas571rEW6Zz/72e1hD3tYe+UrX7n0/Bvf+Mb25V/+5e0BD3jAkbzf+ta3tvl83j71Uz+1/fEf/3F78Ytf3D71Uz+1Pec5z1mZTwcnAm6t5ZXFtCqZrrlhUK1mpjxXXfGujJCNjY2lMwRms9ni7AF3BMxms7azs7M4n0BnEGi7gRwMPI+gAnU05NxAkAHk+0XpHEhbDNzYSuHc/K7kMZvNlgxHGp9DlACC5OIgysEf5UGHjPKQLJxSuH+qawV4E2ghj/z4/vneCpDup/ZtrS2F1VLG7vjh/VQnlcMVMtY16Rp5138a/8k4YxSHwEbikWUlQ5xtTDl4GzDcW7rA/GgUV+HPlRGu61XETQUOyKf4Vt/f399fjJX6eL/R7xQJ4c7GJA9vl1QXj6xxYOL9pMrPx4TkIHCZpG9tx/DoAL9OHaL+uAyVnuPikDOrB9q4vYp66cTopaq+5HljYyO+ms6fYz18PNQ19hHdS/WR7BRqzm0ErbWF04Db1Hz7gI897PfSTd/KlsBl0pUE8nttJ/mk6IHZ7OhZL9qukajiy3W+B9JVB+ZX8ZaeTWVw9d+jOPya2nJvb6/dcccdbW9vr911111H2tvLHJLJurRqnxtTJuWzCh/sP17+WAeA9+FV5fNt3/Zt7UlPelJ7xSte0b7ma76mvfvd725veMMb2hve8IZF/mNs/okmOilax2l4OXg4LXTNOAhaa+0lL3lJu+uuu9rzn//89tGPfrQ98YlPbG9729uWIg0++MEPHjFa/uiP/qi9853vbG9729tivh/72MfazTff3P7v//v/bve///3bV33VV7WXv/zlbWtra21e00TeG0B7q5691dAKzPs1OgnSM+5E8IlnY+PuLQQ7Ozvt7NmzC+OH5wnQQbC1tdV2dnba1tZWO3v27OL/5ubm4o0H/jyNmDRpc7+hrtEgnM/ni1UCvYO6WjGYzWYLsOJGi+orfpKRT4Ndhla1HzO1h9fNgR7lTsDn+31p8CeQwZOZvWw3Ah3Ap/2+Lif9d8DmwC3VNZEbgUpH49YdQsk4qcquZEeZe/gpjX4+zzYh8HRnghuhNI4d9JEHOSGYVwK0dMi4g4ky9a02aTJMxnhKk85YSMa9rlMftJrHSCLV1UF80jVdY1QS+0A688D12B21LlOXL2VTGeXOX6WTyYmc0vC+5KQ0jAyoDAr2j6TzvbmDfcplx/ZObcM+W20vS+V5P/J8W2tHHG2UF4GvU1oxFvgXiFSkgA4g5DikZw8PD2PfSTrD8UP1SRFlri90mkmfew5bymdzc/OIPg3ZBMnRRxml+cr1g3JmGbzn/ZT11lybnG7KNzkG0scPldzb22t/8Rd/sXAUeMRI4ve4RjrHvuq+yvF0Vb8eap+qzB4fvJ/myqHnh/Lu0X//3//37ed+7ufazTff3F72spe1G2+8sd12223t7/7dv7tIM8bmn2iiia4OXVMOgtls1m655ZZ2SzgRVfRrv/ZrR649+tGP7g5iX/M1X9O+5mu+5gQ4rIlGpgPv3uq+T/BDA/3Q80POhh6olVG+vb29tLWgtXbE2Nfhhdvb24vIgXQ4oZ+wnMgNXH0SaJSBoBVKGX0VSFM+rIuMFcrDV7D52x0XYyhNygQCNJJoMMr4Zf2TEc77yfioeGqt3rvOOlMOyehLhmlvlYH3XJ4CozwokAZhkuNQezjgIejR8w5o2C681jPMVDcvT+BJ97wsPuftwvyT3FP7McrFP26Qsn9VToTKCE0g2kET5VbpisrxZ5VWzoHKEZvaw50flGnSzQRqU369Z5JTIJUjko458PU+NsQH7xHksq6p34gH7z/uHCMfXLUeArKpDyU58BkHii5fyavqR14HysZPt3cHgZwCfCbpv/PPOULy8TnF65lkRYdfkp2e86iJxIv4T2MR+e0BU+pxkkHV53zO9GtjiOOSf6rrWjDY29tbHC6p/pD4HTN3eHp9rwuUe/Oil7PK/aQDY/te7341xq9Dz3jGM9oznvGMbrlDNv9EE010deiachCcdloVRDod16u9DtHoq1bafAXbgUvKY50JJYEzXXfDgNcro47OAa5AqQ4pWqEygNYhN9KT8eTXeW3IucS0/nuI7yGDYyz1gB//V78JPB0wJzquwcI28baoDLkEtsaQ8zpm9coB/Zgyh/IdY+ivQt6PkoPKwd8QGGca5jOWejKQs6ZXLp8lr2P1recAXYcc2CXqgVndF3k/q/rtUB49Oq5OjSmjKjc5l1M0jctsHZ59PEhtVTmL0vzoel85KZ2H6jd10Z0DXsYq4wv/DwFmH/+H5tWeDidnZppTKofn5aarYbep3HXnwYkmujfS1RgfEg+nhSYHwTGIDZ1Wc0VjgN4YpTlpxZJhonMCFDnAFWv9ZnQAtxnw1YaMGHAjKIXMatXLVwocfGhLgUIKq60FXD3Z2NhYClc9c+ZMO3/+/FJ93GAaM9l66DCNk0q+eo4rRszPjbpee/X4EfVWiGhsJrAwBOIcMLihWBl+LMvTM8S3WilkCG+10s66jgWjdEJ5FJCuaWVP/3sgw2XLeqvuytPrwpXg2Wy2pK/Ub4+GUHlpxa1qu7TK6WmqZ0VeB6ZhBJHLydufq+iMpKmcjf4/5Ut9kayoVwnAJQdpchqwT7OsntPN7/XGi1RfjnM9IORjoAO1KlIhgdI0JvbGEvGZyMd15l+NfdV16rc7BBgVoPlCv1c1DnvOEfZJH0dSNBqv+RYDJ+pX0tdKp8gTr6WzaqqxsRcJ0Vo7kpfzI1597FZ7p9fJVvMHIwY15+vDrXWyU9KZOGMojSdj7IEq/8p5sypfvTKHHFwn4Tg4riNtookmOt00OQjWIF/Z1rXeoNxzElTGd2tHAZGHD+p5B6p8hvn7IWgC+jpskFsLuP+XBw9ye8HOzs7CseDnDZAHhmGSLxkA/CZo1vW9vb3F+421tcBDCT3MVu9K5hYD1YlyZdi25MJv5UmwQ2OschKoHtVbHVhGCmWvQIS3n4Ow6vBCBzbJAK6MT6UnSFWeMr6ZpgJxno/qKYeOO6FECRSwbt5+1ENfRXOZV0aXg3H/EJBQZvrv7eDtnw6d1Gq3OyVUj6SDBEd+iCf1vAorTzRkaBNket9r7dI4ozMW1Je9z4gPP/Nka2trqa34LPPjPW9DycPHZgfJVR+s3iPvekM59RxTQ04Y5k9QRRlUzlSSH6pKeVROjtTveWChAz933oxxlrksOL+oLbe2thayT3KkjnMOcNn4PME3FTiPPi952/r86+3vc24PtHEMcOL5M66jbCe/52MSxweecUJ9kI5Udkk1bnhbasymc8jHDu+H1CEfU50HtR23iWgrgergOu3t5+Mz28PJQXHPgcP03u97acY4qiqeeS9RGpfG3Gdde/12oolOO006PZ4mB8EaRMNclID5qpRWR/3+qtRbBdGEvb29vRQNQBBDUO1nC+gZf1NBMl5oQJC3ZPQSMGjP6P7+/mI1iICERnzVJjSMBT5Vfxkp7nhJhr7+++FyBHJuaBL0cIXDQYv/dgOnAh6+wq3y/cTwBIjcCEkgITmhyGcyhJJxRqoMQckwOZhcR1w2rIvXMxGNXz2f5KIP+zflnGTi99zh0KtjcqSkj1PqQ9R/r5cbrWPBq+uG8vFDDflWAz0nxxz5cSDGw1AFcFweFThiOvZ55e2AyckdBKl+FTCWnAn+KrA8RNIL10kCQAcyDhI9P19xdbmkcbvi19OSB7aBO9ecJ+kEx8LNzc3YD/gtwKnIAD/h/sKFCwsHgTuQe/KugLDrhDsI/KwRPe/50UGgZ5KOUDb8z3HDxybKqLfyz3bn/0TVfO3Ohqpc6qP47Dm4XEf0rNpW5w34aynVBh5BkPLs0ZUCxO6AcDmOeXYdqtq6ynMCUhNNdO+mk904eS+ldQfSFBmwjhMgUZVPchK4kah0vEajMD3DiS6Bswoo9gxR1UPGnRvHyaBIQMENZwKolE+10kn5jXEEuSHnToCh+1WevXLS/8tFyaHQWja0euC2aidPw2//7XxVzgvn3Z/x53s6PcRHpauudzTw/V7lDEjlV2B5FZ4rGpO+AoGVwy3RWAeP0o6hHu+9/sT/HvmzDq37bOVc6NXLxzt9J2dCcjgch/+ePqb+VI2LVZ2reghM8r87FYf0OI0LKU36+JxYRaX1xnaXydh5ozefDLXbmLls7Pw9Zj6tHECpnDTnV/Py5Z7v7klUtedQmokmmujeQ1MEwQnQOhPTcSINVsk/GVoyXnxbgEcI+IoeVz/4P4XOi3qGQALoel6GnlYMaPw5mBoqM4VLciWYK55claEcyZu+0zvNWT5DyNfREX/eeeGKFQ0kRWAwracTj5UBynL5SUZe5UTpGRjVKrL+nz9/vjTO+btn1KziVEj5+//07BinDp+XvqrttKLNlXWmZ1o+z7q5s4s6mXjis8rL28xlW8mlckgQNEkXFXWkKCCPtmF6/vc0/F+FSFcAqRp33YlROZCG9M+vcaxi/3Q5O9iqnJe6n0C4A2JFYCUd7fXxNJ667o459LGSWeUkmM+XI8NcDtxawFVkjyBwfl2P03XnX/ODP0eZsQ1bywcCsv1d3i4Tn8vSWOz3Unsx+sQjUXrkZVTy6TltVI/k6JRuSi/T2OGRID3yMY6RGb32HUvelieRJ/NZxyYYw0OVL8scU/bkcJnonkbVnHqleTgtNDkIViTfCzh2awHTp7TMiwbYmHydt3Sf6bS/e2dnZ/FaQzoC+IqxnZ2dxQGGmoB5/gC3JXAPpcgBS2XYUgY0ELjv0FeImI/nLTmKGHovI1fyokPEIyVoaInHBBJkHDIs2Q04to8bl6nNPJzUnRxV3nL+VPJxvUigK4EGN4RpEFMWFVUhqA6W1O4XLlxYctyobinSpTL8CWr8OZeb88eyHWgRLPikQ9Dnctdv7puW3qserksylJnGHQu+vaBHlDtllurBb5FvO2H4Op+dzZYPN2V4vzv31K7a7pTyqvpTNcYwLfuxg7TKgUeQmMBY5UzptXtry6/59DaswDHz4T0+K9Ds40/1ijwf6yifKrrNwTPLYd5yULhcq7YUqQ58FaHqyi0FrC8PraNcvH3YzxwsJV4qknwc5PXGdG35SuU6+fUqyq/i3fWFY4zfVx5jw/PT+MAxqrVL+pLOe1D6JDu1KfXZ2zHJTOPM+fPnF/NeevWx89GjNPZxnlklr17+6fqQ86DiYQzwqOTh/XmIz4kmmuieT5ODYA1y0EjSgOp7ctPvVQb2ROn53oAu40IOAB4uyI/OFJDBLmeCG/E8f0AgIIHACthX/MkpsLe3twQWHYj4qqs7BtJKB40XlcloCoJC3yfeO51aBqjvoa08lg6MRTRM5LjwewSO7rhwQO1GdjIO3Rj1fAgKKMPk7EpOguq/fxM8ypDXXvTt7e3SsE46XzkJ3Mh0kEqi7BNI0zMEexUo1H/x4I4q6Y9W1yhvOgO87umANtarWmFPDoGkG+k/68m+7UTdZD3Y95h2Y+Puwwl3dnba+fPnl8BnGmvZ99w5VIG1BFp7q7oEl6yLk/f35KhhGo8oILAlyPdn3LnDdtdYybIqZx+dj15flznLYeQV5d8DVATT7pDwvn9wcNDm8/kR8N9aW3IQSJ8YTeCySe2l/kWqePd2S46NHtDjPc2NPocl4O6OG3cQOI/urJAs5/P5olzvF4lXr3PPLkngXtfp0Ewy8r7JcY4OAp/fU9kizb3b29uttbaIUvLnhupU6bLzO8SP17WXR9I156lyGoy9VjkAepTG+4kmmujeQ5ODYEVKk0Zv5aC67sbI0AA8tCo4RAn80Bkg46M6kDC97rBadU8Hi/nqJsFlMmxSKGlaEejJvgfMCSjSKi5BgRtLNHBp6LqDwOs+dpKlsdYD4H6iPeXosm1t+aCqnqFQAQeXn/73+oSoB5ac3HmSnCTV/54zotcP3Uhzg7kiB+GUbXIqUOcIEJ2PBDjHgEYvyynl4+W5PKp6D4EOT6txI4FsB0T+fPVM+h7ipQKCFd8JPFcGvuTh+u6OzKQbVZt73slJQBDPtPwe6u8JKHo+rluuZ0lm3p/Y1j6mCygKTNMB5q+29bffpAgSr2cFwFIdmI/SpOilRJwfmBfnmgT6U9uk3ymd88Vxpno2tZXfHyqb9aJOMlqD11trS85tPe9tOTRnkjc6UqrIFX338hwaS3p5rAO+V01T6avKP2kaI4+JJjottIodfjl5OC00OQguM1WTvxtZx6GxDoYqTJ7XHGSmb90fosqYdZ6SAboqjXmmMrjdUUD+WmtHjJyUtnpmjHE2lnqy7xn2yfinzow1Qp0ogwQ216Hq2coRoe9V+O4BnCEaa9hRr3r93O9TvxxIVf2lCqUdQ6vWn8+JhgCzrjloqs7w8OcSqOd/Aq5VQIWPN2PaK9U91d8jN3rgS7+HHAdjqNdHyFvPIbAKpbGDdU3jAtvcwX6KeErOkxQlNkbGzjPbu/rujaMkdxT6+ES9GIpa6en70NxS9ccx88bQmMp28HKq+T7l6c8OOQVcNpRn73M5AMHQ+HI5wfSYMelKljvRRBPdc2lyEJwgcXLorQowPam3T3AovzRZ6zrT0EBkBADD7HXeACMMPMqA5TjIpoHA/aI+WatOlbG4Clh0mfUMmZQmvbOe5aj+4svPiEgGla/iJ4NX94fqKtlX9XVjNgEW549yZ1oHSsyP5fAd2AkopXZKYGzIoHJjM73qKxncJJcPV117TryKd3cwODhI5VbAo7Wj+3V1/gKBbNryoH5VjRtDQMuf8eeTDiTd8nEgnUcih4DGFPHHd6SnZ5Lusnyl0bN8tZ2TgxLPh/3M9dOdBw66XUa+TcTLV7txhVx8cSytQq2dfPXU+SegSnvOXUZ0uqSxrer3KsvHXo43es7PE9jf31+MLclx4DJLbZTq4jw4UB0zDqW6u5xTtJN0gc/zms9VvTEtgWQvz9uBfYSORs9PxMg0ySyNF94fSGpDtbHsCc0ZKcKN4xjvSRY6X+D8+fNta2ur7e7utr29vXbx4sXFuSXqQyqnF33Yo2r+q+77vV6+nqZymvA+x9eh8sbUs2dzrJrXRBNNdM+kyUFwDFp38NQkSFDB1f1VtxNwsB8y7mQc+lsJeEChDh7UgYQ0KGmwJzDC35qceYhUclwQAKZ9msrPgTXr7sCvMmhYpsgPBZMjQPlvbW0tAUHyn4zLCtCwjFSXZDTotzsIhvL3lRuP/qAR7oCI+bGd3dFxeHi4BKwSgO31keRQ8PokWVHmCez0yvS+J1n1QKjrhoMuXff3oScwmfJubflQLe3Vd+DLcyGYtqqv+GBYL3lmGvFHvSGxnkm3vJ08P+rH7u7uEk/SQd/So2f0qXSKwF6OFcolhfezbVJ0lZ71PpfGn54TwcEsedBYVwFhT+PkYxz7Iq/5h32mGnOSbLwfepslGZE/nY9AUv0ODg4W3y6joS0FbAfXXwed3nb8puwq0JYcCT438DrHUA/BpxMtzY2p7dL40xtbOPZLNmm7DstlX0jzas8+8TqzfDqURclRkRwI8/l84SCQXTKfz9u5c+faxsZG29vbW5QhOjg4aOfPn2/7+/tLdajklIhjLdP7c9Vc3ptPq/J6VOWb0vTyq/geKneiiU4zJbv7avBwWmhyEByThhq7N+D3Jlp3HAwN9BVgT6+74yTMVSca5HIQMMpA/KTJiZMfDVuuBOmbocZ6lg4FN6jHEldRHaw4uPAJUuDp/PnzS9ECrK8fSMjnmWf1WzLiae5DQJr89gxD39qQnnPw4E4XN46dD+WjZ1SPZBwPEdskGeE9o4fpWMdV9IV19/r2jC+/n/77NpUef37Nz+9gxI7kTSei+pXrA9t5rI7xdw90sJ5VuXROuv6pb8mYd90m0ZEp8rajg0r9S+mUPw9+TDo8n1860I1lVQY59YZAakh3OTY5AE7OAY2L6XknB1fUPfLKMd/z6oGYBJRTm7nupY+IkQOcL8hDFVGRxl7nvZpjfbwikO3Vzfua6yHTkWdGDUjXmMfGxsYSuHVeXO4O8nsLC75QQD7IL+WgNO7Q9qgzn8NZJvWWrx+k3vmhwCmyhfOv+qecBFtbW+3ChQtte3u7zefzpbf3iHR2RaLenOFzQ2VD9PIdSiNZ9Oy7NEf3+KzujZ0fq3pPNNFE9y6aHARrUm9QXpdWBTnrlqHv5DDw625cJqpkwQmVkxyjG9L9lEeP3Djp0dg2S6CKBrevrOl7TP4ejt4DF2MpGZHVf38uGdqJhgymq2VIrOMgcPIVvbFOiiFyw73XT3S/6hdupCfwXxmDVd8a4wgYkm267+NMujcGkPkz/pvXqnz8fzLMHfQnOu6Yn9rEoxvISwLvQzQkp+oZ158xbZLq03OGJH1d5b6XOwaEJUrzmNe3N15yvBkz7jBtah9/3qO9jktVX/bfY/pY4jcBWL+WxrHWhh2oPapsFbdrqvqcBkqyvpJ1mZwDE92TqMIZV5qH00KTg+AY5A3tK/ZKUw3oXOmpKAEyv0ZjolI+RgIoOoBnDmhrgbYXKI2vOKX9l/pmKKiHg/oef9WbJ1OncNvUob1MAiZ+uxyrthgyhufzS/vtHVR4OCRBXIreEAk46jsZa76S6UZyCs9Mxloy7NxoHDI6aAy7sedh6r7aW+WXDFcPZ07nDTj/zMPlwby8f7CtZrPZko76CquvYrpcEk+pTYfGApeR88m97Oor1fNJBs6ny2VojOG1odDt3m9GRqjd/e0p6gNMq3ZyvXOnQ2uXoiukR0OkPNXXyXM1tvSAa2t5/3bqQ2xj6ppvf/JQdNaXeu7t4WnSGOGyZBv4836mArevUJaUjUdC+Pif+laKqvA6JPKxyPUw/U/Aspc365/6NmXR0780N7Fd0tYF73vchuL6lMalMQ6INBb4PepBGiNEdJT6GQcuT+/XXpdqDuf2xzNnziz6scpLNsgQHceYH5pTe/LSf5+zqFNjHAW9+XKiiSaaqEeTg2BFomFC48Mnn7TCrOtOY8Kz0wDvEwh/kzdNkjxfYHt7u+3s7LStra129uzZdubMmbazs7PkKOCE69sCvK6z2WxhzPH1hHxNYWvL75b3gwuVjvuxEzBWmT2DMcmrt5pQASIZFhsbG+3g4GABWLj9gOGTaUuG8nHnimTh76omTw7eHAR4OUqfthxUhrUbY5RHAtSeB4EY9WNVvaaOkQ/qoRuNfo26muqe6pJAJqNc6MDyEFuvA2WX8nPdc+dKukcwJV10fUkgws8LqUCuy6S67jpSpXHQ5GOm0m1vb7eLF+8+YExp5ZykLqRDUuksSaBWZXnIetIFOhQq3VK6yoinDJi/2s1BW9pKxfHTQTHHUPLMsYfOUvKbdI4HxxEUs++k7WQcW6Sfkp2PUyyPJF55Ng37lp53GbFcAknPm98+5qZ66Xoamysgyz6YwHaPr17/4X/y5c8kOyI5ozwvfW9ubh6pmwPxSjZsC+ou+XCbiPrlZ6lsbGwszhTwbQrky/sASa8X5jkw2m7Aww2pM6kdXNYuu+payidR6o9p3B2yZYb4GHIepDFwqMyKj4kmmuieSZOD4BhEJwCJk2ZvNbUaxB1Q9AbmygBkuT45y0kgRwAdA7ovhwKNAzcUVL5P4HQK0Ahs7ZLhJaPw8PBwwSsNQoLOBFrd4K7S0SiqgJj4cgPFf7sBLRkR/JA/rpq4c8IBvhvYiTzSgEDG60CQ7YZ1ArRujPkWEP9OYJv5yfjTdYG66hnyQSdSipJIMnIQ4IZ1MgyTfnm7cHUzRatUVDkJvF5qv2oPMYEQV+sk2+S4Y738oMMEeCp98nvJ0ZDaxIES82X+Onmc9dahqKyXRxc4mKSMla61Fh2N/O/1dIBKR18aUytj30F/krHS8X7SNV0/f/58Ozw8PHIgKB0uPZ1nWvJFx4zydWcBx2Lx6kCNaeiAoN4yGkhjv4/3zC85UqoxiFSNBcnxUYF7gUp3uHjeqV+kPMc4S0WUY1pkqMbfdJhlxZM7YZmP14f1d/56oDKNNVtbW0tzosvZnQrkhc4+z5/jxHw+XzgM5CjgnFbZVN6e6X6iobRDc0VFqz7n40AvDx/DT5qXiSa6Fqk3b1xJHk4LTQ6CewBVg7wbKG4YaULVPf73V371ALYbFb76pQ8naD1Hw7wyAhNwYnql7cnCyQ3/3jM0pplexiuNYAG9CkAoH30nY5L14f8E0PTNOpAH5Z0May/TeXZDyctNvPF/RUMGVfpdySnl43qajD4CtSEek0E+xENFDhTG6Cp5SMZ5qm/V53SffbAyiJm+R1UdUlv4b40xrpNJTnSkVPlWIG5M3VIf06qk7g/Jcug7fZyfdD/1vdQ3fMyvxk5SihLzsb8nL8nJgWqKtvHXxfonjVWe1uWdxjEndxAk+aX0Lu9qzO7xUOm0t00atyugV41lVbqKvzEyTHOTO3v9OzlN1O7sx4nvIb1PRL31NqrsFpY3Zl45aXJdZzlj6325+JloookmmhwEl4FohJCq1ajLUbYmRW4tULTA7u5u293dPXLewNAk6+QGnJ8n4PtS9Yw/X+VXGc9e39aOrqTx3hgjwXlTnizH8/FQdK2aaRWDBi3DH5WfG7wVqPFyq3pWk7sbx71VsR5V7UiqnAdeJuvp/LmM+Yy3SeLPjc5k4PYAh2hstEBFXu4Q7+5cckr9wwEF0+l3ijxxPtgWq9SPzyegn0htzBVl8TXkxHSA54C4p0te51T/lIbX3Tkxmy2/NYHt49dSdMBQn+X/qj5V3Vo7enp8GtN9bErfjHZI+ul1TxFw7jxIskgOAW8Dl1HVnkzjWydIaS5m3lW/8HnAddHbIemh5+2vSk1t4XpTAW3y6DSUT9LPlL6KekrkbeN5ss9ozvAxzSNrxjjAxjgXxuSxytg4piwfb9L/obn9JKlXxlgbYaKJJrrn0OQgWJHSQOmGrdLpHv+3lvcLO1VGS/qfQKZCRre3t9vW1la77rrr2u7ubjt79mw7d+5c297ebru7u4vzCBjCqzDfZIARYMrg0/utFTLqB2uxPpzQfaVJr3lyA8ABnfOyysRVbfmo2iABEP/NcG/ltbm5uYgw4KqZt1lyStAwdZ7JKw1fEcN5aWimE/qT0VMBJt6rqDLm/brqk1YoGb3i8lBa/XaA6WAzGczULefP60dHl6/YD8nG+fL+wDokIoAWjx6O7X2B5RK4kionhZ7x/uTyTPIWr0neXl8+w8NSPbyfMuCH9fS0HgnF+jKsOfU5lwPJV8BTOm8fvy7nqca4dHirA3kHCFX/S3qf0oyJXnEASF75Gj4HZqlftXZJ3porVK5vH0hnGLgDoao368WxhbLkWOl9LvVnjxpJxD5MRwzveVpSGoMdMLvjJc2F/t/L8nGW7cT+7s4btXdy6BweHnbHlzS26H5PFqqDv76Vcjg8PFx8ND77OJDyT5ScMIl8rO3pRZWXt/OQjqRxuMqL1yqnQpJ7de1KOCQmmuhK01C/vVI8nBaaHARrUDIM+f7dnpfY83GDLB2OlMquAKbSyJjWYYTXXXddO3fuXLv++usX0QPb29tL+wBpiCeHBid5Gm4yfrmnlPUhn25kJgOod3I3J0MHUUlulfxd7gx5FN9pr6pfc8PXy6LByn25DgBoxOqT2tx5r6JSvHyvN50HLD/JKt1P+fl3z/jy8y1YH1/tq3QxPStZ6NvBk9rY20y8ugOpdzBWT1b+nRxZ1AOvg+7zP4Faim6g/vDMB337YZrJsKwim3zc8bbRc5Qr5cz6ikdGNflYovQ6sND7BZ1x4ilFGfgWi6TH3r96eq7xy8dC6hbHOD13cHAwOLaJGJnkfbIHlikTr4e3bTW/pP4qvZMjOIFUXWefkw7QScJxweeQBHg5L1Tja3ICqK4aZ3oRBORfPLh+USfJQxo3KyeBy1V5e1k6LJN9yB0wzhfJHSbJKZ6e51uEeN/nX45BlEsVcaf/jFJ0B23ix/WYjovz58+3g4ODI+OFn3VDnp18Dq7I9dz7GXkcY/wnW8avO0+prFSm97tKF4ecALw/JJ+JJpronkmTg2BF6g3OvM5JsDJISdUEVv13YMMyuVKiFTpFDJw9e3bx9gIa3wkAV1ERukeDQgcSugFbTXbJSK5CHH2CdpnI6PC0nCjJf8qrkj9554q1T/KSu5wArAdXLR3IJ5CWym3t6KvEUh16RoHXaezE78aCGyTJ6GXdKgPfjXkZyzTm3QGUgJ4DEpZd6V4FstwQrkBP4sfzGgKlvFbxk4CW9xOSH16XjPhk/I3RiQpo+7hQGd0cV/iaVR0i5mMHo0ncOSBd8f6dQGBP54fqRECbDHGP6PCoAJbjhyaybVQf8u9RDxxDkn573RJQZB6JvC9XvFf9SH2FZRH4ujM2jffMa+zY723IOZD/fbzRM14f6nEPRI4Bxi7LJCvdS07NpC963p28FY9pjPb+lnRT7Zae5WGhdNy6cyvpKHUg9Unxw7xbW4688cguyr9HvflrCDivmm5V6un62PKG0o6d90/quYkmmuh00uQgWJF6xsJJ0pChXqXxFVY/hJD3vCw39KtyHTwNOQXcsHWjz6+58VoB+7GGAPkZMpBb678OcQzR0KOhT+O4CrWseNHvHt+rUg/EHZeSQ4DGYWVIM20C1Z5XpRuJn1V57oGToWera6vcHyovOUO8byag2drw4XskB0kVKJWDrGpLbz8Hw6ndewa/g/j0rEeVVLIcupbGLJXXA7l8Nt2rjPkkA3eMMN2YsTDpDEFwJYMEbsf0Da83x8HkaKjyJH9Jj1wOlUyG7nm9xwBv/13xpHx74K0nTwfyq5C3u7cF0w05IEXubNG1sZTKTXlQXm5H9IhOocT3Om1wtWmsk2CVeSuV0ct3oolOMx2nb5wkD6eFJgfBCREnf3nRh9KTKvDnxn8PhMjon80uvU/83Llzi4MJdR5Bz2nQM4ocfPB1hm5YkG8HyczLHQ1pRYDfVajn0ISfjNxEyfBpLYNaf0788dAyRhXoP0O93YipQITupXDRKm0y8AgwktFdycnr3pO3r2q5PBk5kKJUuFKcDNDKiEmyEy9jDcL5/NKKGVeoxjgiPJ2DR6ZzvpiuCgVPxjvzZX7a7qOxSHz5q+Yc+I8BUIkqp5pHiWhsUj/gVh5fteXzzgtlm3hUXltbW0fOOiHQ4P8EgFV+Bf55T+3h2yxaW34NoNeDxPrzvAOO2d53ve5V9FUK3+aYXgE+ju+UTW+cVj/iSrO/ujbx4GOSt6nf4ziiNBxXfdwe0nH2ldYubcup+n0ls9S23t9dh6lD3HJBSs7zqm96XVxHfb5lxMB8fmnbh0c1zGazxTlFY6NZnAf+p67Qmcm2a215PHY7gHqgVzWfP39+6doqDgzy16vPSdEqoMHtwDSGrEM9u2aiiSa699HkIFiRkoHIFR1P4xN0AivVNeZFY6I3AdA5sLu7266//vq2s7PT7nOf+ywOI9T9ZDD5bzdeuPeQhwQpjU/e7hjwCZ7hgnxeRrHLUDx5mKjLxfl2SjJUOXSeeNm9CZOGLs8b0LcOZZMBo8PZkoPAgSLLHhsq7CGovXpwpdVBQwLRLmsHw6q32lD6RvkKKDq5we+8V0QAozo6iGY+bpwrPQ3kRKs4CZKsUugs+fe2Z16VQ439Vv/Jv667se+GOHW+AqHJGcB77P8prfqBnJXaYqDyzpw5s+A96QevJ8DN+qkMgQV3BlS6LblyS4b6tT+n+gpQcQ858+RzQ1FKFagd6vettSOAPG158PzEczqbgvrmOu1jiTsIKEvNHUmGrBd1stJN6hadXkwrOY9xDoh8Lk96Rp7dQeDPidgn0pyUnAO9lXJvo2qBIb1y8uLFi+3g4KB7fz6ft8PDw6VyKFPNX+RVfFUypxw8skffcoRxDpTMtCDh9WQEkuaVixcvtq2trXbx4sXFf6ZLbbIKVXOjk9tQVV5V/imfMXn5d7JDUznO+0QT3ZNoCD9dKR5OC00OghVJq/QkGpDVwJsmFE8zJrR9SLk0werVhnqlIc8d8AP4VGYFANipGDEgB0Eyslk/GpY0VrmaQYMo1VH8ypDlZO8yHXIOVHJ050gln9TGqUw3aP0eVwMrULmKcct8fLXP6+K8iSqHQjIkKicBy23t0uGXyYjvrb4lR4bLO5XtPFIHXO/dYHVDXXyONQi9bIJylue/vS6pjdmmyUHgTgCRg6a0gkd91DOJn4o33VNe5Nl1jYehykkkPmTMky+vu3RpaHWXYEFghque/qwD4vPnzy8cW0rLk93ZtwioOEYlA93bhW3BtN5P3DHYm0s0VlZAU3JltINHJySZ8D7nQh/nlDejqeggoOyS84NzEFeBSRxTqkgBn9O8LSogzzLS9SRL5u91qiK/fH50B2A17vK6R+k4MS93HnmUQGtt6dBh8ehRXXQk6VnfXlTJiE5K74dqe9kpPl76WRhpXmutLSIIDg8Pl+aZVUBv0lFdZ5nV+DNUFuvv5VZz7hieq+tVHSaaaKKJEk0OgmPSqqBh3TJWTc/VlbETpE+2Tm6Q6puGbTXZ9fJK9ypguA6tM9Eet+xq4ndD0NO60VA5Mmh49pwgDmzXlcOQc8LLHft8+p8cIj19GQJfY9rfV6uOQ8fVt1XL8t89Z0n1OzmGnMYY/8mB4wZ2+p/K6TkjPP0Y/fDohmq8Sv8dyPT+V3kMGf3Oj/eB9J3yqORWORSqOjig4PPVmON18HGsJyfnq1cfdwj00le/x0YnVeCbupR4H5N3ojQfrDouJSeg66s7kfmsX/OyvY9KRkPjSKVXQ/2Q13qAPI0dST/uCQD5Ss4zE0000b2PJgfBiuQrkNXEyf9jJiOmW3fg93BM7RN0nhO/xwHBCWww/7TaxfsyLLhSm1ZNhurgRi/zrp5xSnsVk4HmxoqD8ARyKR+tqLW2HFIvh45WaBgeWcnTQyxFKVS9uudGnq8msl2SkTXG8eSOqhTF4r9XMbirayyn51DhM6x7MqQr/lxXqj6dHDbJoePlel2TfqU89J8h3qIKOPvvVJ6Hgqc6J8O9cgJI7/g2BqVTv0k8JmJYsc4iaG15LzP5dVCltJSrv44vyZ55DIFlPu/ySLLyMaZXHqMEEiDUJ4W7z+fLkSC9tEmHuWqdVsVT/XSNEROeJm05GKNfQ/NbGh9S1EKq95g5tLIBEnhX3dI9zQvVFgWW5W08n1+KIPBoDtd9tRVl7HWczS6djcGIJjpaXTc4DqlPt7YcueZjkZ7x7QXUgzNnziy29Yl4FsF8Pm87OzuLqEdvEx+7/HqPqjmM13pODdJxQX9VD147Tv4TTXSaKdlSV4OH00KTg2BFSka+X0///bpPBMngGyq/KnNjY2OxpSBtJ0hhv5UjwQ2MygBk+l6ooXdQll0ZoQz/pjHidU/AZowcRZIVeeXvXr6pfNXN688wz8PDw6V2UGiltohcuHBh6byItMqt57xela6K0lYIAr5qywfbY4jcIUAHTM95lYBvqld6Rr8TiJAOyUhkPfmcyqQhW4FjGrZJXmkbg75ZLq/TgeP9zHVLdWJ+KW/VWfuPW7uk8zKufVxwvfb6q02T45RjAe+5U8HLSCCXYN/LSdsQyK/Gw4sX7957zX6nUGqXbw9YVf2hAtp+jcDIZc3fPpakMlO9dX9zc7NduHBhsRfbz3rRsxzXWXe1b+Ug836h/BgKTpnRMeV18u0CjHzTdb6yUHV0+XifpIyHKI0Z6Rwcl0Vy0lROSHdMpe0uVXtL1u444DYOdxQQuOv/hQsX2t7e3uLZHpikbNI2DjmwVT7Bt497zNd5JHH7gsuOcz8dztRd8ba9vb14VnzKkUBnw1D9e/NNZQucNAio8kvjMtP7/OnXyWuq5+RUmGiiey9NDoIViQNub0Ifk8+6A3O65nsENzc32/b29tIkWoHfdJ/pkpHrBrRIBmECGrrPeiQQ3TsIzI3WRGOMaae0EprKHipPeSRDVXVS/bTHXddl1Jw5c6Ztb2+3ixcvLhk2AoHVyn8FnATSkkErI9/bS/Ulj16mGx8VkHSD0o355HBIZfb+e3n6psxU1yEgR/DT2vKeWeWt/bHep3p6mVaoU5ukNMlg58f7RAIwiTe2l8YMtiP3+Seg7w4C6oTGhqRXvhLsPNOx5MY/6+XAmrqu+xsbG0sRBNpbLaDAg1dVtn4zjb69HbzvJX1O7Z3kQnm4Q8jTkgh2qKP6nQ6j03fS2/l8vjg80iNO6DzwdnHngL+vPjlvKEOeL+FyTQA+OQgoJ2+TobHc83bHqwN0lz3lleYvl2OaQ70OLisC5coZwPalk0b8+QHD7FcsX3OP9332K1E634B5U/Yuo8rG8P6eAK7ynM/ni3F5Nrv7TQt6ngef7u/vL/gd4xzo2Xbkj/wMUer/Ps5V5TmfPg7qP+enau7v8dcre6KJJrrn0+QguEyUQOzlHmDdUEqgr6LKKCH1vOIJjGjSrtJXZflq6ElRJYO0EiViG3LC9Yl6CEQrnb4r0Kb8eaAaAaoMLTdwK0OG4JHGbSUXpUnOiCr008ut2i0Z9T0DjAbPmPteD5eBXx/DswNtX7E6Dq2r3+w3qc4JmOo3DXU3bj18vtKX1vIr5zjeOBCs+nrVZn7Nowdc/gQ3Drhaa0tbFqr+Xjl8CHrTKnhPp6pxNAEdzy/Jashwd5l7O6melBl/85vRMyzHeagcXxzjkh4lR6d4dmdJklE1hvT6ZeUY8DKSE4JpkgNuNls+qC+N0ySXSQKmSf/TGESnBeXt0QNyEFCfOZa7DKt5Tb95iKMf6Fjpa4pIcTlUOkenI9uK6fWfTic5CRiNN4bWGeOH5q2hcf+480ol97Fp0//j8jTRRNcCXQ5csQ4Pp4UmB8FlolWcA8cZgGVM6bO1tdW2t7eX3laQjMTKuE2TQzIy3AhRWgKDClAfh3ortOuQG3Bsiwq8J9CT5DgE2BJRhjwNneWRNxllCSSLKuO5B+59IK3kXgG+KoKiR2McBWMBQWXk9ORPQFSF/voqzyqDfUrba7cKwCWjmkT+qrx7oNb58nGD4K3XzulZf36ozccCvzFGeXKW+Ce1/SptPIbfsbJP9XEHTkrjJGef5K8wa+m661RyFojvlE7AuLXlE/NZfnLu+Cfp06rzRkrPSIeUpudsEA2N56kNxjojKI9eufqfdFO669tI+KrLalwjPy6PoToovTsw6NRO8un1LToDqmjBMX3ychnivTFb93tlrzpvDNGQDccyKzul98xEE01076TJQbAm9QBhSruO58oNAye9KkwOgc3NzXb27Nm2s7PTrrvuurazs7NIQyeCXi1WGerklQYGjQzdu3jx0uuQaGQrfwcqY8BcRWMnsXXkPGSIphXTsSA1GdqtHV15o6Gt+5IxV0HciOaeTQ8p9DZQW5KPFOLNPJKzS0DDn1ee1DHPP8kwGaM9Zw156RmZrCfrV600u567PCqjtzJk+WwP3LtuqB8xbw8nrtor8Zh03PVXob9sC+pbGj+0xYC65Kt5vhqr9HJiDgF/jp8EH2klnM/xOtvSw9+1dYDbBwiwGLbt+VbAs5oPvB0S8PR6Ue+SXnv+/lsy89fGEUBSPtTVHrDgM74Pns9X2wU4pvJ8Af73evSocg7wfnI+8CDCMU6CHkh3Z4pv6XCHgI97lfOBOki91NYXbhs4ODhYesYdBfP58usNq7ktOWt03ech9Uem8S0qSa9TvZkn9agnIz7bczxUbedpKr6GaMgWqfoT7/G5np3Zcwz42OF1qOaCVO6Yek800USXl1772te2//V//V/bn/zJn7THPvax7bbbbmtPecpTYtqf/dmfbbfffnv7nd/5nba/v98e+9jHtltuuaU9/elPX6nMyUFwAuRe2LGDf7rHa4l4XSFzu7u7bWdnZ8kxcJ/73Gdx0B1Pxte+vCHngDsBZFBov66IIJbP+fvDk5GXQhHdqCdfVVRGZRA4EWAwjwpQiXyrBuXmIJG8O1h3wOf1lTGlD0+IVl48TI48JMMkgQo3OhOAd778WZdbOulbb9BwuYr/yvD0NmWaXv9JslR7e711vTLmaGBTluQ18Zb4YN49QMt6OD8pQoehtrxHHj2fMYYezw/x6CR3EDioE8nR0Nrya1bdQaCxqCcDB09suwSYK2DnANjPFRDA8r4kp0HlLOpRD8BXfFa6431Z1xIA9rLUZufPn1/sqVedXD4EdGxXb2MHvgnYsN2Vh8uAIN11pCfLJP/enMmynCfJJMme/YtjbYq86D3r27MoI5efjxV0DrhzS7/Pnz/fDg4O2vnz548cQEh+/ZBKkc8plJP3bToGPQ3POpC8qCtedjV2p7ZNY1o1liagX0UGjbUdyO/Qc2Py7OXt5PN8Ndb18hsar1bheaKJTiONxQqXm4dV6c1vfnN7wQte0F772te2Jz/5ye31r399+8Iv/ML2vve9r33SJ33SkfS//uu/3p761Ke2V7ziFe1+97tfe9Ob3tS+5Eu+pP37f//v2+Me97jR5U4OghXJJ7dkGK1ikHueqzwnA0POgbNnz7bd3d2Fw4DRA26w0bD38oaME95LkQWz2aXtBQS3BKNelsshgTd27t5q8yryrwxPB4D6dmMzGVNDjg2vYzKOZMjRGJOBz/w8fDfVz40aOioqgyeBU35TDltbW0tGoQx8B+E9I5o6qXKTgZP0IjlB+Emy4aq8G+cyclN5LNNDaQlqKv2teKbO+X0ah2PqpvolPhKAJPkqua8SEhikw8u8LHc0+P+Kd44lzq9/j+nvLv8KdHn/cMA2hjjmJXkkvlgXrw/b0IHmUB9hOkYhVfpEAOl6nhx+6j+MvqBecJ5xRyu/HWxy7NC1nmHV00H/7yA4reBX/V7fSScq4zNd97ajXHnQZnIO+odtcP78+XZ4eLjkuOfzvTdJuBOFcnFHVBV1oLSc/123ff5qLW/n83Rpzk/Pusx7WxTSOF3lVY03yQ70/Hrj5ElR1T+q8fFqA6WJJppoHL3mNa9pz33uc9s3fMM3tNZau+2229pb3/rWdvvtt7dXvvKVR9LfdtttS/9f8YpXtF/4hV9ob3nLW1ZyEAxvMJtobbqcAzCNrtZyGOblnpAS9cocMrKH+HVDpGfM9agCJgn4j+VNdBJt7oZfFf7roCddH0O9ulVAx3+7odhzqlR1HstjDzSyzF45Y+QzlGaMcbnqs0MOlSGqgEdKx+/kLEzPJrB6uagXHj6W1u0TLNe/1x1X1+mj3sfXpdQ/15FpBVKHytO19O2/e9fG3BtLx2nHdcsbOw66XJNzYl2dPs64NZSX2yOkVeTtY0tyxniZLMMdFnQM9eb5iq6GLTXRRBOdLPUcrVfyswodHBy03/7t325Pe9rTlq4/7WlPa7/xG78xKo+LFy+2T3ziE+3+97//SmVPEQQnQEMT/tjVjV5apuc+TY8KqFbkCap7nuT/n73/j7V1q+r78bnO2Xufc6EXjFougqhoMWiwlQICUiqfVCBWY1tbf0Qr/qrVXKri/UOLpBENgdq0Bn9iaQxoFWuaaqUGW7Aq1miigvSHNtS01ovKDdEiV4Fz9t7nrO8f9/te57Xe+z3mM5+19zn37HuekaystZ5nPnOOOeaYY473mD+eBDh9TzGXN1czgSyDEfg0M6j/zm81k1jxXt1Ls0+95a7JsSBfXrfWtmcNCeyTbNJWiSrKrzI0O7Rer9vVq1c3cj8+Pt6sFFmtVltL+H3mg+WxfqmtWC/ny2eZuGxZxC0myreaBWLeaSZJ16eCQ75iIaX3eipd1Ve8nEpflAeXv1dU8UTenM+ptCMOr/j02Xz/Zjux//P1nFpB0FregpPKnQNKe0G8SgYpbVre7LPkLDP1w7QMvOJFVAVPqr7IfH0Fg64lu+117/HENpM89J/nE/Akfs/b5eY8+Hk3viqAvJBfX83EMplGZc7RIeo386zyqMZDv5fSS0bOM+/re2p1AMcRfrQlxrcbiPzg2rStwH9zBeCUnDm28TfHbB/rufKopz+sv9s0H4t6/Z7f0sP9/f12/fr1dunSpc1YyVVkqS/1xpuq7J6trvRtTqBiKm1vzEtpRoMlc4HNQgstVNODDz649V8rwZ3++I//uF27dq3dc889W9fvueee9sADDwyV9S/+xb9oH/zgB9sXfdEXzeJxCRCcgqbA6VRgIDmHFTlA0/kD+nDg0KDnh0NxINQA7stG075UEpdmixcHmqnu1TJ4X0qYBlg65HRSnXoDonjwpZFp9qFaEtsbQCk7/aeTVNHIoCzQ7++u9gModcYEX+fky31FDhIpI7Y976sNecgcv11Hq2WibGMPIlAmBKrJ6fHlq55fWhKt39RhPZccUm9X5cml+HqW8kltm/r7iNPFvubOcwqIeD1cr7lFgNeYxp1y5nN0dLRx9LVcncEFpvdZuxEH12WV6kR5iBLo9zNUWCcPEqXgjspQPZNNVF6u1749p6o3391O/qoyqHdToIb6wv6uazorhOBTcku2kQEW1s/7rGxCChQ4n3quqg/TJHn29CnpHW1/BdjStTTupLSpXhVvKSDAM314zsB6feMMIG0jUJrj4+NNnXjAY2VfOBamAIGDfvcRqDNse7V78hF41oPuSd+Yn+pbzfhXwUPdp47TFh8cHLTVarUJcDLo7uPHiI1KbanflH2y+/6blMbDXl49/Up5p+up7y200EI3j570pCdt/f/2b//29spXvrJM7/121E79xE/8RHvlK1/ZfuZnfqY97nGPm8XjEiDYgapIrN+rnM2KRhweDpoCgpwZckCj/CqHQYGEBHBHIurucNIhTY4q65HqPzUroN8CyT6IOniqBsMKrPiJ7L22qGREXUidukdeD3fCV6vVBqDR8ZYeXLt2bcs5Vz3YRnSiqlUE+nYHUM6hHD6fLdRz+s39zlPOHVcJJEBBeRIopeCTt4N/u05W/dQBYW9m2GU7BQycKnBUrZ5IOl/ZEG9zBQcYSErPEbzo3tHR0Ym3D0g3dHK5t1Pqb70BLtkrXyHicmN/EQlgXb16dZMHbUfKv+fEC6BVab1tPU1qF4IhllnpNdOkvN3u6hoBH4OMrbXNIYapfybg47OuDuDcNnlf1ndvzHN90f8UtHLy4K4HOyr7XwUAPNjSA2pV3/P8BeqZv89oCyz7CgICWwa/vC8nXRAR6HPm3/U49Vk+wzTeRxNfuq66uZz5qka3pSzTbaz3Pdq81m6sart06dLGVlUTFy4/v15Rz4dJMplKo9+pLZNO+Xg5p2xv5yVgsNAjjW4HvVb573nPe9pjHvOYzfW0eqC11j76oz+6Xbx48cRqgfe9730nVhU4/eRP/mT7mq/5mvZv/+2/bZ/92Z89m9flDIJbQDdDIaecK6a7lVSVV4G1m029gIPzOrVioAduVVYKhsylBBQ8X192ylkn/xDkVs5EBeQqGTkY9mBDL0+X2dS1xCf/e7pEo/pX8TmS30i779o/qnyTrCpQWQE0D8Z4sCcB3qSTU3UcvT/6TAXUnEYDPCNlTdncSi94n9fYn8ljWuUwQiOyrfrQaH9Kdqa1k7YhlTlic86yrqd5JvXFuXa9pzcJ4Hn5lb5U11mOr7jo0ZxxudJtr5dfq+xNemZk/Erkebpd86BBsh+n9Zlups812r8T9ca8hRZa6NbSYx7zmK1PFSA4ODhoz3jGM9rb3va2retve9vb2md+5meW+f/ET/xE+8qv/Mr2pje9qX3u537uTjwuKwjOmFLkthflHiUObtpWwL3nXFroM7ocIEUegfblsD74i+8qQu/PswyuUmD9dW8u9UDUiANBJ8WXzydHjvVI5TJNxetZEvlhG3L7gS855ZJSLgNVnRP/yZlbr9cnlqj7NobejEdyChNQ4Cyty5HltFafeu/PeVuk5eIOfnttoDzSEtzEC5+rdJgyYZtUNqQCerymfLhaIO0V93KSI+9p6MT77HzP8aS85qRj3R1EtHbjtasivmUlyY72y8tye6X/nt5l4jRlA7ycSgYj5PJUvpwdZjoHbj4D7HZCeuRbdFyXXG8qXa7q2uu3Sc/Jh645QGRe1J2kz72yU75ODt75W3LzlQF8xa1vMeCnAuXVdelrTw8rO1PVO60+qFZp9GTjfsXcgFjKe0461/XTljui51PlTNnbET6qfOf4Lj2btNBCC906uu+++9qXf/mXt2c+85ntuc99bnv961/f7r///vb1X//1rbXWXv7yl7c//MM/bD/6oz/aWnsoOPCSl7ykfc/3fE97znOes1l9cNddd7XHPvaxw+UuAYKZNAV83LkcGXSmBiku1bx48WI7ODhoe3t77dKlSyeCBQcHB21/f//EHlAHHizXAVECSD6QKz93EniPjqmW0SZHfETmlBU/LKciOi6SBYMpvO5BFH6z/NS2U+DP61KlSUQHj/rFvcIXLlxoh4eHJ8Ael5Nzq4GeWa/Xm/o7ePJtBJ6vZNZzaqrrXpYDtgS0k9Na6Z+XSzDJYI9kqzRasuugMgUTWD7/9/p/yqeSWwVQdK+nv9qCpOf29/dPgEEP7qS+6fmSN+932lOsfp4Ap8uPlFbxVE6tSPLm693UXvqtg/cSmOSSZeoDeXZdVfq0RDmB0ERuS5MNc9mPgOykt5SB17m11vb39zeBFdkV50N2k9srmA9tzFQ793SN/31cSrqatiOlj9tlLvFPck/XWJaPRandKSe/xvMxdI6AbynwAzXTtYp/9W/1jaT7bLu0ZD99RB4w9/vkwfUp2Q7214q8zf15/+8ySv27V97I+JwCHonvZMu9DNd/TztKPb1I46n3uV3LXWih25l6NvNW8jCXvviLv7j9yZ/8SfvO7/zO9t73vrc97WlPa295y1vax3/8x7fWWnvve9/b7r///k36f/kv/2U7Pj5uL33pS9tLX/rSzfWv+IqvaG984xuHy10CBGdMFZipaFRZBNb29vba5cuX297eXjs4ONgMwDywUAdP0VnrDaju2HiAgOCLg6sG/qkZ3PV6fWIWW3lNLdt3J97zrWb13ZGhA+SrLfR8xTvL1zUPJFTOCXlJQKMXcHC+EqCQM09ZMmjDtr906dLGYVRa6Y7XSfm4TrGtWY8k9941ytSBKGe8fJbSy60cMuabwKTv82U57sySUp9RUMDLrsCuO6dJT3pUgS0HSQoUMhhAHUlBnySzaum40nDVgLdX6uNVu/V0R/nK5riTf+3atc0hnpxtFV8Cx+mMEfHvup3KZ9DD6zYKUFIdk4ySXUjtk8pUWuXjNkIkGdC+pzyVl9sAyo765OU4T0kHquCA29wUGPC+xrIq+TAg4vJI5AECD8T42RbUQR7sSKCvAMH169fb4eHh5j+fp62pAHQvoHHx4sVN4C6lrQIAbk/SmMc+T/1gegZwWZc0odCjkbEljcXuu7htYF7eV3tlpv4+B9hX9r4a7/1aup/4Oi31xtiFFlro1tC9997b7r333njPQf8v/dIvnUmZS4DgFlFyPkWVoRfRMWEwQACOA3Na9s18WKYPRO6QJT68DpxF4+/kGKeBrxqEK+qB8ap+5J+ypLPrTiLrmeTT428OzUnv4JS/1TZygNhW1A3917MK8PjKAuXJwJN0y53UJOcpnfZ7VXCE965fv7510JU7WA5KpvqbO6vU2xQw8Tyqel67dm0TiHE+q+DAlF6RvNzKwac9uHDhodd8qSx/w0kKEPTsAOuQ0o/26WQXEj9Vng6e/NR33eMqD8nGgWQFXFPdae+m6tezTa4DqZ4jshxJ46sG+Jxk4wFED1LoN/Vbz+l6orm6nXTC9aP6sF69fCqA1xuHUxlVfdMqJQepaYtBukeATb49WFvJKNXF63+acdh9hyrQoLRT+aZ8Uh3m8JvKYF49vqbKGuF5dFwcLXOK5gYsbgYPCy200PmlJUBwk8gN65QjOZUXgW0CuqOOC2l0QKwcqtPS3OBARaeJcNOJIxDVtbOkBBSm7p9GPgSxci4FXlvbntlROs7SVcBzCrTp+pT8pgJEybl1YF6RO87pu6KUdxWYqvLqBbIIRCiDnhz4m+W6TUiO+WmdxNFnKoeb9U5bjJIcec8des6sUrd7vKcyK/4rUMq69MiBQE/+zleiFDjhPa9Pj/+K16n+7uNNtdy/sm+pbgmo9UBrr4+M2oUejbSFl+k67r+rFUt+rcc3V2X46qYqSJXsRNoSMFK/HvgdkftIHcXPyJgzxfOc/2dJc8aVs/J95vJzK8pdaKHblUbs0K3g4bzQEiA4JZ2Fs13lwX2dWubN8wb4ikM6cK31HS1RD/hzBmm0TuJBz/mSwkTJOaQjxXsJLPTqx7ok+XBWsXKaeuXQsZ5ykPRs5bBUwQOBdgdcU/Um6Fcavr9+tVptXonI/Khf0j0/0K4C2u4Y835v+TbTTQXSOKPm8kozpMpf5XM/bI//nv45P6k/Uze49DrpyZQj7MEEptPWj5R2f39/a6VArxy2hZfRC6zoWprJTDrNvJK+p8CHz67qrAEtxebhnCT1ndSmaQm8tzn5ctuUykvy9eBERT3QNgK+vP0coLZWL5+nnip4yCXpSpO2qlCeVZv26kK5e6CBclNbUkY+diTw0xsTe1SBYfZ3B/1ctUIdZUDLt72s1+utVxay7pK536vqwTbkmRu03RwX+Iz3E/U71YVt7zx4sINtlO67naWt9Net0qfo6VfKs7rGVyhWVAVCvOypdvH+6HlW5XmaKb+kR4mHkb6pa0tAYaGF7kxaAgSnoJ6D61QZ2jSwcMZAwQEdPiinXwEC/52cwOQkcdBIgMD3547KQ8+mdzxXcuHvNKCne6xbAmled99vTQeaebKdqsF/dMD0fEYGaHcIxSOBkz+b+OHhhQ7e5PClpfDSJZ5v4VtWfI+pA7BKhgwSpHZzxzQFGJQf9dLrn1aF0NnW8+ngrAQmPW86tP6cymK5krHz47xX9sGBkeRx4cKFdvny5RM6wcCi2wOCj6rsFDxIesfyBHJcT5mX5K2gBt9s4vz5mRB697s+3MPNZdleL69P0i21dVqJkGzQ1Eysy9yXh1dlJNvds53OgwNXB6VJNrqegmos2wPRSqMy5vDOvkCZ07YkHe2BJdVTANP7GvtqJQPml9J4ffxcAfWB1h4C1cfHx5tAQQo2clWX25vUVqmt07ik9tEYoPbh9o8KyHMMoo3UOCAZV/LxFWpevyl95ht2pvRWZbI/ut6n1Ubizeuv/z3+aJvSODzX/0s89GiKv5G8xYvrAPs6++hUmy200EKPTFoCBLeAHBzMIe4B99ncqVeVTRl18SVHwh11B2Wt5WWOGkTcKU6gXrO/iT86SNWMQ6KpvcB0NukITwH2lI+nH2nTyhnjNQchVRCAoHrKGXHHSYEBgrCDg4N2fHy8eXUZgwRK67PQvC6eUkBjSqZsix7o6qVrrXUdVgeslK3ruzuw/Hbw5XqUHHVP1wsKJKDsfHqA5cKFC5s3E7jseDgh+dT9CiQxjZdftYny5in5lKk/77P4bl8oD9ooAS4BjqOjoy1AkCgFApK90n1vS/+f9E95MbDLskdAftI13u/Vya+zHmmrTSL2a/33YJivxNKHAYIkq6oezqcHBjwYUa0SUVnSE69Xz+6zLyS5J5myfgSiPKRQ+qqDB6u6E8AmsFrxzN+0C6xvkqsHZr0fe1msJ2XlZ01UOp7GtRQsES8egKiAfK8cz9fbbmqVmutxb/z253RvBJj7c55u6lrKP+VHX2Dk+bnlLrTQeaHbIdj1cJc/h/pHyC90S2jEAHOQ9/+9yPXNpgr0zOHndukwI8GI1ubXb6rMkf/JYdlFbu6sjta54k/keslrfj3NiJ+GdjH6id8q7zk89BzlXpop+aU0CUQ5gPN85upulXZkdo/11m9eG5GTb1NKeY3yXPF3WpoC3nPS70opsDGXpsaWpFO367g0QqO89QIb1NEESj0985uypT0+R30G/p56xlc6JB57vO+qc9SdXkD1rHRpRL5z7t+u5O2/0EILLTSHlhUEt4DmDOZ09n1lAK9POeW+VzLN+KXZgOTYJefPl6EpMl7NzpBSNLtaBTA6sKWZkGop4K6OjEfTq99V/lWEfzStyucM7JSzmWaM0uyESDNfnC2U/vg2A2+vClTouzcbVLW/9wfqHGXkeSZn13nl8ls68VU5fDbJL828eXr2lQSmEtg6ODjY/OYrKfmp8vRtNe6Eu55VdWP7pXTkO82gUxbaElDZBvKi16OmN2d4u1PX2b7igb/TzKrrQW/2zK9XWzl4j3LwulTbI7w85kldZb3ctlfbxNxmcom+iHJLejoFclMfJH/cipLy9dlm5zeVmWzJqO31ctluDvS5goUrCFprW9sNRnRoCrSynaUr1NdqxZ7fZ169cSoFm9wGUOfX6xsrEY+Pj0/oUU/u3ubq9+yX1fOVDrgdpe2THeUKzLlBm9795Av02nq0rGSPPF8ft0b6aO/aqP+10ELngXp271bycF5oCRDcJPJl0XMM7RRoSMs5W9tetpic3AR0fHDk4Kw0cjDomLA87SXm8l2vvw9WDp74PHmi8+BONeudgE1aBp6WN/cc89QulAvvkedkiCrAkdKlrRjV8mjfH04dcXl6PZSv8uQ7uFtrW2dc+J72HiB13uVc+jL+ngOj+/6/0mfKjt/Mh04yn6EsvAzvS6lPEfgR9HjbiRfttU3bhNh+Fy5caJcuXYpyV/uk/pLahFtIegC417cq0MNyXL8EHsh/b2kzgR55T2CAYEd9RkCXgQV+PMBGIMI0yS4kvj2d902vowcK2N5Mk/KnbJSW/coBHMtN4M7HlWR3mUcF2nwMcfuiPKlPSfd8bHHZuTySTJI8E3l/clDN69yPL1nzfAGlYZ19lU01hvlZHD6WOsBP46jbO/UFXefhghXP5J3fHPt1tpB4lR0TD0dHR1sy8ufZTn7N6+0HFurgzLQ1iTJl/pQ/gwPr9brt7e1t2Yep85aq8T5dc1s2Mu5PlZ18joqXRFM8e38Z9YsWWmihRyYtAYJTkO/907UeVU55ipLTyWeaNFvF/B0gVY4eP3RE5Fw7fypL5fMAI3emlM73JXMw9sFzypEboTRIp3wrR9rz0PPeFrznfPYGa3cE0+/qOX2THzqC5MHbN/GaHC0eAKc0PMhQZxWwDHfkqlkf6YMHCfRs5fBRPjyErFohUIElAhTqsc/q+jvep/ZxE1Co/ErmLg8GVMSPnzOiAEECT9XqAZXHdlZ69e8KsFR6nOrHZ90m6X8VDHQ5pXr5CogewCTg0n/pM/Nmm1JGvoKgVwb5roIGnj91jcCE44ivAEj9mNfZJrKrLjvxybYQUf96fdLtjoCWSODN28DLd12t5JZWWjBA4XLv6R+frdqV910/rl/ffhuBPh4gcF5Zz2os8lUvFahO+s/AQQKm1TXlfe3atc25NCTazyQn51nXGRQgb6m/ejsoz2os8zbpjRX8TsEJBQgU+F6v15vAR88HSeB6ilzX5wQFqrzm8FDJqdf30vXT8L3QQgudT1oCBLcBTQUVRHOA8hxKg44HP3pR5p7Dl0iDfZpd6zl5iVc6dhVwIL+J0tLaRImX5JD1yhlp6yqfFPhIPDio6DlmqQwPLMlJTkDLKQEbpvXVDF5OlWeSs88UKT8HeYlX1p+ObKVzow6SO/AVOKhWFfnKD348cOH9zvkf/U6Op8uI9fO6zHmO/12/KoA6x6FNbeU6m8CW5+l2iHUgmHMQk/Jguzho6vHdc9h7oGtEJlV+lQw8/96y7x7vU2m8v1Rt6fKv+GFbj/LFsvRN/fRAAQ8n9Od7drbSNQZCOKOe6lb9r9rT5TFVb+c12VY+l9puRE/c5+A9vz5FPT/Ay9PvOb7LLtTzoW4FTenQEgBY6E6gKdt3q3g4L7QECG4T8kHNlx5rKR8dzTnOzhQY8DScwUmdygf0Cjho1ljkIMkBI3lMDoY7K1XZZx2pZ55zAhDkrbc0Ml3vBS5Gnfr0HAFnWmrs+dAx1gyl2o762KuL85CANO+N5lXlz++kJ+7w9/Tcv103KwezB9j8v/ft9PGyWzu53z+thqn4Svo8alOSfvB/cjzdyfdnkux7+pWCQZXuVPxN1bEH2l0nquu012mLk0Bgb2WGg7ueDZHdSHY0zf5OUdKXXrCTqxKYhwd/+HtEzt7nSFXArRoTEujlb+pqtVVlpJyKUvClF8gZte9KU4HBFIjzAOtUHdxuOvX6+QixjlwN475CVU769natghkVv1N1SP22p3ue9xxfrsdbT4eqZ8+an4UWWuiRQUuA4BTUi2q7IyiaMrzcJ6c933t7e21/f39zsI4HD+gwCfglpyqV72BDToSDJjqyFTnYYp0r56pa8qp0yRlMA1rPUXFg7gBV96r/DmTTYF85mxW/4s9nwX22RIBcZTj4YPtPOf26f3BwsKVH+l0FCdSuPJ+ATpvS8hDDxK++E3BYr9cn2p5pKAc6emkZNR1Jytr/cwaQ/0VsG1/q7jNdXLbv+l45j6ozAzZ8xaS/2tS3V1BmzJv1TECLjv1IQIn5+TPuZFcgjSCLbZH6nOyfAwPvY9XKES6RTu3aWv/1blMOM20tdTzZWg/4JDvh/Hpf8ef0jNJ4vamjzktlU8m36lYFidUfuC3C86FtohwrMMO+7TaD22i8bTz/kZlmtr2Pc2l7kuwP9YNj5AggruqdxouKpux7mmlnW7ieuY1Nsk16x6A/D7T1vKtxUGl9iwjrwW/d03YA789uU7w9Zd+Pj483nxTwqWQw2j7kNdnCyk+p0vfKnBrnR9OO0Ei9F1pooUceLQGCmUQjP8fwVgOAk8DG/v7+BiwoOMB3mzMQ4Pmm98I7SHaHnvnQmVdaOqSsDx2PKWCsvJNsHCD6dwKtfH7qgCEvz/NN9122UyDJf1fks1PVPb/GvdUJeNOhrgDihQsPHXpXHY6X5EynjGdHCLzqOTmPHtBI+VZg351IypPAhG3njjHz0XU6hPpP55HgwOXGQzh5wB/lqu/ebBxXXVBWDA7wo3YSWJaDzPqkfu7LkiVrHrLmOkEdS/2d5MDB+34Cbev1euOYV6CdQSbKRzJgnm6HqaeqY1oZQhvH/tQDn1Vbi1/yldL4ah0nBzIk9idPr7yT/WH7kY8eSGH6VB7tdNJztzXe57XPO9U/gRpd4wF7DgZJaXY4lefg0IOFPpZU/cGBJftcVTaDNCNtMXJN1z1w4+PYhQsXNkFe77OsswNz1lflSIbqlyyXhwm6TiQ58B7HEx87WnuojXUQonjyttR12nWdt5DsfZrUSHbMee+1Sc/X6+lmujeVvrpPn2qKUn29jRZa6JFAS8BrnJYAwSloapBorb/KIBEdT4I4Bgd6A2jlhFbG350IH2x7DokPlMlpJLnzyuuePgGAkYGK6fR7ZOAjIOm1WeJzDjm4TTy3tu2EVM5zmoGp2p/pOEvtwSbPj05k0nc5ic5LkpMDpwSofHbZHfCK5Px6fiyHeu3AwJ1m5iPSK+MS//rfm1lVmS4rtaX3fa7skC3wenD2jjqQ+m4PCCcQShl4XVNar5vbBgIwOupsL8mQdeLBe8qL9Ugg2e3YiK3WsxUwcHJZJHn7EumUlo580vkk76pfsg7Uj5SP81rVNwFKt+XiOwWtVTcPPjHYV/FDG8W0HgTr8Zrql+yAXvGaxjGVl2TZs3VV3Sq98us+HqVnvf9Uabw/uCwq/UjAmfJnmzK9B20Tn1XQIAUp/DBcleU8sPyqff2NFElnetRrw0Ruk7wenrbSnxE/aJS3VN+e37bQQgvdWbQECG5zOk30tnL6T1vG3MFxDiVHZcrhOm29KlDjZYwMzj3qBVumfveeF39TAMAsj85pAAEAAElEQVRXCczJg86Et787ae5Is0wH7IlPlsHnTksO4p23BCqmAKIDTwfqJAaheiAjOZOJN3e6HZQ5sEi/U516dXNygKo6Jqez9+3A2EFy+p3K2oUqh52BnySzqg1Po7PeV8gD00zpZWv9MwB0zYNGKU1Kz3tTgIfPpGAU+a1A5Sh5v6nq4Wm5omUUXO3C265E2aTxUTSle65bvn2np+9O3kd7RHubeErluh4nm83vpD9pRY5/V4GKh4tG7POu+U7V6+Gu+0ILLXT70BIgOAUlYz13xUDKbwRI8hqvp1k58kUHzZeh8rc7cv5M4sNnLjkbwBmDHnhprZ1Y7piCA71BLDnqyQlgvXr56PcocPQymNfUCoWKn+QUESD50nWWq/SckU4yZVlV3Unr9XozK6N21Uw+VyRoy0zlIHp7UV96sy69Jay8phUS1E1++5J3AoiqrRLIoW5PBTe0ZYjtwG09vp1C8uSMtNrdeXDw7O3NevZAmF/v9RVf2s/yVKavHEj9mcvs3Zn3tMpDM4tpWb3bG+/D3j98RjzJz+Xda2e2F22q24b1er3ZQlKNK0l/yU8FejxtkruWnusaZ+urdnKboL5EsOfBAf92+5X6edIlrw/7jdsMDzhRpswv2QDyNBUISXV0uaW8aM/d9lJnqrFDz6TtRZ5utVptHWDJT9qikepGmR0dHbXVavvMkFT31erkSiCXF8cvjgXsx8fHx21/f39j03megNtMbwfqmr79M8d/8341Ct5H0yltNfZW/WsuVePmQgs90qiybbeah/NCS4BgJlUg56yoAh4VL+k5gkR3PpTWQbwP2pyZkxNOJyzxQWcmOVrM02cFmDbVz+8lXlLHcwe9IgKC9L/Kv5cfn6va0dvJQbIDTToF7tzqOf5mkIYH3tGJr/gmeVo6JoeHhyfqoTJUHkFAAlZeN5Xp33SEnV/KxZ0m8kHncL2+sTeeAJb1TmA/geUEgJhefF+/fn3r/AYFB9h+XJat9LrGwIKvImAZHqhQfelQJ57JR6qf9wmm8wCAnH6VS74cjHs7EvhMgZakx7Q5ydGmDARyCI4l97RVxPW52kKQdJxtwfw80EEeBeAdBHpQRMAp2c60VJ12xPuMA+sEwr0+vbEqBUeSHjtVQaXEYwL9rnuVHjM/J9bN9Sm1dc+GMQ/KpRpfWG56qw23PVEPteWKedDmOFDmuSwjY53SSyf5piWXHfNLASzZuTRe8xoD0GpL9qUUGGWf8f8MDqTzZRIlcK7rLu+ezfL8qudoD3t6l/jwPCpK+S600EJ3Ni0BgltEU0Y33a9ApaepZtiYLwdfDcg+IEwBr6qMVIcEQL0+yeF1x/P69etbvIp6kX7Wa1SGzDc5bATdvcG0akdSkrM7TAkUeRoCwEp2dMrV7klfKoeEabwuDgI9ncrz8zToqHmdktx6QKbniFHeDgDoSFaAwNO6LnmgzR1zP4mfTngF4higkPxEmjkjH35wJctRu/TAYnJ0aVNSsFH1S3ITwCA4cbBG+bq8VQ71j29vIHmdE/hONsd1Rv8ZDFB7+sF63s/Yp3oBAr9GueubBzSyPAI3tw0JpDvYToCe7cAAhOSd+oY/w7JSWtaXsmZ7UoapPxPs87cTAwP8Ftjl/nOWMTU+JBBY2akKqFE2yZ4nOXl+zqun5eGxHtzz/uTjm/OtYOUU4FW9uMKBOsR8vO+63ZJeJ1vLYHNrD9lBX/Xl/SK1K/Nj0GFvb68dHR11JysSJb2f8jU8XRp3U7peGl2v/LTkY6QyKv2teFloofNGlb93q3k4LzR2xOlCt5ySYzma/lbx0HPYR/KeGpAqmrMMsCprDs0tb4qX1toJMDE6iJOS05n+6/k0Szcl8xGHiWCFzrn/Tv93MdhznJwKqPmnyreScZW/BwT8k8rtlZnk5I79lDyqMkf1bA6xndOSba9XejbVt/fx/HetU08vKnl6/r3rPZ74f86qp6k6OFVymuqTSc6jIMr5qnidO+aR714dpvSnZ4fm1vdmUQ/wjj7f2slxR98pACrqycXteo+m+uiIPUoB5qpeiSrfZFcfYVcf5jzQEhBYaKE7m5YVBLcZEWAnA50G8sphTYNnazdmpbw85lc5WVwizPRK49eqOlYgNs3WpFcYTjlzvFbNlPhzaWlvlX6uc6xvzriMgMVUdpKf+GVeFTjlrILIn63qwvL8nsuZuuPLUVmWZtrTKdVeV68by/K8Wc+kV/pOoN7zSTIgT6kdfWksl5A7+Kv4VLvq/d0izbju7++fyMP/u/6p3r06Una+fcX3KrOd3T64LUmfZG+SviWd52oJ5lXZqERsO86CprJpK6qATy9w4DbZ66x2URlp6b+3S+KN7ejBGq9btazcl/Wn+riOsy/3ggLOd2+lSwKhrmtp5QDlWwF915HKrrmepvS9fHs0Jy2f0YdbhnrjVgXA0yfpQrLLKo+2QXZOqwjIK1cLTtlM8ud14GqZtPqkClKnwGXSkZF26D1DPU38zymnR66TXv7UNb8/Ov4vtNBCj3xaAgQz6WYbSjperZ3cY+yOqDtp/jpEByIcpFmG7vnyRHdE6JT1nBHxp3Se71T9Wab4IK/kT8/5sunWtpc1e3rd9/y4rFpl0mn3uviSZq+L/54aqMlLBdTcAeE+VDnodNqlFz3AzCXMlZ5XDjTz8fTXrl1rh4eHJ+Sh9Fo6zyX5LjPfksFD+1R+ehWg8tBScd/Owq0G/k57d2wr8iCMynUAqTagfnm+qa9q+WtrDy2vvXbt2lY/T0vwpQO8xsPJfOsA5ct6i18HIqlfrdfrzTLutP2lki2JQQuC/arvqCzKweuhNnKQw7R6XnWmXNj+5Lty9tN1Bz6uaxVgIZhxmyR58/m0jcPBM+/pGb1bvtc2KtftDOWXXscrGbhuU6c8CJwAsNeHuuZy9JVKnnci2vBKb6vnkz0lVbqR8iNA93Elta0+OkNF9U/l00b58nyOG8pjyvbR1ql8HUjbWtscJMh+TP+jAv/sg65LtGt7e3uba621rdcY8uwKXUt9oKfzaVz3dFM+IcehpDuVTar0tFderw49vad+pSDpQgs9Eqga1241D+eFlgDBKSkN7nPJZ1TpcCVHg44m0/PgM3fI+JsOJx3jyul3cJAcujQA9mTBe3TeOVilQATrlwZCOvgEQy6PivhMRXRIPS3bhc6T3/O8+Ay/q3uV4yqwxOAAzwAgX3zewVzl4PJ5dywIxjxvAZBUn2vXrm0dUuUBLuc5BRCSU01dkKxTf3XQxrpQ/13nNVvmARnKi3mnQ7C0KoD8O+DxmVJ9tGeeMkp103U61lXArhcsYN+/fv365nBKAo5kH9zJdsBKB5rPuF5WfVKBLa2mWK/XJ9qSAROflU+AlvVSGd7PqAepzdkeys8PcmOwhitEvK2ZD9uG5RMcug65vFUf5SMQl4Cpg3zKi3rvAWqvu3SR+sSgM8kBcJKJAmdJX/mMt4X/97HE7YaTB5A9zyQ7lsX68beP15SJP+fy8zZkfpUfwHFXfoDeNEDd8HL1LGWhduBZFgwuejtRTj4J4oEDlzX7F4N6lJcHByqZ0Waxrj2ALkq+Tm/8Vjr3UyoiD55/spdTPPYojR3JD1hooYXuHFoCBDNp1GCelXGtgK1fq2Zs0vM+sKX8k0PlTsIIv6MDVEXujCe+3DHsDbzVgLsLX15+L1jAMkkELaPletnkR/WnM+964c96fXoy8fqme34tfYvX1k6+zs5BanJwe843/+vDIFFyAB0YejoHHqkcOrbVyp8EEFi+AxWm1SwdAVkld5dV+k4rX8in65fLIQExd7a9TpSnaKTPVjaAsvHAnQdRp+xWAirk1fNPfaYCYw6sdW2k3ROQIojzfuyzpBVQqvQ7BaxZjxQocFszFSDw9kw6U7U7+SS/bht7ciVN2Tun1Dec72Qjq7Fxyg4k8hUS/n/uuFaNF16vJN+q3JH6ss5OHmx1facOsm8kflJwONUvXac9TNTz85JtHgk+zElb2dqUxvVxrp4stNBCdw4tAYKZlAZ9XSf1Bo1q9m5XSo5/lSbxNmcA2oU3OrjVjHlvCXCPpzTw9ZxEphktK5E7gEn2c/L3+iencSpPBzk3k6pAQ4+mHDQCE32Oj4/jigHno+ItXXeAJuBSzaBRh/1ZvjaS5DP7lTPWAxAVSCMo4NYSb4sekB2h9GwCV6OgxmmKn6rfVver/y4b9TUCVw/gpOXPaaUTAYTbgJExwYFwr63IcwJrXoan6YFH5937Ie97YCD1S5/9ZpnS2wpcUh5TgYRUfmWTko2dAn+VnPR8+j1lD10v/Z73O//u9UnPz8fcqq/u0nerIIKD8WTDqrKTLnk+6XrVjymf04yLu/pAVZ+/WeWeFehfAgcLPRJprg90s3g4L7QECM6IRgYfn1U5Tb4aoFPEv3Lc0uBLZyw5Wj640rnuBTmYjvn5km/OKiVnho65nlH+ngedbAJO5Z32KFdyIVX1FG+9/5RbD/R7/Uf0iWl8yW/VllN1dl1IQGkqOOAzkEpbPeNLQ9OspC9bTrqfgge65vvxKW/KhkvjKQttgRBV/S7Vy2c6E5hM18gr7yuva9eutaOjow3PWqbO7STUqbQtiPmTD61W0P3qkxxx/U80NTjqPvtukkWqR7Idqf+pfloOL3lx+b/Xy4MC5MdnOqlr4smX3rvOcam96yTzqQKslSwJ2Hx1B+tK4KxtSR5AYT1VF26Dc31SOTr/g1sgxI/Xu+KVddU96TbtOtOlYIL3+annks2mTqieI4C4Csz42MDffgZPWhrvaXo64f1ceaY0fq0nL7afXikp3VC/6p1zofas7Gn1W23Pswjchid59FYljlJliyo7kZ5PlJ6tAjsVjeiep+vpz+0ArBZaaKFbS0uAYCZVoMiJAFbkRr5n9HuDMfNLjr07uR4wIP8ELdW+Sq8DHTN3YJXGnXHllerlgIOzoh5ocEfZ+fN74oVOJGeId6EE6pJsdT2Rl58csCkA6ml51oCDllRuBfx99jvlI1Dh9yrd7jk8vg+Z/EmfdZAh77OuvUCB0lIfEhig7qXZedZdDqkDHa+n6kU9JrCqZmIrkMLyWmtbhz8qv/39/a2DwhJw1m8Hi5KRB+Uq4Or/XQ9YLkGVE4Ge6kjg6oFGfqcZe8nHQT/zE2jnt5flS/FVTpKd21HKxXU0AaoE6CuZut2sQJCDt2r84NswvF8RhCm9ByQdcFUAnx/VnasJDg8Pt54nuT6noGE6J4T3aXt6QYj03+1cAoLiaaQ/JNuc+hVl4QGUaiUG8+c2NrafQHmSNQOEXv+kb9QxBYQODg429qi1diIYJNlxvCF/lFM19nF8UF2lkzqwkDJJNAf8Vn4Y71dBAt6v8nbb3Cuv4rknL+e34mM07UILLfTIpSVAcBPIVwpUTooPIHMHKeXX21KQgF1yTFIZKTiQ6pGed+DswDGBl5SHg8kRB07X/PVn/po5pk0yTEEeznK481INzHNWi/RWZvRknvhyUFU5J+laTxdTQID/KweGOpCAQwo4EETL+aNO+SqVqg3c8UozSOLdV54wP/1XgEAgh3m6M8/7eo4z/GwvluXBMO8HdMaTrBI/7Aesf5JhAkTJaZ1yWCnbURvHlUGed8/BJqV+KRl5kMZBccrXQZvq4wfDpgAB77vuO3h3Obt8E5Cs5JFAeWsnt0Il+fhHustnVHfvQ72yeS0dfssAGEltw/Gz0lOuKnP76+CrauukBwm4efvwf2q7NCa3lsdCt1WSkx9omfpm0jfWv+pHbn/5jMuJ131liO4rQCGe0wGmop4tr8ZW9UG1NZ+jbnn+qfwpG+b/pwD0iK71yHWK5fZ0Kj0zRc7rEhxY6JFGvfHyVvJwXmgJEJwhjQLBOTQK6Nxhqgb529Xo9wINUx0qgY9qQK4GzbmDogc6dpHtiIMxl5cEcLzMXrlnwdOuzlBKm8CGyEHkHKr6EGclfWm10ujaaWTVAyAsqwcoqnzTJ5UzBXScKiA0QqNpd+mHvbQVwOk9k4J0qQ0SUE38uJ3pfRIlOzXH4ffgBVeNub55sCDVvaIEXDww4DKYWyeW1au3qFpJla6xD8zR7bN2+EbGux6loIjTyLg6+vyIrJJezSkrlTtVTqK0WqI3SeF53w7O/e3qwy200EKPLFoCBGdEo8GBkZkE/U4gn7NfadaLICfd61Hao0pnOTmyPsPBdCNy8GemnkvAJuWXynMQlOSRnMQ0O59+K62o2vrAdO5UTzkrXrb++9kD+tBJ5wzcFHD0Vw+6nBPPDg52peSIqQ6aMeeHPFZbbERKl9qf2wC8LH8mAS1eowxSoIH9xtur2ovrZbF/sz11NoG3nXTEgyzMW7yJP7a38+GrMNx2jJLkyrMUKkrAlts99O1Lj8lT6nveH5wHycJfValrKUBAOfoycS635is0KXe/5nbY6+zgh3qX7qd+MhXocH0Qj5wxZj3Jd6UvSXfS6i2nFPBJ37SRSW4uz8p2pT6Z5FONk/zN55Ptd/vgZaTyKvmkMTrxpbLcHk3JII195I82y+3DlJ1j+3mwJ+kNy5qqq29vcXuQSPdT+1U2b9QW9vJMeSReSKkOPV6SbVhooUcSjWCMW8HDeaElQLADySiPBAUIHHoDSzUAsBw5+AoO+DuouQSbacmzl83/PVBQOXQpIp/klYBla9t7HavOmxwVpffZqeRw0MGuHB/eE19paWrVVr2ZquScebBgZBaD9SE49PaWzjC96kwA3HMC5Pw7EBTvlKHLPgGYKUcnXXPQ67op0qFq169f3+oDaY9y0g+CbII5BQiko3Im+bxk4SsKvJ+wHye9FR9ayu36RFtAQKrfvnyXjrme56F8CUx6G7LPcCm5y9HlVq3s6NkJtqvakbKjDNi2q9WNIAD1hQekSS7JBpJXPs+tGi4LL8uXNZPUzsfHx1s6pPbSb/1nkJaH+nnwdgrwifd033knsQ5erxRAFh8eIFC9PDjCMpK9Z59cr9db8nf5pmfZD1Ob0BaSV9lU1tH7M8upxqM0JrrMUx5sb6fUJ51P55F2vkepXXr+iPNeAX0PxLIvtpbPj2DZVVDebXWqA/WWsmEwQAFg9UsfW9I4U8nDdamXllSlrcZO/+32bCTvEZrqZwsttNCdQUuA4BYTB7YEKqcGTjrHvndWA6MAE51Ezs5xYGXZdPBJBPGkyklJeSQ5sF69QagaXHtlpaX27mA7iGZ5BHTORwoMVUGDEeA/d4mjO0sMEDjvDlRZ157M5ZAnR5POH9O688LvXiDC2yDpA/lhGrU/T+4Xj54/+eDsqusKAY6ed0eSgJMydyedZSX5+Inb1SGTDA7I0Wb/ljwIKknKT23pATPXGz4vHnjQY3JUV6vtA0ZTOzrAdLuR+q2T2z4PEKzX662DB6s+QP1xna76f9WnqyCBDh8kIOEebbVZtYKAoLAHihL5GNDaSRvvIKcHjtL4IBl5gMDrm+RKW0bZJSDK/uDA2p/p2Ro+VwFN140ExCoQlcajFCBw+8nvnj30Mbc3doyMwRUITXKsgGpr0+Mt7VdK70GA5APRZqvPetC2Z2vVp7hyh/1slCq7NvJcL63bQz5TtQV104NoLpcpvqrVZAsttNCdSUuAYAdKztRZUxog+T85U1PPjax4GI1q70KnjWr3nk/Bjt6SR6Uh6OmV607KyCA/Rb1yK3IH3nWh58T1yu0BDk+/C9+7PJPyIBGwMGCQHHISnUj/qJz1envpeJo9ndIZpqO9oCxc7uxnKf8px515VuDcgbHLNJXpv6fqf7Ns4wiQ8fv+3JSNq+orSgEzL6uSvS+7b217X/RUICPx2tMVB2IMYvlzPf6dVwcVzo8HOrz8ZG9SmSlgkfpRRVP9jIBzJP1cqoCky0/35gCzqg9XPMyxv7vY6grM8v7I+KR7LoPUn72dKpswZ4vFKNjfVSdOaxtPO44utNCdSj2/8FbycF5oCRDsQHMHtlFy4MJZE86a8Rq/uczcZ1yqWe8ELnymI82w+DO7UgXmkpM8ktcUEGCdXd66z3d765rSj/AwQildxa+Is7tcMcC6+G/lS2eSDraX4VQFUeY6nXTo5j5TXXf9JRgR37rvM1fsUz5jRXkxbVrmzHz0rKiabZ5ykr1spktbZXozRZydpL1wkOg2J/FU1cO/r127Fpftp/w8eMJZb/9W/dzOsV/Q3k0FUqgbtKNsU+otbSH3s6vOqX5aeeJbDNgubmN5zYGsnvHVMsmWu3xYj97vpLMe4HAwRv7Je2UPE5is+kIV/Eg0ElhjHxB/nJWmTHyLA8d3HyfTdQ+YVDz77ypI5J/Wps9pSAEhf3ZXx5krk9hnkj1MdrtapVfVJdVL/7UqoAq4cfWAvwLRy5gap/yZOaC9sqVzfYfT+l2uCz6WLoGIhRa6s+nsj90/Bf3UT/1Ue/GLX9w++qM/uq1Wq/aud71r8pk3vvGNJ5yV1WrVrly5sknzCZ/wCTHNS1/60p34TNFrzgolw+oDYQ+wO/jXMlpfWstzCPb29jYfnlHgjmNaRkbwwYFWn6n9jvpfbVGoKO2l9P/VvYqSQ5CeSSDDZevgnA5icsi9/J6j7f8pO5eLytfy8oODg6323t/fP3H2RGp3d6CSs+l10H/RlEOf+lkKVnh7pEBNkrH3EfYjLWk+PDzcfI6OjjZ1Zh7qH5If5el9yHWDPHr/8wPr1Hbe11wG7IPqd6rP0dHR5iOgSQffgaT3Z+X14Q9/uH3oQx9qH/rQh9qVK1c2eR4eHm6VRTBb6YvrJOUoW0UZp60TSnNwcND29/dPfKTn/J/SeV9m3yWvXi77jtsBt6/+m2BI8jk8PGxXr17dyPiDH/zg5nP16tUTeilZ69vlnvRWY4HkIZno96VLl9qlS5fa5cuXo7z4jL+qk7pGfq9cudKuXLmyqdeHPvSh9uEPf7hduXKlXb16tV29enVLR1UfbrFhu6TgXFqFkcZDtztuW/id7FBqX+owz+ngdR8PEgD1cdMDQ27baY/9fmoT2TKmJfnzvQ/HpwSQe8SgQOpPkmFadcV+qP97e3snAnSenvylsT3JmPaP9pT2Lm2dnJJBL6DTG9/8vo8T1bMp/3TPKfWX3vNprGZepwkYvOY1r2mr1aq97GUv28r/la98ZXvCE57Q7rrrrvaCF7yg/fZv//bOZSy00EJnS7fVCoIPfvCD7XnPe177wi/8wva1X/u1w8895jGPae9+97u3rl2+fHnz+zd+4ze2BoL/8T/+R3vhC1/YvvALv/D0TBfksxGkNOgRTHC2TB86s1WggM5MaycBnC+LZRp3TMQXwYeuVTQC3NP1VEYKDvTymSqPM8BppQYHQD/cy4MDIv/fCwoofWsn9wr26pXAqHjyGXJ3wNx50XWvC/Uv8e6z2ZSL5+15Vc5JL9BAh8nT9fjwA/rYbuwT7tRSrqwv24NnebD/Su7qN97GXEWQVhQkuXOWlvVxkOP6pnuUM2fLaAMFGPWcr5ZIM9TeHkzH9N5XyafP8rP91usbZwc4KPe2XK0eOpzQAyIq10nPOVipPtIN123Wi+Vdu3atHR4etuvXr7ejo6MtYELw4isIevaPKwU4PlAekqNf5zPJ8V+tVltvu/C92dQr8ay0169f3zrjgTpCIJT6tevxFDmwSnrIOqWAkMtA+uZtqv5JcJsC2N5O3obkL41bLqcE2Cpgn2xI4iHlx3Zy/p1Hyl/kQTa3se6jtNY2b8OhLeSz3rdTcFt5pYCI6sb+5UEXBQNkBxVo8fMxJIMeVfJN8qr01MfAXp8ZKb9HafxNPLW2/XaXs6Tf+I3faK9//evbX/7Lf3nr+j/7Z/+sffd3f3d74xvf2D75kz+5vepVr2ovfOEL27vf/e529913nykPCy3U2u4rpc6ah/NCt1WA4Mu//Mtba6393//7f2c9t1qt2uMf//jy/l/8i39x6/8//af/tH3SJ31S+6zP+qzZPO5KHJR7aejEuFOYIsI+2Pphbb0ARRVhbi0fZjWl2MlxGR3weoN0LziQ8k+OfBrEU7CAMh9dCbELJQeV3+KPMnRA5gEB8k+5pFUUlcPd++28k8dEvDfqBPUCB04OMHxW7eLFi1uA3h10B1ZeTwb4mJ4HspEPOvCuY5VcWBZBdFVfb8vkbOo69V9gkDwwEObgyfNKeqBrfggeZUyg623PdqCTKuDJIBhtYLVSoKeTSa8cnCSA4vbA86GMCUAUIPCT/CvgSf49QJu2lfHtNG77HWClAIEHAVxXPECgejHIwUB2omrMSjyRD2+/BLoqm+N64M8nuVR9noEUtn81PumZZGc9T/b3VBcGa9ReLMv7ZBVscP4YdPKgRsWL5NKTY9reSHLby2c9iDNl973OrFslBw8m+FaEqozkG82lqfGOdqSXfgrgj9KIX+Y87kp//ud/3r7sy76s/at/9a/aq171qi0eXvva17ZXvOIV7Qu+4Ataa639yI/8SLvnnnvam970pvZ1X/d1O5e50EILnQ3dVlsMdqU///M/bx//8R/fPvZjP7Z93ud9Xvut3/qtMu3h4WH7sR/7sfbVX/3VpzJ8U+SD5EjkSo6AO5BpOWEvj0QOVCrH7SyoF4AQ3UzwLXIAJzpPETynnnPK+1MOH9MnJzY91wvipGsp/WhwYBeijvusVHLaq6W3U2VUnxRsSmnm1rXHe6pHer93L2+mqWZIKz1x/lQ3BrC4lDtt3XCgXsl8ikbaxgOqCZSkvuCy5rJl2mcPAFTtl3gXkbckn/Rx8vZyHU+Bpuq/0o9QAoc9wD5F1bM9sDonX/2u5Fn16ylKfS/97tle75Op380Zy1Ifd0pyqYIDPXn0VodM6exoPlW+5HvE3o70ydNQr52S7bzd6DT+0ktf+tL2uZ/7ue2zP/uzt67/3u/9XnvggQfai170os21S5cutc/6rM9qv/qrv7pzeQsttNDZ0W21gmAXeupTn9re+MY3tk/7tE9rDz74YPue7/me9rznPa/91//6X9tTnvKUE+n//b//9+1P//RP21d+5Vd289XeStGDDz64+V0teZszmCVar2+8H1t5yZnmEuY5QM5588He8xiNTk85GT4Dr3x7sxYOTrz85Fj4sktFx6tZCjm7kiOXPFIe5JOzLpXsRxwAOoOVI8ByvB6JD11XfSon19tcz/AeZ3l9VsPbm3pYyWAOqNuFvO3YZzirSt1L+/d9Zlr3Ep8EvcyHTrNkmHQ4LRmuyHVMz3CGmvf4jOtvCtDo+mp14/WEWiFBvqpluJU+X7hwYWv7gsiX2TMvb4sEQqqPyk+y7K2m8hlu9i2tCNAz4v3w8HBjp5lOe5s5O+mrBypg7v2wAqit3djS4vLmtQpQ8p4HkVLASfe4/WC9Xm/JKY1Bvp2nN7449cC+t+UUqGM/pH2vyuqB9ST3tH/d+XM+1bc4/vhzDELxWlVmD8C5XfBxmHZBv2lHW2tbW20or2S7mS6t8PKAi+rmh36m5xOxX6zXD21RunbtWtvf39/0v6tXr3bH3BGqZOx5Jj2byiPZ5l6aKt3c+k3xWMnsz/7sz7b8YZ174vRv/s2/ae985zvbb/zGb5y498ADD7TWWrvnnnu2rt9zzz3t93//98crsdBCM2huUPVm8XBe6GELEPz4j//41jKin/u5n2vPf/7zZ+fznOc8pz3nOc/Z/H/e857X/upf/avt+77v+9r3fu/3nkj/wz/8w+1zPudz2hOe8IRuvq95zWvad3zHd5y4PgXsUjoHWVVaOqUcnLlU2pc6ajAkuWFPg7k7QkzHpcziywf1Sh4egJiiHsgecQB1TTJimnRgHNuAzjHBcZKLByKcppZVTtUvgQPP2x1Kzo7w5HgHS5UTJ3n5UvPKoZbjKrmOBEg8H/53gEYnPTn66T/5SYegkVcHO5Kh+OCBdeSVjq3kKqdZ9VCatATYy+d3tczYQT51XM9TfrIbDBwQiLA+OhQsBesUJEkBkhQIcdug3yqD1/0QMcnWgTT1gTPprFOyb36QnO55AFBl81wJykcBALabltcrCKBAAXVKe5s9wJA+bGdfJdCbsU5A1YnypT7oHnUrraBhEIf18PHL6+MztpVNS2NRatP0m88keY6ArDSrzLavxkU/GC/ZQI4pFQD3QLiDeOpNytvzcxubAo/ky695O3H8ZL/tAdnE34ivxEA16yBKgYs0MXPhwoXNAb6t3QjotdbalStXNv1shNJ4k/jp6Rptx1Q5Kb+ePKo0PZ6dd69jKquiT/3UT936/+3f/u3tla985da197znPe2bvumb2lvf+tat88CcEg9zAx0LLbTQzaGHLUDw+Z//+e3Zz3725v8Tn/jEM8n3woUL7VnPelb73d/93RP3fv/3f7/9/M//fPupn/qpyXxe/vKXt/vuu2/z/8EHH2xPetKTIkgWufEeNbit3TCMcg7koB4fH2+i4gQldM5TPs6XA3wHIErnA7s7FCPGW2kINJKDTnInaSrvauBk2X7YoOcvXpiuB3pHl9mOUNVOPce4cgh1zYMfvOerLOiUE0BQR3o67M5lxd+UE+U6l/rQqM75smzuyVZbqyz95sGC1J1eGa3dmLHiLDx5diDK8gkeHGD5bLPLIq16IIAlyNPbBEgEccxfcmD7J33yNlNaX4WhMwR4LW2fUrlpX7DrRrW6QPJn3ZJOtNa3LxVIlD3WOQ5HR0ebt+SwPgR2AtaiBGZTu6xWq83Bf37wKHlMNoD6ofYlHwm4JkDLtuF3knklR9cPldUDjqktqmtpHBmxFQlMuXx7YJeBgqlyvA+llTj+8ZUrU3VOdWjtZJDAda8Ciuxr3u85TlQ2MgFT51OyoC3zfpEmGtJ4pLahXdakyt7e3sYO0s6fBVVA3X9P+YA+doykm+Jn9JmUvsqD+vM7v/M7W/56Wj3wjne8o73vfe9rz3jGMzbXrl271n75l3+5ff/3f//mUPEHHnigfczHfMwmzfve974TqwoWWuisaApf3Coezgs9bAGCu++++6acVLper9u73vWu9mmf9mkn7r3hDW9oj3vc49rnfu7nTuZTLZu6meTGmIP4aSkNtun6raTT1ssdUTke7lyMOo1nydsUnVbuPf5S4OgsiPp5GmdmF+o5W97W6ZP48/zY79wp4v2KHw+s+ExlCpg50BOQrnjVNx3rqQ/r7yAlydeBSKVPVTtX8ndgz4BN1Vbs2718CRL8egK1PR1lO3OZt8ByNUPvch+lCqAlkO3pnW+vQwoG7OokzbGpp7k/Uk7qP7w2Wr8pPiq5n8a+VXbHgzcjdvw0tnZERnPznhoXEjFIv+u467bDV6fdCjqrcqaCbw83wLj77rvbYx7zmG6av/E3/kb77//9v29d+6qv+qr21Kc+tX3rt35r+8RP/MT2+Mc/vr3tbW9rT3/601trD50P9va3v71913d9103jfaGFFhqn2+oMgv/3//5fu//++9sf/dEftdbaJsr4+Mc/fvOWgpe85CXtiU98YnvNa17TWmvtO77jO9pznvOc9pSnPKU9+OCD7Xu/93vbu971rvYDP/ADW3lfv369veENb2hf8RVfsZmh2ZVGDPQcI54GBHcWSHKGfUlnStfa9qxhj780m5HSVLNQVf58xpdUn9ZZTbOKPmuYyFcOOHCr6uIzOvo/Z3VB5chWbe1pHVQKjFa8pf8JNLP8FGjhPeet4tl57cmXoHxKn9m+vmLAD8BLYDI5/1pa7bxQzny/O+Xm8kuAVbym5ygnbiFywOBgX7ykQwmTTq5Wq623GfgJ+a6D1IG0vJ3ypLxVF/HBYIbzQzm5DA8ODra2iqT+Lfk5qCZ/Kr+aKXfivfV6vXl3+tWrVzfnDbAd3LZ5u5JX8SXiqzZXq9WJLS7Ol5fhwQx/20DaYsC2SUu2+fpOpk9Bmp7svR5VgKayVT27UT0/AtSqYNHIeCRdok6y7dOs+NSqOd/yUT3ntnI0/0S0MSkdA+4aY/is/3ZdSDzr27c/VfwxTRorR3yQkbRebvqfbHxvvOqN51X5vbbqXe8FFZj3aQI+c569++6729Oe9rSta49+9KPbR33UR22uv+xlL2uvfvWr21Oe8pT2lKc8pb361a9uj3rUo9qXfumXzuJxoYUWujl0WwUI3vzmN7ev+qqv2vz/ki/5ktba9h6n+++/f2ug+tM//dP2D//hP2wPPPBAe+xjH9ue/vSnt1/+5V9un/EZn7GV98///M+3+++/v331V3/1TeM/Ob8j5GBMToIfDpUcZDpzdEJ9P6sfqpb4Y2CgChAkR0b5uhPsy6U9T16rBvce8Fa9VEe9c1m8pMGzGsh9CWICLWyDlMdUe486Hn4/BQQcLCpdAiKVM866UCfo9PpzDvq8XpWcE6j0OiWAKuL+8mrPNl+N52mcl+R4apl7WoIvmXN/P6kHCit5MBDAPFR2ArTMy/VB9yrw5/orHiQzBc1YD8pXYD057Glbh2Ra2RLlraXALFOfS5culQGCVC+mIY+Si8uVQNoBvpZ7X7/+0EFn165da1euXNlsNfB28bpRNgTc5M9tGO85Ue5pJYPqpGAG6+W2JoEt1w2lk05wGwrbL63cqIJNqT69ulbtTMCa8qkCC8keMn2SjfdttZnu8/BNP4TQ+fP89Dy/03g4ApadPABQgdOkE6wnz7fx+/qtfpzOAXH9Yrul8z9S+mQLe/2P22zor/DjtuG05PJO9/33iM+Q+OzpsFNln6bqvGtwYJS+5Vu+pX34wx9u9957b3v/+9/fnv3sZ7e3vvWtN2Vl8UILtbb7hORZ83BeaLU+T9w+jPTggw+2xz72se2TPumTNs50cuToCLujwP2Int5nOi9evNj29/fbX/gLf6Hddddd7dGPfnS766672sHBQbvrrrva3t5eu3z5ctvb22v7+/ttb29v62Aw/SZYam3bkaRjo5O49VsHbhHs+GDrexLdmeNgrH2waV+uHCM9zzTc/ypyoCgngiCDlK5xtllpvA1E+/v7Ww5iAn4OvnSNafw6ZUC9cSCkttRzPtPYu5aAR8858eATdUrPqK4E5M472yg5fQJLFT/edwROdU+HCVJOaf87dcPr6YCQv13n2Fdae0gnUnu7E+1193xSEIL9cL3e3tvujrQ7ug6aEvChrutgRslUcqaM9bl06dKJsxeYn2wWwYyfbVDJjLpNHVSZHiCo6sb7Fy5c2HorjIC9A3wFAfzUeKbXyoErV65s2sjbm/3Lba/k6gGCFFRJQMMBEXlmeyiYIXte6SPlrXsk9U/qmVaeeD/1ILW3kffvCvxW5OA4jbupX/h9t8dptYvLnWOltwHv8ZWX1CO+0cKfVTp/uwfLopwrGVXjI+8lm+v8kNxn4FsvvA3U/vRByIcCDLIPXMGpPDne8MNxQPLVN+VLHT06Omof/OAH25UrV9qVK1fan/3Zn7UrV66097///e3q1avtwx/+cAyeel/Rdf12/4Jjm8u3apM07nlb9nwJ/ubESK/d/RlP0+OVdO3atfb+97+/vec972kf+7Efe4L3hRa6XUn47bnPfe6pV5Cflo6Pj9uv/dqvtQ984AOTW3UebrqtVhCcF6pmtXuz3a1tn8JbzRKJpiJdDtp6aRwkVdHjqTIrPjXojRwK2APNc6PUCXhQLmngq+qX6p6cRwJkf96f65VX8chyWjs5oLP8FFSYojky7unCiJ6koMIccpkyPw+iVNccsPT6qDv+7hzKSW6txUGmpwOJRz6n9kwg2vOnc18FxVgf7396RjahZ4vIj4CsyksBwsS7yk32wW0YV34wSEF5czaeqzBUJ6YhLxUYdJBE4JGCpwnEeT2SrrLd/VWAPdlN8czfXHnGw/SqYHUaQ5yfCphXesfnqvyn7MeovfD8d7EzLLOyx71yaWc8jcuwKjN9fLKhN+5MBQl2kUkao1Idxd/oGKT0rd04HLUqv9cnpq5VaSjjXXXF863A/O1KI31woYUWurNpCRDsSD6LTId7V5oCniqr51CO3HfAclbkzueIE+jy8mcqmaZXGPqgl4Bpzxnp3Z8KEuwKfqecz9713hL2XplzgwSVkz+HKiBBnrwtSQ76+fHrvXw8z6q/usNHINZa27xlpAeQRp3GSq6ccdZ/5j9VPw8OMF+XX5XXiIPONLxHAM97VVsriEDetGzZ+zufTSDDwZbScYWGQD5nJvUswXYKBlRL6Ctd7AFZ5zMBRV/tkgIVHuRIfPm91L9ZBwYHEghmAK43nsy1l85LZQvT7wTYvM68TpmT1ypg4ON9kltvBUMVDOB/J/Lk1xOlwNLIc3PSqL7ss0nHeuMHbVrS00o/Kxl5n+D1KTpLX2iqnLME5ym/kTK8r/T8z1slm4UWupk0agtuNg/nhZYAwUzSQMb/NMbV8sdKKXqzd+5EcCmfD8r8+JJP8q0ZQzklo4Zfz6cDvURc6uf8p7oxXXLIWB9e4z06GiP1qdqh59xyPyPPciA/I2UmR9Sd0lRnLyuBDuc/zdZ6OSOkdvIZT95PTsSUQ5/+VwCfTij1Oy1rdp1g2epDTu4gpfpxNllOaMqH/KUgogNof971IMnLeXPgnQCIl+N2xAE468DZZ24tSABY93xrkdJW7SgSH1perKX5vtVFbcAVBOkwPi7B52sKj46ONoEBP9TPn+eyZtmZ1L/Eu39ThyugmurhKwIcSHrggHmpnXtL050qW0ugNmWbHNCNgBR+p+s9/Sc/XIEj6gWruf3FV+L0xgmm01jKtvXggcuD+qg2dF11WVbjaFoB5OPNFFVtmoIL3i58paD6tq9UTEFI6qbr1tQYQzvnafw8CN/SVdVx9HrS7aSbvTGleqZ6Nt1PNr3KJ1GqX9JTpj9PwGahhRY6PS0BglNQGvx7aUkc2NOzBKV00LjXzw+3aq2dcOzd4eP/kXcD+yDVA5eckRP1HA//7Y7R1KwU60enzB3GqnylpdPhDiD54rOjzpeX2wNuytf1Kt1LfFMHktwqh8PLZ3rXU+entZO6XPFelaf68NwMglDeq/6z3lXQLbVZmu3jzKkHBwQmKSN9czm8ZOLtNAKYvC0rRzTpkYMQX6asNNoPTJklW8H7npeu60wW8sRZefGkdtVzBwcHm3MPRALV4i29xUA2kQfxKV/V2cG10h4dHbXDw8N2eHi4OV/g8PBwC6CxHvqtwJBAEdvKefdgBu9JFjzs0kEsg1DimSCSlFbAUB5Jb1IfEW8pAMr/agsviwCNz6lNvKwkv3TPbVprbasM6SiBaAI2lEcVmON4oGeTPJ1cdjzYT2OQrik/6SSDPmnmW/ykoAHzGiHaoimAST48eOI2W7aktbZ1yCnTcszyFUwuR15zXazGR8lP24H0cRuY6urXp4JDFaUxvTcGV+N/5R9V+ab8UrlT+SRaggILLXTn0hIgOAPizPqUwXXqpWeQQGl7INAH4yr/ynHclU8RnR3WgSDe65byUHnJYUj1JfVWZPRWQPTALHniKoI58nNncypAkOqSnGmXT6UX5KPiuwrmjDgJcmZHyPWP33T4W9s+TJKOuIPXymFi3vpfOVK85zIjAEpAcr1et729va0ypC9TOtlaBi3MR7IgkOkFwBJwIACiTJMc3Jmv7IgH6Tw4UW0xUPk6ZFXEAAGDGB4g8JUMPlvrgQJuKxB40CoCriAgn5QLz55wwOO8J5klWyU+E8hmUOrw8HCrLuxrqT9X5Sb99+eY1scQ1YntxZUN4nlkfKnkwXtprCOYT/m4Dng/5m/XH+pQz+a5nRD4V9tzNQjTMhjE76QDzi959nxHx6Fq5QvzYJ7VKin+VlA0BUP9mcpXIU1NCkjGVft4P0kHPjovibep9hexraoxaIqS7EeBebJVU/27FwBMec/1dRZa6HalUX/2ZvNwXmgJEJwB+YziKCCbomqWpwf+K3Kw0aNeJNrv81pyaOTQj3aKKadyKk2PRmdapijNAiSnzR29XQ3DlLM1l0b0IOnxaakKWrBOlXPJ+36dlJbbjsqq0mt9Vw57usZ70jvy5kChIoIk/a8Ckg6g0mywfzwP1cGXsns5vozdwYqAiINmD+okMDCim1M2yNuBdeF3IgfUrZ08/8EBa0+W/tuDN/xPsJ10qZLHXHvQAxNV/2vt5LadEdA3l6ceTdmhqfqMUA+gJ0A11Tai0T4/UmZKU/1P6U/jl7D/er4jz6YA0Nyxecruuv3dtc1uBZ1leXP7x5wAxkILLXRn0RIguAl02ogrnWduGUh5VlF85qN04s3JZ4HSsjw9mxzX5ICrHM7KeRrWobW2BWhYf6+DO0y7AHAGL9zZd77425c/pqWfnpcDF8mc+bnj1ANS6YDGkbr2aGr2X3VNS3AToHKq+PUZbV92qvsONJWn6zv5Iu9K7/LX/eTIq87plXae/3q9PVtFEO9tWAEwL8NBvIB4agvK5dq1ayeW/bMs5cVrDl65Dz7pvtpErwBV+bRVzqfOFdCqAG5xSG3GWV3Kxl935q+SS9sMtIJA2wu4BFl623tdp9vUZIvIpy8n9zppG5bbCbWfZM83Z8wFElXgpRpH3H4lPU02ibbU7bJ0w+16L/+Kx6n+l/qwiDxU371r1EOW6W2bxjnqqM/KJx1LZbPMaixPdo75pryTjrDdquX5fP2p0tE+OTF9ej1udcYNeU55S67aMnT16tWtPs5zHdw38Tp7mXODXXPBeUU9X+0s8h+lXflYaKHblXp+3K3k4bzQEiCYSdUAXQ067sh7Gqb1e9WHaTTQcrBOg34CInRkuCSPgEjALDne7hClQ5amDgcib1xu7UAx1YN1IRF8V0CQQDHNgCZKeyO9fnSefcYo6Q7rWgUHPPCTgglO7vy5w1OBeeeRbU/5sH6+xLxyrAj0eT/t3XZAxq0GLusquOHgrSLXC+q1HyTmzyQw4Afz6bcf0Jf6tPKmXJVGoJ+6o3QHBweb+hJUMj/Wj9sLWB9dUz0q3VJ9Ll++3Nbrdbt06VJbrR5afr6/v7/5n9pzqt3cpug51V1nBzAAwPfQe3CA50cIQCgP1pm66X2OAIb89PTHgeH16zcORDw6OjrRnxP5sn3ykBwNAvYEDHtjUTXOeMCOWz58RQZ5S8u73W6lcaCipPcu90S0xx5EICBm3qyH6sLxifd8HCVRD/lN3lSPqbdx6H+y47R1HsjzOpOqVxMnHvgMz0JiPZMfI7un7UTcOuR5j9gEXpNM1a+vXLnSDg8P29WrV7deT9rjr1f3uVTpcA+YeB/o5VGR228f93wsdL2v6lL5CQsttNAjn5YAwSkpDb5Ts7FT5A4qgVUvbdq/lwadCuhUy285uFSBAeal3zx9W8RDjNwJlbPCelQDenJiKuoNzAmM+XMcZHk9ORwenEhBCeZD4JH2cSawovQEmhUlGSbZ+33nk860Ow4jIFy8pn3vCfwnuSgN9cd1Rby6M997qwN/u/7TuXTn2gECnxfvHiDwYEiakabM9CzTkj/ZBh3mR0Ci+w6Aqnp4nZKM9J91UPmr1aodHBy0g4OD9uhHP/rEIaqpH5DX5PwLRHDmneBedoYBggTS9eYCBQeOjo42z/uhrmwrkfignVAZOoiRAUHyS6By5cqVrQBBTwek6wKOfjgg2yIBHcqd36xDso1eltsKH2+YP3UogW3lkcYp1lly1HeazXZdYdkOklN9XR/Tb+btweZqxYDnXZ2m73VKdfS+q3SpDhUoTHbZdWIUCKrdeVCyy8H7O224ggOceKDMWbeqvb0eWhnk/Vv93gOHyadIdi/RrmDZ9arXJs7XSJ69vKt8kh/meaQ+utBCC90ZtAQIbjFNDUCiCjRMPXNa8kFyKpqdHJQKYDj4TnXsDW5p8ByVJ/moeNqVmFdv8E+geoqS8/9wDtSsh9e1qlMV2NK3A2mm8XT6Pafdp+qSAHD67uVT5efOby9v1+lKRh5AEqCjbvEegzvVMuAeXw5QWBevM/nxgBBlxDr32tPBn8u5sj9J/qpD1a6VvNM18l2tVBIg1G8GLQielYcHhFj3XahnJ07Tl3p2mzp44cKFoTflpPx37d9zbNBIHq57KRCSPk6uH3OJz2sFEPNTP59aTbZL2emZOfLs2a+erzFlF5INYJ87izHiVtBoYOAsx70F7C90J9LtYBce7vLn0BIgOAW5wZ67cmAKTNKZ5OnbWu6YQOeIUyiHVpF9Rvj1SY6/L3OfkkePD1++q2uJ36m8qjJ7TlmKmusZX03gMq7ydceyAowV+Ojx59en0juAdNA4Ss77HAM7BWr9HuWeVlKM8tlLo/arAHLvfwVCR/ih3nh7pG0HrZ1cOcCtHN6HfQl8xU8VzOBsPfPp6ZuWDGs2kfwdHx9vZoNlU/isiGXy7RAClnpe1zQr6Pv0fbWOylH+Wgp9+fLljR1VeuXvr85025LACMsXD/4WgrT9wfOkLWebkGT3e4ELl2+VNtm2Kp/qvl9LQHW1Wp0AbL3+fDOcpyQDHyt9zPVZ+tRvqhUEabaa/ZW8eD9mGZKlnm/tZD8lj7zv9e+tbuyB9CRLHwt924SnrfRI9aDOJ/3yII0HS8QD7Qdpjl82B4TP0dWeb1b5IiPPTuWV8ltooYUWGqElQLADJYNeGfC0xDYNWO4YpmWqh4eHbbVabe03norup0Fa/ApU7O/vt6OjoxNL2eks0dmXE8z6uyM9NfPlAQnxlpZZkp+qnizb/4+AOTrflQPLelWBAQK/3pJYpentSx8NGvj9KWDt10adx9QuAgA+U0wnMC1L5sevVekSeHEwQkebdXLnMoF9B2u6RiDQa9OkZwkAklevNw/xkn7s7+9vALmDaT0rAMxrzq/XU2clUDbkj8uCnc/WHgLUly9fbpcvX94ECpTP4eHh1lJ9LUf29knOvgdwLly4sNla4GcHpPaRnWIfu3Tp0iaQ4e+fT3bZbbHLjLzyTASCJr5aUc97MCPphvhP75SXvic90n9Rupa2M7D+zoM/y+e9n3nf0AoCX7WS+pED4up6As+kns10mVG+rj++bc71lNf4TAocSBask+TLNnBfgSt/lDdfdVoRn0t+AmXiq4J4jbbTbRX7g/Q96SJXEtGWcNxnXVWu812tIuL2IT9vgHnJDrlsmKdfJ6X0o1SlT35kGpOmqMe38zAn2ODPLrTQQncWLQGCmTQF2tKgk9JURtcHIgYJFCDQ7JyAGZ+teEsOoZ4V8NBeWjnR7qhoUPeZEHdwk8zc4XcgKH4oLwenSW5J3uIxLQ91GbsjwlkNp2pVAOWgtqHD3HNSK+Ccnus5KAlwunM/FbQh+Ehl0fmlM+eONnny/d2qcwLHeqYnE5cj+fZ7rj+6VgEU598BjTunidzJY1npwE7WW0C6tbY5xOvChRun/eue6uPtwDwFoGQvvH4OxmULGChT23LPsOyDeLt06VI7ODjYgG/VV3vsGeCo2p11EdiQ/Ph+ee0vZr9ym6DyeTCa8tYbFwgu1GcJplprG7DhbUt7rN9Xr17tBghc93pAOdkKPit5edCm6ifMJ9kT1tt1yW2R22umYV9ne2icSkG26pyMBJxcDlPppuSp+rD9PThVAVQPGvnKkWQ3qOtuX6X3HjBYrVYb/U9jSUUEx86/6wLbvbKjLk+mZ1+SbVA66YN48eCSB2+9bdgG1XjM80f41gLmU/WPEX9iFBzPeS6NZVMBCO+rLpMRvZjiI1EaDxda6LxSz3e7lTycF1oCBGdEcw20Bv/e4Wl0NrmUjuC3omqVQvXt4C0923NCSWmWnXylvByY6vlqMK3+O00FLzydnO90PzkBzi/zam0bdHs68d8DwFV7VJTyY9s6TenRlONCuaX8U1DA+XRAMgJ6Uj1SuyUQ4fXo/fcgQy845P8T3wmoez+gznIW34MAPaDUC3QlXjwv8uOrCHyFA9+gonwZROTBc8q70gXni1sNtIqA+VAeFXBtrW2tsBD5SgQHdqlvMLBCcEJwyNcu6nfV/3WPaUZ0lDRlQ5gm3eN978O0r70+7M+v1+ut1RqqY88ep2BFqv9I/0vkus3nUvC3+k0d0D1e661s8ECtj8FpFY9fGx3TErk9Z/uqjapnko5xq4/b36RTrisJoI/afPHmwU7PMwU9WG+3TX7N+bsZDn7K9zTt7PnsUv5CCy10Z9MSIJhJlRE9C0OeHDqPvKdyd4mK9Z6ZkxdnTPzZygmt8qHDUEXi5zjOiYce9SL0uj+3fOfhrPVkF6rA/C58VLw4kPDrPaDh1zyPitzh1bX0u3reAUGvf+2qC6kuacWEA1XKgv3O83Ow43kyb/U5BiFkd3x5sAd7UuDLwTZn07naxJ/jcnyXF2Xk/10uvM5rSQ8kA33rWgIdqgfvcbayByiSHSTorqjSuann59iHKUCkNCkQkK5Txwhwvd5zQOBp6kcaHdcqoOa/RXMCh63l1VwpeJNkyOtTVAV/K7sxko79I/Hfs+vsv6lPVJTGYZ7zUb1KuVenni7seu+0lHyD0471c8peaKGFFiItAYIdyKPwvF6lnyI6VrxWLbUmAPD9f9WH/DjfHPgd5Fcz6lUeorQdIS1fdTnNBXIpj7R8McnY8+F719OrJasARkqn9vNrot69qUBCTzcSEbDpm1tGUruM8ODpeY/fvq2kte3DKalnI/Xp1bOaBSM/vWCAqDeryDIq8KDfvve+Ani+UkBlXLlypV28eHGz7ccDBKyX14evyGNZBwcHWwA3rTJRW2kLgbcX0yfZ6br2CetcAuYv3n15dgISFy9ebJcvX+4GR1Qm6yMe3MZxpp/9Q9f04cotHpTI/65DVdu4rCod74GwKn3VZ3qgY+pe6p88zFHpuJScwSdR6i97e3snZtynbE7FN5+txrqp8SW1n/d36hKDR7quujJYwjrpWgoSEEDzXBfXBc3Wu033uo0EAJLPwXJ0jXypzRz8c5URxyaeQcLXh1Z2vprxl504PDxsV69e3Ww5Sq9TZh1dzj094L0544/nRRvPekw9n3TF8zpNOV5mLyjhPN2qYMVCC90s8rH54eLhvNASIJhJyZD7b1ECfCORcg6QGlh9tqy17RN802xaFSDwGbDk1Op/KptOkX98pkPOZAJELgufCUizY+68pdmpJNOUTwq2UEZ63pd9pwBD4rkCzz3qOey85jO6U/VlnZhWzqrznJwqrwvrl/LwoIMvV/egAQ/h28UhqQIDUw6UA0f+p0PsjngCHuRfMvOZ+Moh92AKQanLy/khUK9m2g8ODjayTnpLUMO8L126tDmE0HVfz3Hfs9qCYIr3vFwCBuqC67a2NqQzFSoiYPVvrlpg4Ix7mv3tA7pGYEJw4svoU3CA373gAUEp5ar2r7anVTZH+VRLu6ttGuy3DgRFbEOBR9qo1C/UlhXA9fSVHiU98D7p8p66llaU+H/pNgMDPob66h/+TtsHHBx6nSob5KsYeqC7GieTPPxZ1Zk2pbW2tcpI+sFzQBgkoC5V/ZeHMdKHuX79ofNNrly50q5cudKuXr26ZQ9cXlP2wdvL7035a/68t3O1ioPljfiEo/dSgGGKenxUQYSFFlrokU9LgGAHGjWY7tiMUJrB8yW9dBTkqLjz3gNYDm7ciXJAVeXjgx+dKIKh5Hw4P9W9iuio0dHgzJXPxHp7JNArRysFV6p2pLOu/JlHz4mYQz74p+CP7jl/1VJmOuDp2Z7+VsGSiscUFHAATfmTHCDpdyUn/p7S59QHfHl5Ly0pyVp1VB8lsKNueRtQx11+DggYIOBhh7qnQwQ5g6d7Dkw8eLi/v7/1loIkZ9WdvPv+fPYH8s1DD/mGFu8/Fy48dGCjyurZLAYsEp+c/Wc7e+DAA0RMkwJHiRde9/Z2e+F8pjx748pc28K+lOyV0rCfus4wH/Hg9302WvcU3Pa34ozWxeXiQLgaJ3r5pfHQxwe2fQoisD86n9V4UgE7D1qIkt65bqTARK9sPlfppD4MVLkNcTufdEf3Ka/KfpI/BegODw9PHEw4h6rgQNUfe2XsUr4/m8qc8j08n2ocn1PmQgs9kuk0ffVOo9NvRF6otXZzla7KuweERp5xmgKarY0dmlcFKkYHIgdpPnvTK7MCwiPUA5w9uSWHZoTOamCey99cqvjsBaBG+OrlcTMp8TQKHEiu23SMU5rW6hUmVXkEH/yeClSwjLT6yIOPdOZTULLXv5IdSjP2BFb+u6rPVH93wJnk6fqY5DpHpk6U2Sh529+qflDJqVqFlNq9p7cpb11zcNhLOzc40Ls2cm/qGR+HdE3/Pe8RHSZVY29qi973rno00u+qoElFKVDUS9vatn9B20Xydkh8nHbMe6TREgRYaKGF5tKygmBHGo28TgF1z4czX5qp0lJMf00X984qTWttMxPbWl7m7tF7j+hrhjEBZu4j5PLn1lpcIj4HuLuD4jMe7hBUDgRpav9hAl4kn83RTJpT5eh6PpRLAphM43ynLQW6V834+IoU3wKSHNue0+7bBhIoljxbO/lObdbT5ZSW44rId2/Z5hR5+ye9GiF3ZFvb7nfKT/ri51lwlory8meZjlszkv1IQD8Bfw8K+LcDZb3mUHpPPSLQX61WWysPtIKAM44ug9Vq+xVuyof9022YL7GvQAttpM4M4IoG/eZr7qYCBJIRX+no7XZ4eLipP/lz/WGbeRn+7f3G+e0FpXjd9SWVk357HVM/TnXgb66A02dqvOnl2RtbE3ifCl6lQFIKUvtrG5k28cJv/vb0lDdl7LPrep5vQVLfGVnSXpHL1Ffh8EO7lex5FRDq8dMbL9WHudKksnvkPcl4Snecl4q8zinPXllzqOdvprE/6d2Uj1KR+48LLbTQnUFLgGAmaSDmoCnqGdCeIU6DkhzYw8PD1tpD4OPSpUubQVmH9chB8NeM0SlLTm+aOeS+P/JD517Ll7lMl4EGr+/UcnClTXKsQBzLSXVODlhqqwQK6ADJ+Tk+Pt7aV8l3xVdOtIMaXUsgjemTDvWcAzraPbChtD6bnNqscnSS0+cOIJ1q5UPHLfWbyoEcocox0u/kKPF+DxQmYCTSdgG2qYNCOrit3dhX62BCQNZ5cl64FJ/kh4NpO4EHBWgrlCeX/upZ6iJ1y2XKMxIS+PJ7rkPUD5EveVeAlK8pZP8hT16W5Co7yi0PDF5cvXp1q0zXJ++/rbXNVgfXCw+UpCCB2pK8ellKxzK9DLWB81wFTVlOCj54X06rxdxGVnmyn+u66kww62MSZeDjUAXeUj/3a663bqfcDui/0nKfO++JTx/fUhCXvxlw6NliBgS8jX3LRMUfZVmRjx+0SR5YFmks1G/ymcY68jhla73urbVNX3Z5yI6JD8/P7cyuYw3J7ULK1+97nXmf/anHH+2m6w7zSOOd55Pq5Pc5Diy00Hmn20GXH+7y59ASILhJJMOa9tS5Q+kOs6631trR0dFmdYA7JJoVI3DnKoLkeCZHjgMTnXE5cnxOTp5AspyE5MhyEPLgQ6IeuPNOxcHeHVHPqyqLAEZ1dYddZV2/fj0enObOQRqckwPgQG/KaUnAgfWonic/KXhQOTEuT+pK2nPKtJxRFqDTMwmE9ZyiXoApASy/l4hOatKxKedJfKlenFF2oJpk6f1cwUDdE3AlP+o/aXUA9dTBvgcPHAj64WI6yJD1STOulDn36Tug8kAR9Ud1o13wk+DTK8wcOFMPCCDEh9464IcPpjcSXLx4se3v70edZLkKEFR2m+k9DduN9t9nR9OKIYJbAje3h8xHelPZSuc1BQtGibbOia+41Jghu0rZsX5coTZC1Fm/5kGB3tsnmFb904G9ryxgvb1d2JdTAJBp+bzbem9Dv9Za27IfaYWL8iW5n+J1ZZn6pOCU8u4dzOqy8nEklcW+zHGakxP67zqTxoJKp5jXFCVAvovzP/eZ1Mfn5Otjb0rn7XOeQM1CCy10NrQECG5jktOq79a2Z8c545Jm9N2op4FX5IO1fqeBVQ5Aot7AOuroJaDnDleV99zBzAEiHSU6aemez1YkGbIMXfc6VM59VceK/16QgGmrvNzRrPKi7lRBjkr3Hm6qnKGKKjmlFTgJbCSwlhxvpk0rMPxNJQ5k3Mme+yEYTatRHPhSdg6mPJigdEkPHewkoJZ+V8DE2zSBQ19Szus9gOtlJPCv9kqz7ymfKZtYlcE6qg4+4zpCuwQGqjISYGI5Xiav87lenad46T3jfWY0/14Awcvs6U7Fj8si8dXTRx/7ptrQeezplvejEb2o2jeVPYeqlVW0YWlChtS7x3rsymOPdgXaPX0Y5XUB+QsttNBcWgIEpyR3KEcGdxrrniPpS7Pdka+AqDsyiRx4V+kIStJyZD4/Nfgyjc/w9Hjg4O/14/8K4LpjwXp7OVPkZfHZarBOzrE7UQngcdavyt+dwsSv/5/ildcdCHtwINWF+VT6WoFol9fNpuRM+5JYznBKbmlJLvtUBZK93zlYVfn8zf6WADxXCbiM6TCznyU9JF/sSww+Jp7Z1rrue/TV92VHKt3XM8fHx221ujGrrq0G6/X6xIolytI/bGfKMgVVKNsEBNmGLs+kU9xb78vlxYPbED4/px/0bK/bn5FnRoBHsoF+r7IxnPnl8nTaV5dBBXKq8cD/e9/TvfTfP70xtVfXaiVBqo9+V6vsPH9uWXJisCitwknPcNUG+ajGZfoD4m9KDyufJV0XH3wNKfPqkfdftmsls16+vf4wCrx3BehzwX0v4LPQQncy9fr+reThvNASIJhJc6LLPmD2or4pwKDneTBgWias546Pjzegnc6Q7yH0gZ+OagIrDA5wq4CA09S7rBM5Tw44pvKZmt1nusopqByrRHQkWQ4dv6pNvd0djPSCA7xe8d6bsew5Cw4YWTcHn76sfYpX15s0K+0Oewo0VDNCrj9Jziyjkgn7KA/hW6/XW30uLftP4JqOqJ5Je56TrosX9St/n3hyyAV0k+zIE9tFaXhuieQsYM6l+g6UXK7KlzZB/TKBE668cX1SGVeuXNmUI9DCd6cnYOVEvSJY99VPylcyEB98zWFVVvqv8g4ODk4EKshbBXySfWfeTDu1fLu1k/vL/VqyLXPGOPJNYhAgAUH9JiDlsn/v9woMuQ7y43Ko0qSAAfsoD7L0NPqmDfI2GJGby6YKDDD/ZNdWq5Nbcdymuh4mvnWd24RaO6krq9WN81D46tRqDPI27+kW+554Pjo6akdHRyfyuHjx4oZHXXM73LNhSl+NkVMBgV5dOX7NJR+feuS+Ui8ANVXWQgsttBBpCRCcgtwATw2O6TkfMKv0DrgI2lq7caIxnSjO+lXgMTlXpARSRA7KNRhW+0Y5ILszlwZu8j3iRPk9OoDVioXUhnQInUfOPvqSxqQLnB0TOKmAdi8w4I4xHUx+3LFhUMPrlJYkO0/V+6vJH0Gn14N643xVAQIPUow4zhX1dDvVg+WrveSIUo9ScEt1UdrDw8PNf56WTxDHAIwfOMq3B3D2m/qm/q3rPNnf5aq3LLBs779p1pBtlZxj6RH1hHxUbeDONMsSSFGeXDXgbcHgCj/UVdc/tqH6KAMX4iGBeOfZSTJN/UvlCvD4wYrKOwUHKtmTKjn3ggNVkGCEvA3d3iVg66s0VL4f8Ek7lwIxCeSLXGeZxu85cGa7EyyTb9n9ZFd7cmTaFOygPFqbXhLvgXLlwX7jhxUmeQqYt/bQuUceFFFQgLaKgYI0NrD+lb6l++Lv6OioHR8fb84IYbo0prhc0qfqz4mSf+AyS+l7NDJepfT+nNuGuXyM0hJAWGihO5eWAMGO1DPYozQ1+NPp9eBAGjgqwO8OqK4lx1/3lHf60AknyGjtpFM4Mrh69HtkUOqlqYBAD6hQPkzDuvXAThqUHeiy7aoZvNS2SbeqNqrkkpyi5Iw4QK8AV6pfqlsVXFD5Ls/TODburPfySoBMfHJljH63lvequ4PPD0/L9xO4+U05yuHWYXl8RaK/SYPl9nTEA0oqK80+6zvNNrpsXW+ZL9864PlNObAE0NIfPbNarTYHDnpQkcEUytFtFw981HcVEKxWANAupLr0bLuASgLKSbZTlOxWui++qvFDNGJ/U9tTjyu5+tiQ+gPHEJLn5/YjjXmuu+mZNPZxfGQevXadChZU5PxXbZ+ANQP2rIt4TcETPq98XR6u9ywn+QHe/+dSAtsM1PRW2igQkqgKDKUyUz+ink6NJ6el3vg9ks7t/UILLbRNlf9+q3k4L7QECHagXQbAs6AKoFagiw6OO29zlNQHYw1AnE2vAEOvLiO0y2CXnL9dDENqZ89vtVpNOo5OCQBMBQWSbKv6zJVZFZQYyaPiu3o2BaqSY+/5zyEHRHQIk3OYnNsK+FezkHRkk1PuQRyCqsrR9mdJ7HujcnLn34MAvb7ibZJ0RqAwLTWuZM+8JUduWVL/YrlptYPamafjs6w0c+qBId5LbdIDVXMp2dR0Pz1XlTnS59JY0LM1Fd0sJ8d1a844wUAYKQUH/MO0vfGV+d0sGmmTXv9KxJVCqf+pz8wZJys98fFwJM9kb3vljtg9D5iwnB4Pu9AouL/ZVAUOloDBQgstNJeWAMEpKAGPsyI6vJyJPDo62iz145JYAhvNwHEpvM/2+kBcgXs9r72GfE+6QNHe3t7WVgbtC3Q5sVzS1GCfZhCS7FNAoLeksmqz3iyI2kR8CUBQ1sqb91trm9lLX7YvSjPyvO7y4m+2Z+Vg94ISCRClGdgKtKQ0vmfe9Y0HzxE8e55JJslJ5zVf6u6giA4jt2HoPvWHy1z18feic6k473nZ3g5+vgBXDKSPt4+DWpLrt8+6U86cgfM28GvUFcqUAQIeUijQLhk5jzyj4erVq5stGcrPbV1aPaD/BEKaWWTAQM/wlXvJFlDeLMvtyQhY9NUGamfxUwVk0moYfqf+6DrCMigr8pWeSbrqdvz69ZPnOSSbyjZRnlWghn1GbejBHif2QxEDdT4W+OsN/fBN1y0PIPhvAuzEm6f1e/xmf6tsn8vBD3kkf+qLsrWsJ+vKa3z1b2WDq2CmdIJjtttgt1OUGwOElS4pf27PcjmyfvyMgGUGzlwPes+mwMsoTQWA5oD8lM6fT7yN+AwLLXSeaU4A9GbycF5oCRDMJHeae05Lepb3RgxyChDoXeVp2bcG28PDw83ASVDvaaccXJVzcHCwCRBoiTOBEIFbcuoScHdZECwmpy/JNTkDvN6Tb2rHHmhwR0rp0inylAcdGU8vGeuZlEdK41Qt4e4FQZRvmsV23tLzDlqr4AB5cdDse0J5yJ3zUfU1AjmWzS05lLk7xuTBdUl9TlsElFb7dLlXWfz5clc6xmnJO+VEfpNcK/2odJn/eQChbIrKcJ49uMM2kD2hXfE0BCOSoYNtyl88ffjDH97INoGUROJTAQKuavIAHvuiDnTldgh9q6383euyeQx2uNNRATleo3z9ef1nWbSNPTlQXg5yHHQS5Lt+eX9TOg+UVP0y2U8fF8ifr/RRe3HFjtovyZ4AUOl130GiL1v34Ji3pXjz4FBv1ViyuxyremlIbJ+q31PWHigTn9QzyZWy4XJ+pfEJCLf11cSDt5kH1L0OrbWtICEDrqyj2p7fCkS6/Gi/vW4jtCsw3sX5T3acvys/xoMXU2Wzv7kd6NmW1JcXWmihRz4tAYIdyA0mHRk3shwUKyNcAVh3ftKevARI6fjJ+U0z1iMDJgdn5ScwJAdb9+k4JdBRDWI+aPXk49fcMUmOnOdLZ6sXyEnlq04+e6H/Kdigb4JWUZq58zb1w5h6TkTiuRcgobPn5VQAppJnBRRd57y/8L5ArAcq/HuKH1+twcO0vE+JH37EKx1NniOgFQUEkD6TRQebq348EMM2oOxcvikgWO1BdkrghOBjKojmANJXEyUevU+mGWQGCY6OjtrVq1e3TixnmU7khcDIQYzKScEXl5/a3UERAWhl1xJwrPjmgZRuhx3UMuih/KlvSSZpHKFtUr8W2PIZ4Softmsa67z+5IvAlUFBL09jBwM91Kkke+mQrvk9Bgb4ZgICWj6bdJV5Mi1l47ylNuiNg3xuqh9Sdl5vjsut3dAZ6h1BuR/IKb2v7HBaQeD9nHlTjqlP0M72ZMRJD+mvViymoFBrLQY/qvGy8kE8Hcn7yFlQatMp3vx5t7OpL4/yUdnghRZa6JFLS4DgHNFIlNjTJ+AyYug526Nn3FGgE54OCUp5nAVVDlu6N7fMXXl0x7EC7qctu3KUWVaVT+96BWTSdy/PHjiakk/Kv2pDXqOzmlZj9Gbik4Ot35VTXzmwidcEftInzawlAFa1YS8wkJzNVKeq3ERVPacoyYgBvSkbx+dZL/5O9iDlrX6UHOf0YT17uurfCcx72UmeLE80tZJmLu1iI/158ja1Iq2iZNOmbFLPBlaBhOp+dc35OCsAOEJTbTNis/Xb9b7S30onU5BghP/edZfrlGxTPVo7eZDwCA8LLbTQnUdzMdTN4uG80BIgOCOaclyYhv97TkACaGnQTrORIkbxOSPMe5zBUn7r9Y1ltv5qPs466b7ya62dmJlxRz456Xy+Al+pDD3vICM9mxySCuQlnlerGyslqry09NHLnNKJETDu5fXy43/mSSA6ta2g0jf+5oezsb5ipQJciXwWi3rOLQj61iw4ZzB9L7/yVVv6GwZ8hlEz2vpw33KSJfVGaVKwwrcOJFkzH33rN2f9elQBLpXhZ2E4MKjea66ytdJDn7SiiWkpZ+bF+ogHd/hdNsleKF/2PW9z2sLWbqwGSsukvY3Tcmq1h8pxnsh/sisVqdz9/f0Nz5oxJT/khc9Weeo79cM0xlQgMumEn0XAevTGxp6d9a0Vqe0Tr9QHXz0wtTVE13zVBm3jVAArycF5TP+9XpTNHKey136pPtU4kLZqJZ7cLqZADG0B61eNw4nvSl/5TVvi20l6QaLeeES99OdIyb/xfG4FJT4r3fO6+b2FFlrozqUlQDCTqoEppRkZgKaMMIFEb4ByZ1bXeOAQQVNr7cQSQwIblaszB3x5vO7peTpUdPzlOFavIfL6uHPv6aptBJXT5wN75cC4LPnbHVQ6Ks6rZO7AlEv104DsDpC3A6/TcXVg59/UC9//znZlec7T1H/qlsjB+VR9KGseUMel4Hr1X1pG7rOXHqDwwNLh4eHWuR5yXq9fv765p8CA7rP9BET99V+JXFYepGE7JvDl4JPkWzW4rcF1g+UzOODgN+XDPsMDz3qkZ3wfsDvzPJQs2TrXa74ukuW4vVVebHul9yXHqrO3D/c4SycFXF0Ozhepmvmn7qZVBi5PXeOhmZ5XNSZN2ZleoDkFbfSbdU5L0hMI9/q5vib9qlbQ8Bk/I4LL53sAMRHHNOmH8kwBuir4wTpzHEjtm55X3XUt9Q0+w+CK58stHtreIr3x81/8VaHp3AyO/T7GuT/gv93+pfp4eyhttTKR24A88NsD7ruAet4bDTb00pCPSheqIIT3uV5ZyU+Yy/9CCy30yKclQHAKcgend29Xo5tmYlvLS2GVPg2YdMB0n7MrPnMhh0ABAn70PAMErbW2v78fD3wbGXymZhHo7LXWosPXy9vv+YynUwVQqvR0WCQX8sUZLec3OeS98qbqy+cJAFOAwMGgqDf772n8QDuWm+rqZTngcOeboHZ/f//E7Lf4SLqmvLjvmLPaOoCQAQEPEDC45QDGHV2m4XMe1BCfkj2BiPeDKijGe2xfluk8uuOfZg/dcff+nJzt6p6cdTrpnrcceYJk6oPLle1K2THAUD3re5P5DHlLbatyCHDISwKgDCixz7lNct1YrVZtf38/6gQDHjrQkfw6ef9lHdM2sooSKEn21/MZAV/e3pSH9KOavffyfOaYuue2pipf/wW22Q69rT5TdfSVCSPPeRBIfFZ5eDAnjWE+NtB+Kw8PEHga6qEHDdQv2GZ8u5HaVzrOevcCJZRfCogxOETb4yvAemVUOlbdq9JVfo+PgZUeer+eKtvLSf9HfIfRui600HmjKZxxq3g4L7QECG5jouMz4pCk2SMO4snR9EHTwYTn6c6mp3cgOepITVHFt4OwanDzIImnqfjkM1NORJJxVXYqh5QAZ+UkjDgt1SeV3Wtv58fT8H/Ke6o+bNsEXhjsqAIEzNNXFqgMgQfOMHLbAa+n5fP87QdPjoA08lcBL/HqTiPr48GLXXUhBQgqXeNWDl7rBQi4zFd8+DXn0cvVPb/OtudsZtXfaRMreyCiHSQI8qAK+fH89ZsynbIF3iaevwff0u+qjKk+mQDZrjRq/xOAcr5SfmlM07frpa7P4Yk6NfXsaN6UKYNPozTVrt6GlT1P91s7eQCvPyPd43NV0CPZd6VXWcnHqEB6qntlL3oBgRFivql/9Z6bW95Z+Um7UmVDFlpooTuXlgDBTaaRpbgV0cmho8PfdI7dMW7t5MCTlviKErCrBng6C5x9cydd6UcdTR/Qd4n4VekJJk6bV8qX/9k+1bvCHdS6w+Ugxx1hB9ruxOleFRhguqn6n7UD4wBb3+44+v5Xd/bTx2eXNUvN/pNAq/iRTKqVFbzWewWZgzh+HES6g832dKe6kmdy/Ak2CWpHlpVTxpyBTUEALu11YjDGAb3L3mVYXUurqsh/soVeL6XjGSopiMD/3p7S0dZurKBif/a2ZT7ent4XU+CE9W+tbW2B8BUkFbmtSW1OOVZ5eJ/rBahHbW4PHCaeU7/v2X+v3xxKAYMeVeWcJuDigYU55KsXqLveD1MwQN8MmFZj37Vr1zZvPHIbk8px6t3zNOyLIrc5XseKUrBpLiWblu4ne1/xcSsDCEugYKGFFmptCRDsRJWB92u9Z0fLIcDx1xxqH6qDFp9FI9DgMr/KAfVlhAQHBPzas6jXnZEXkXh1MJvqyvy9THcEyYfSk98ekYc0+KagRNW+aWBXe7nz4oGDxBfb0meuU5neZnyNFYEhgXbieVRvK74dpPXADcE165veu60zBxz8JGAivdBr8rz/8L+fO0DdZXCCy1OvX78eD0l0wMo6V453a23LgU1LYAnilb61k2eE6Bo/XGHhy9tT8CX1Wzr7LgeVzzokp5Ygme3GdMwvvdfcdarXP70OBJIJpDM/8eLnE0gnvA381ZmSB+005dZa2yxXJ4+i9DrTSrf4mjdPL354TkEVPEl5UyZ8hgdAerBH9s0PcZ2yx1PjIW0n5eH2nv2Yz6by2F4+DlB+Pt5NAbueDa0CLmnM7AFMB+keeK/a08eJ/f39rQA2+50HXxT0c92ULvvqGl0/Ojo6sdqAtsfl5nzrWX9NotIqn/V6vQlGSKZpUsVlm2yC01xwPqoPU3n0rlXBBMpo7vg+wtMSLFjovNPtoMcPd/lzaAkQ7EA8AMjJnbE0AFXgyfPhAHl4eNguXbrU9vb2Ng6R9p8SJNB58Fkdd+QdwLqToLx8sCHw0DUNTj6DSOfCZzD0LJ00OjspMJBmfMVTj+jYVg6Zt1XPwUzPK39+E5jpGt90wPokh8kDQMm4sA0dDLbWtsAi29QDQe4A9mThDif5SHl6/uJVzin5p8768n3XFQEXgtXDw8ONXBVYcyBbLXv3N1A44EuztOxHPUBKufEwtbSiIfUztp9fS8EBfUu+XO2Q3k4iXhNgpr2hs+0A2OvvgL+1k+d/OPgjH5Svrul0fxFtDgMOuucBU+eD5SVQIT1kG0t2sr8EKfroDRgCU56nE3XmwoULW8CI/Xe1eihwpnROlJWCYSxDdfc8PU1lFx2Ei1fKN60Y89nvVE7VZ3ys8gABg4CUgcvXD5BNQYIkK8pB7a/+kOwB+ZsCZ0knaAOcR+bJwGJvlR7bRfInwHbHeb1ebx3Omt4osVo9dD4E7a90XXThwoXNpAQPdnW99bGHPovXy+uiMUTl0C75+RM9Sna65wvsko//1v+pQMWuVPXl6v5UPgsttNCdQ0uA4IyoNwD0numBPgYJEohgpJwRfD3Pb5WnwZvOB2dunR86mj6LQoeBy8MFYDgwVwNsAtcsNzkunid5dsfMn3XQPcUTZVgFB/yaO2msAwGqgxWXrzvzPUpOk4hAgGlTvafaKd13gEHeq8CC80rA6m9DYPmUJZ1XEc8Q4MyiwEMCgiKuDhAfHtDiIXOsj4Nb73dJHuzDfMWieCIIZfuyTJXLIAGv+8fvpcAGeZZ83f5I1g7MKIOezvqsI+tDsOH2pRdgpE4wT7dL3r/9Ou0tiUEW9lUGaxSgot1m0IJgM9kx1p/gyPuR2o46S6C4Xj/0pg7dI7l+VmNFAjrJtlEnuNLC65fqkfpRCg4wSOp9jeNgjxwMUf8q++WUxsgpGgkSTPFc/W/t5FkaVVnUW8mvF5zw7TIco1JAkTpI3W9te6sC05G3it90T/2CfY918kOMK//M+e7Jr6KUdy+PXcuZw88uetrLj98LLXReyW3Bw8XDeaElQHAOyIFzup8Gan6P0i7Kqxmk1vJsarrem+1I5GlH63RWg2Qv/ylKAGSqbea0G2U95xlP721WPVNd83ZP/1vb3v7A76Q3IgeuBF4OFpiGz1Z8+yoIn1V13npBj4pf58N5rfhM5fNamgFOPHkAqnKa3akeSe/flTx4nQGAXt2TLNK104CwVL7+O/BNcvHn2EbU8amgSeKFIGikjlP9eUpvRqlq713aoQJv+u/32bdHqLJDc8YFjldz5baLjBOI9PF95JnEA8Ej9TGtlKjycx11u+yA+7T9c5Scr3T9ZtLN9jcWWmihhW4VLQGCHYjOVZqBaC3PhFQRc3cCEnGWxFcR6D5XB1QOrc9SJ6edPCUHhXX2WUk5HfrPCL/ycGBQ1blyxvm8B0MSzXVMqrYhX85Pj9brG/viuVRZ7af/7oDywyXSki1ngRPoVl5+TZSWeVbOtIOe1trW1oDEh+rLvH2ZNJfAJ8eb+0olLy131xJSLsNdr9dbS02p99527iD77Dzvub5XDrrairqbAgF8U4I705Sd5OOvdvRtI3zWZ93EF88f4f5hlpkCBMneJJ1J9i0FG6jT6fnKJvhqCs9XefvWgNbytgbKhrJKINRXc3FFCvsyy+F5IN7eXP2S6qEyV6vtJdsqT23WA3XqVyS3WSOgWfc41iR5JTBf/U5tXfUZyoyz0q5PCQTrHBEfh5yvHqir7GTKi/KcC4rTeEf9qnj1696vfLxknSofhYEppvPtA7ShvrqK5/AkuzkqGz3vK3o8L8qJ/SsFCkbH7l1oKk9vz5G8qjavyq3uu/1M5Nd30eWFFlro/NMSINiBEpDhPf5ODmhKO0JyMOnw6Drzp9PvBwwlJ0p8Cmz5jCqdbu5ZJCBp7cZ+X99e0NqNE76Vjs6mgwN9J2cxOTsJsNGBcyfaiQOmy8fvU869PJnX8fFx5MV5ZF5pFtvvpcPmHKDzuwLhXld3ftO9CxcubL3DWtf29va2Dm9Le7f1m4EBl53Il+ATUAl0uZySY+xvklA5vgyWdfe82EZ0pD0/LrlPoDAt1ydRdhcvXmyXLl1qFy9e3ARUPDiUnk0g2gEebYXLh2m8DTyownJEBJXMg4EupfMgkvdx11u2Rw/gq92Zlu3t7cbfPFeB12krlc77NoM3OgyOOqvzCRgASCBGQRyBXLYXxxYHYLq2v7+/6Y9OSX95PRH1iO2r7wR83DZT1p4n7/vHD3708UUy8P+tnTyJP+nCFOBSPqqrbJ3zXz3L+vbsHWVCeUwFB5g39YF6kQJnbmtpC5VOgSi2gfRWdZXdY99mXtwuRfl43042JI2R3o/5vL+2lr4Dy/B2SH5EknOPV7bDFJEPtt1I4CDVY0SHU7qpOlc+w0ILnTcaDczdbB7OCy0BgplE4+9R7VEj2ktXDRDuONGBTU6eDrHSfwL6aqmkynCApHvMy+Ug51Vp5NS686xvOryJf9bNnf4kw97AOmc7Awfq6r4TB/hEdKxaa5uDJlMd9M12oCzSDH0KECgfB2PuNLLOTJN48wABZ4x0XQdG+QF5vM9ggcp3kCCSrisYIGCla9QxlaHAhZ/DwDpJJ6hfadk1/9PBdT7VzuyndJyVlocmUqcJYigryXNvb68dHBycCAglUOZ8E3CSPx0wxmBDcja9L0o3JcMkNz7L8jgzKTvh4I5lJr1MKzuUxu0M9+gzoJBsiv77qg7lxxUEDPBQZtI7AjQ9t14/tJJIKzn8XAzyoDI9aELZq009CChS3T34I1l4wG3KcWG6BLiTjU520WXmfT+Ndc4vg2sVyKSu6L6vSHK+mN6JdsD1IY0xLH9q/HHZUk5uqyueVYbrA/l18jqTT77pgDbM+dRztOu0Z94XE1XjdzUeVenUrr0DCl0ne34F01eBBa/DqO9QletljfTLHt9znvF+uQQGFlrozqUlQHDOKA12fi85t2kGdU5kuHIiRwdu/XYgMFXmaYiDXeWo3coB0IFAL52cndRuIl8V4LL2b78m6gUHer/pvKYghAPPBESngjfUuzQbTdCnvOjQpfb1oAmBude/cgqr9ktgr3fNZVfJMsnPHfseTyybcvMApwelTtsHvc4MKFQ2pVdmpY+85jLU99y+nto+2Vv+r/RJ19mGU4EVDzyIHPRU8kr93W3xnBUEibfq2SkwlfJgfdIqg159ky3yez1+dqGzyivVJ60oScEBfSfwL6qCJxwXe2ND0tFeW6RA0c2iUX1N184L+O0FCc5TPRZaaKHzRUuAYAfyyLhf3zU//SZx6aZm/LSUTzNRq9Vqs6zbZ9DkhHLGQ88kpyItGXYnl06+KDnRnEVgmT6LyBmPNIvs/PC+8zBntUCPqvwrx8gH8eQkceZbRDnSWRvVJeencpDT73QvBRr00coA6RpfV7VarbZWD/gst69aEHF2MM1EHh4ebnTfZxMrnl3+vO48sX+5TF3ODFLwvI+qLq1tz1SyX7BM74tcDbK/v7+RZ6+eaabMnX6+WpFp9d/1220SAxpTfcxl3lo7sfqFdVbbuk1imf4KyhRcoJ1yPng/gUb2Q9/3Lx45a5wCHGx/bsfifdZd8mBayrYCdwyEefBhynYwT28Dt+tK4zyJn6Q3pATsva+lvu9BQAYHnQ8fXzimeH/Qx9vGx6lUV17zlXhzqBccSWkpp0SpP/H5pKcjwLq1kwE2nunBNqNNTbxXdirxxusVr5Wep+BbGneSXdhFPs5z7zp1qTcmOz89XqpnR/lNejiqmwstdN4o2ZqHg4fzQkuAYEeqnLAKXPTSVs4s02mJbmtt8x7wvb29rX3gBN1HR0fxILPWTu5hd35Wqxv7Yv1Zvpvb65WcEToWPDvBnyWg0uFGvuw0gRZRAiROvQBCb3D3WRZ3JJIcqvLF37Vr17b26vuBfa21CDBIBCFJd3yGsgJFFYCm06dl7tI5LuVnOm4t8Jl6l5mvCPAloev1jcAA01Ce3L9O4M1vl31PFt6GDk78sLlUJwHxBNp9K4HXg4EABQe4tcCdXsppvd4OXLhOJFDrjqrrugftkr5Tngl8K18utW/thi3xpdTurLuOVn3Ny07tTpublmKr3byviy8HrXxdqesbZ3b99X/ceuPLoa9evXqifg6oNBbQRvuqHQ/Usa6ScW9JvcpS4Kaa1fZ+rPwqgJPGmZF+lla7UF94OKn3j1R3r2cVnE5y4Vjieq124TfLcTn0gm0jwW7XeV1jnTwfjpFV36IOS2f17NHR0Za9UfrkbyTb7oFU9htvi+RPMLjL8jlO0eYw75GxukeeX8qn8lP8OU9fpXOfK9kcPpeCV7vWtfJLF1pooUc2LQGCHSg5sSlNaycHCjfYPqOUSGkEAjSrKnCY9phqrzaDBCzfZ4BZFp0+OcB6Ts5iD1D7cmeWXzlFchbohDN95YD1VjJUlGRNftIsZjXQ0vkkn8mxo9x4RoPkSwDoeU4BJG+PKjgwdc2fE8g4ODjY7IMXYJUOOd8Ct+7gEAS01k6AfzmdTKe3PxCs0BH1Oie5VHUjICRR19yh1RkCXL1DJ1Y8MpjhqwMkN/LEVRniz4NGaVbUgxIMTqRAAmWS9MjBpvdnAvrUjyr9ohzSO8p9RYgDO8q750wTQIgoC59hbq1tgXUBIl8hQrvlAa0qmMAPV6oQyOzv759YHZMCEWxr8ZHqRoB2cHDQ1usb59F4IITyTICRoM5n7qljBMjJHum6jxvqK17O9evX2+Hh4ZY8fLz1cn1mW2OjB8xYV7abBymcz0rnmIfLgMR7yWYk6vkXyaa5HkqXfTymnrNeKXjOvBkgYGDH29f1gHbEn2H/79kr51/8cDWertFu0h5Oydfbktf4jI/FVXq3YSyz57OM6F56NuVDfSO/qayKpnhYaKGFHpm0BAh2JBrNqWDBCKUBO5XJV7txhoVOEdP6rBj5dJDlgwmd9gTeRb0BLi3FlJOmOotHgeaUZ09uKUDifMwZ4OhYqQ5TaVVe5YworWTI9O5YJf57+uXPeF2n6u5Ohv9XG1VbDPzVja3d0C22pztPDrTc6eQp1HzGAfdUPZNz6bJKzyaZk2eVTyCi5xz0smzJlN8KtFCXOQtG+VZOqINKglOvE3lJAJDyVXtwxtYp6RzBGIG0z/45KPPfqkMCCqyXy1Z1kx46kHKQlepBmZE3/7jd9ACBl6t+o+AEbUMK2pKPCjApLU+en2or6l9V/xGZ8LfbrwT4/Fn2GbcJKQjsfZcy1zjowRsfr32FVpKXty3l4XnyegLbVZ0rMOqy8vKr65V8Wfcqj0r3OF4rH4Jj2nnnueozXn9P7896XVM9PADr6Ss5zaFKflWQIOku/88tz3XN8zktmE9yOa1/u9BCtwMlW/Jw8HBeaAkQnBPqBRDmKlxvMKGT7YDVy0yDuDsklZM0h7/k3IkcIPrgO+XYJUoA1B1F5ls54qmsykDJoU38OvBJ9/yZRBUwotPnM1I8RZ9vJ3Dg2qtPArAEA5UTmOpTgbxe/QmCHdB5exIsk0fnleA/Oa+Ua5Kvfyc5JrmMOt+ePl2rnHnPm797AGOkTzl4prwqXar4q+570C7ZoBH+p/iZ0/ecR327PjFf9kEGhR3s9Owz5eGBz6oP+T2uukh2rwLVVX35u5pVHpGf+FN5BK2pHl4/bzsGqFNZc8iDcmflFE4FB0iV3VBaD66PzLIzD+kGfZOkD0rnY8YuvozbOQaTXZd2pSm7OEJV+rnBgSqPxGOi0wYLFlpooTuXlgDBTBpxYpl26rpH5ufkS8CrPe2evw9IGqw5O5nS8hV2PhPjAMkHZ1+WWgE/zkimCLleB+j8Vc6eBxIqeSWHNi079YBMAogcrNNMn/PJZbnOg77luLljxRn71rb3q/ccLk/DFQHuuLFcBgj0TnVuL/ByWV852v5asvTRs+5Ipz6h+vhy/KqdnTdtWfAVOCyXe5k5m8l66L6/Z5vyZfu4nNMKArUp66pyK8Al/nz1hffZpGvsWw4aCSa9jaTHLmP+r/qan0Xibcpr3t9dR9y2sb+6zFhXpVNeaRWK2ybKxes+ZecTQFS7aSsYbQt1g7PotDG9wGvVRtzWQl0kr/zNLWjXr19ve3t7Gx601SbV1XXV2406mvame9s78He9UF19JZfzlOyxp1X6auxK/xl06aUnH0knUr9Ueg9Ut5a3kbmcXXau6+kwTv6XjfM00p/9/f3Nlivfbua22leepT5LHfBrboPZhw4PD9vVq1fb0dFR+XrDirz9JZuKdknb4yOVP5V3pTuuC/57TqBjhPeFFjpPNGoTbjYP54WWAMGONGU8K0Od0swJDoh8hozbC0jujBC8+AFW7nys1+vNGxM8PwcXPminssl7NfskuVy8ePGEE+zOltLyO+WVvjlgpnsJXLoDVwExr7OXwee8HY+Pjzd7hlu7EQRgeznw5Lc+vuKE97QS4NKlS1t5Uh8YPOB+6eq1i+7UcYkwtwroHrcOpL6ka5KFzzwn59Kf5W93uqWrfBe92ubw8HCrXkwjZ9gdUDnxbB+2TbXqggEC1xsH7eke9SYFXgheesueKRuWl1YSpdUA/izr5uQ65MG51tqJmVwC5AQeBEB0PQF78sjZcPZBlwN58/JdB1M7ue1w8E7Q47rAfuy65jPuaeabQSMGewTsUj9xYK72cpB2dHTUjo+PN3rXs5fisepHiXfXfd5LNpvBQsqlstFsU6bxYAUDdPxOVIG2nlPqYynJy/K+7PYw1anKN/UDD0ZWIFt2QQF8noWUDqf1A265Eo28uF67fDxAoODA0dFRu3r16uZzeHgYg09ziHpXjS3uJ+haryzKd4p6aVlO4smv70LU+YUWWujOoyVAMJN8QOg5DKP5JZoyzO5Ma3Yn5ZkAOgdnOvy+jDQ55e7U+QyY0lUBAvFYgXfni+WwDi4jb4vkACeqBnpPw/J79ZtyEuRUVc8QuAgwVCDT+U51U/0pVz8d35023mOQQIEbOst66wTlL+dMIECgW+m5Z7U3k+kzXpRbWuHhebgcCGZ8BQGdVJFAkPJwZ9WBn765v1z/02GO7qizr6UAWXLe6TQ7qEmrBCrHUu3GYKM/37N3rJcHQjzder19Knpqq1SO15k8+t5zyjX1g0rnRCmg4jo24ownoCiQTEBHWbiuu0x8RrWy08yfuuMH1LJdXUbex9wO9mxQ0k/ZAK6ecPvBfKv+TFmprdk+yldy5BsnKGvvFxX4Yhr/XdXd5eT3pwJ25NX1tDcGUBfIS+prbCPyKRtdBVgUaDo6Otoap5wXjmNp9QDz9rZwPtNkBFcR+GtwPR+3X+4vVL7KWfh4VR49ezyHko6dRZBgV34WWmih801LgOCckjuMdBx7KxJ6oPnChQsnnCilqxwcfU8NfqMDjAcoes5nCg6kwXxqkDytA0BKQP+0g/QIuZxSEKECR73AQwK0FbnjlXR0RM7ulPQc4dG2S3qYgjxVOpGvRJgCnj2QzO9RmhuMmpNXyvNm6W6yKX5tpG1TezrQ9PQjdZpjE7wt57SH698UP65z3k49vfJAQa8vVONEsgWu471gQSq3d7+iqTEhtbMHfKr+Wz2fnqtozng3sqrHn5lDiZezGu84frg+jOjRFI3YKA+GTOVXtd/DCYJPY2fP0n9ZaKFHMp3GXzpLHs4LLQGCm0C7gpgR0uyLg/nr169vIvmc0U3Ldyuek2NeLfXnoMx95j3QJfIZr+SkafbaAQPzq2Tq9RgFOxW44MyG/veA5ShgTR8Rl+bzGc3mVMu3NWvNZe6ctbl48eJmmadWBPj2BX7zo/LZfuLVZwj9v7cPddN11IMXKY0otYvLubqfVhCkPDkLLYdeuumOscuOPHOFji/T975T8Z9sy9Rv1//UHkyTZgz5n8+nPtkDjBXY1Hfiu6p7qidnQatAQdoawXu65ltY0soffz7xNEpuZ9KbMbyMtApgisf1+saWhKOjo60tFtJNvlGj0ketLGKZ1GG1RWUfenpY0eg4xrqI2G+Zl/q0bzVRvXxlBolt5sGFVJeRND1K2/1c33tjkk8ApDGOQYvURq21LTnqbBrfXqD06ks+1vVWj5Cn5Ftw9UDqGxw3qrr0aDTY17OFvDZS1lweR3ia88xIcGyhhRa6c2gJEJwBpZmc3u/0vJODFg2KFy7ceCf4wcFBa+3kfl3uH5dTxEFT+dEJ5kyAD8gODty5S6DQ66HffMYBJB0JylX/fblwWuqaZMultmmWKNWF5MusU53ohNDRYlkuf27VcFAmx/rw8HCrnR0QeF39VYR09iVfnSWg7/SGgrQcXjz5HnzfW5yAAHntbZHw/z5b5mAutV1yREmuqwQTFbCmDvr/tOdWwRjm47xUoNv7mH/3gLLfc330e/zmb+pa6nfsq14PAi+2AV+l53wyoOL1SPIRj0xL2VZ6w3xcx12+rmsVTw6we3bfy2Mb+CtBezIgqHLbnuyMA0juz16tbgSVJRfXdxJtmb55gKFshGyDthT5OSSpL+j3iCx5n7yz3vzv44kHpjReMminffYac3ugPgW8WFYVlPJAOPts1a+VrrWT4z/vsf+5vVytVvH1nylwz/pQ38SnzrRwHWPdyY/yoW1yHfcxhNsKtEVFZ2G4nH0MS/VJPkNlY3sBgyk9rYjyHOEhPe95OX/u4yQ+K32uri+00EJ3Bi0BgpnUcw4qkHqWRGdFTp0GT3fynD9+87o+fEYOHAGRO3YOxMSfA6tqUHXHxWdqmcbTStbp/csJ5CVyWfjMeJWH13eKkiPr4CA9I8dHjg4DHS53tSEPg2JwgCsBFAxQGl9NQCeLfNNBY1toL7HkkWbDWW/fO+xtkhztJB+XHctl4CWl8QOsKGcHqtRF589XC7R2o+/RiXZ5MC11zpccV04f+dM3QV1v1rPKN8nT7VrVF1hWBfzIH+9T33idzq3blSQrD9LxfrXfPC3XTnqp9ALCnImV3hBE6pkeoGS+5K0Ck0zrwUfqpj4p2ElQSRmnIIIHIViWeBAflEtrN94Eot++Nzzx5nwmAJTk4XLx56UPvfEo2RqXz5StT23NPDwg4XV1HqrtfiK3uewX7JcpGM+8/FBVl6vzlmw4z0BiAFn8kF/yVr1W0tvOvxUkYDDK5aM6jYzR5KvSu/Q/8TxVRmprlu+6m/KtxsQefwstdKdTZf9vNQ/nhZYAwcNAcwat1upljRzI08fLGBnAkhNDR5H8JKCq61VZPdDiZdHhcacqgYRe/Xo8zSGv51Qa0hTQTXmntm5t+6BDl4sco+rjB0WlGX0PDjjPHrThvQoMuywSEHNZVSCpB8IoI+8HyWGm/nBWvHL8qJ++BUPkzjb5qmQpIEI5pvRTMqso2ZHUtt7//PnRNCN9JfGefo+CbjrYvnolrf5JgG7qd2sn7c4UwEx1SbzzOa93Amyeb+KlZ3ccWPpMrpebyvSVZ16Oj0eVzHvtOpcqYFfZEabzgGBKV5U5Osb07MtccmBZ2Q1+kw8/5DilI88JhHtgppLF6JjpY8io7yFKgb+KRuz0rnSWOv1wlrHQQgvdebQECE5Bu4LOOcGBHvk+dTnF/CYASU7fFODQe8vTgO+Dc2/Wkg6pzzKrLC/bHWLOCHjwIDmnnp9TDyhUaUco1cXz4OoMpekBEl4ngE/Af+qeB1zciU/OK5ffVm3s9Uj19mAEqQc4+Zu8Ou9+3WfN3LGsVos4uPCgCZ3x5KgygMN8puqanNXUR5Kjn5z3BOb1rAc1ElV9Y8pBn8oz8e717wUKUnv4NoBeIHa9XscZWpaRwIiX79sayEPSIa9XkkN1Lz1f6Wv17bJlvj5mpPM5JDfmR+Dve8I1hjjw7smeINPvsd5er5R+ZHyu7Jjak/a0tZNbW9Kz5GtXqvq7r5SpbHKykyTJjPUc5Yl9z1dQkcdUl97Y3ws2Uy+pZ14vbn+ZE7RJvJ41+fghSjZxlJeevZzL1y7PLrTQQo9MWgIEpyQf6HYNGlRAuUrLrQZ6ZZ1mA1prW3tA6cilZdg+iHI2iDMDule9X9gBGe9zOaQvN3WqACqdzN5WBz0rJzTtvfa0Dhh7wLQCl5QfeU7gjHX0GX7XgQSquV2AWwT84EG/xr2Z5MNnW3WPqxSoN6y/z6b2XuFIcpkwj0r++magSc9WDmXVzn7PdZ08+n5170cEUtI5Lp9N/bqnb87vFChUGXT20wy3//e2qfhM9ikB5x45X61t25r1er2lm86T10PbM8Sbv4LTy9a3nrlw4cLWUnjfs+zpnSfJ2/s7ZZMAlYN9ynYKNHgar4+XsVqtNq+THCFuzVF7cTm52srrdXR0tJUHbcOlS5dO9EUPQFTLxCkL12FeS2DcgxLeJmn84nMc/2Q7vb/6GKdnFVhP9SB/5L3q18qb5aVtA5UdS+Od86Q82f98yw+/fTsWDyhUflevXi1XmFW+h/ND3Tg6OjqxtUC65vx5UIf3Rv73bJrrWs/2JXn7PR8Hq3L82WQr3H71+tScPBda6JFAlQ281TycF1oCBDuSOwYciNLg0htwek56cmA04B4dHbX1+sb7xHU4WmvbAQLuSebAq4GVgI6OL6+lAUh5+Oxyb1DjqgdP53sVWb7v1W7t5IFUuqe8/ZnkMBFEpXTk3ds88ZyW63v7Md8qMJAcfTo9konOG+B5AgwO6I0FfnCh85Mc0AsXHjrQkPy4oy+9rlZ2eP7VrG6lN16WriUHuRcwcifVVxvo+WoW2M8a4Pu39WxyUkkO7HQtgYN0zXlym1HZDW/vnh2qrgs8qL29vRKwr8p04MR6Ub95L/UnHSDncvB+6zOu+u0HtHmdGMx0e0jQLCIYdR1PgT/nOQEFXU82JfVFlqPxYEpPNE6IGFRmfT2ww3pR52mLZZNkXwkQPVic7ILLLNkP77N+rwLIPh6S1N/JA5/nuKoyyIeu+2oD9wPYph5QZF1TcEUyU34+JjlJ7um6xstr166d6Mtu0+kz6HBCBUU8wHB8fNyuXLlyoizxQd8j+Se8prNudEChr6D09ur1t9QW/kzqk72A1JTjX/mE/pzLnno3YmOrgMNUGdX/JKeFFlrokU9LgOCUVM0ik9xZr56hEz5Srhzc4+PjjbPMAIHSJSeocphaOwlKlW9yTr2eCejxGTqGlInS+aBJPhI4IbD3wEXiwwGYO1UJoLl8piiBGZdRStsbhBNQorPmB035qgSuIKBDmeTB77RMs2pnkQc8kl7xOvWr0lEHeWkVS5qp8g91JOkwHX6vE0GDeE6OlJdX0YiOVf8r3Z7SI68T5Vo9VwV0WIe5TqT38xFnlvot3UzPsm0SuGXbe1/yPNkfWsureSoHnfw77w5ovX9RRimv1G99SXyyK/4/2XDWW3J2YEkgLFIfoT6sVqutAIGevXDhwia4Rp7Ybk4V8O2ldTlTbzhusO6JJ9oEveHD+5vyroIViedREMd25uoLvm3ExzzqAqka85Ptq/SvtbY1nqjtFYRurZWrQtIYOzUOsd7+WuUezVlBMEJVn+wB7NH8dgHiqeyzoiUwsNAjjXp+663k4bzQEiC4xTQSUEhUDTruOCgt73HwTY5yypNlpkEiOd68p3xGBpgKpFf5pt9poLxZg1sPGM8pM9XBgX+aTfX0ozy7Lnj7V7o5x6BVKyFIUw5Uda8C9b3nKx2vdDuBEA8yzK3Lro7oLuS6QtCbVubsSqNOsNc/BWRSezmgqJz7HoDh7wTcKhDNclP5vcDOiH7Qdlb3K52tgHSqh4OzKeDX63dV3TzgyACIgpYE0vzNFWD+StCqj1e2pRqLXM4jwD3V07/14QoFf2bXfp90y4Ez0/nKN8rBV7/0yp2iKuDEb7/GYHEa3x0g93wcv9/zE1jueQG5t3KcGKHKxi600EJ3Bi0BglNSWmrqNOpM+0w6n0+kAVNLQtOScC2F1GyNlhFWjk3lDHIZpS/dp0Mix683kFeySABmapDyvaLiy52OOeDInRG2R+U8+jvee4DDZ/fp0PgWAV3TzIzf82CMO5NcrUHnPNWF9Un59kCagwWXQVolQh4SSFyvt/f3u84lh7FyMp3vaok4+fZlz9Qz8eVySsA2AUyXMXmrdG2kXqqHQNdUEKQHVKeo18dS+6ZVOqvV9qtKufWoAv/sc97eBG0iDzqk/56We5xpUzjL2uvj5L9nwxJw5isIq+dY19ZOrtpprW3NLre2HYjtnfXgeqt+oBlh1jGtWGI+XHXD+vJ5vsa1AsJepurD8kaAsPhiff3b8+TKPgYzxLN+075L39m+LCPJ3PsR/0v2voKAelhtMfDr3teVL20B+6qDbY3x1L2kA9p+cOnSpRPlep8irwx0aGsBdUKvUfQVcF5H56saM3rUu5+CIiPjzyhV40Aqe7TMZLdcHj17s9BCC905tAQIZlIyxiOO4lQAoZeXl00HjuCPDoSuKTBweHjYWmtb4LJywJKTS9Ch+mjgdjBN50IfL29ktrqSmxwUkQcJmA/lxZOzvQ3dKUsDfXJSKyezGrQlHx4YyEDAwcHBifMC/JqCCEk+PktKQF3JknVhvtQ31rmqb3LQe85L7zqXllLHVZdq2Tt1y/mnvByYeV28P8lJ95nOKsBQtX2lUymAwOdU716f4G/vg621rVeZKR+Bn+pU+d4MJPsSZZ7KV1kJnAjIOkD1D8tdrbbfvU7dYP/1tqQdUp5cCk2etOeZaQmCkuxTW7BfJTsp2VG3KhDr5fiBo3zexwf2mYODgy19Tee1cIy5du1a+/CHP3wCmDGwSeCoYDVtv+qn+2w7pdWHZ3twW5rn53069TtfPeJjTG9bgOul+gtBp8YWyoVBj9S3XN+oo/4t20MZJPtXbRdhHZ3IB4MEuuf23QNS3NrGa97mqR1bu3EeSdpaKb1jQMDPrqAOiX/ytLe3146Ojrr2VVTpj+tLstn87zYp9eEeoJ8C+1P2P/lvU/VK10f90oUWOi+U/PqHg4fzQkuA4JRUDfyVQeWg28tnijggcgDlacs6m0ArCJTWB1efgU8DjDsIrbWtfCoQ1gNy/J/kkQZWB3UiOjZ0Pjkbl5ykdC0FPSjvUV69bu5w+asH5dzwrQQeLPDgQirPPz3HUe2afrd2cnVIAj+SYw9I0mlKIJH3ybe/No1Os/Pj7cZriW/eq5xDObD65kGgAqkuU5e115/p5gwWPdvigQpRWjnjgFeOfAU8UpmUvZ5z/ekNxt6e6p+6xtm/VK7uJ7myHvyf2r21G4fyMR+CkMQ7rzsvHojxlTVOHuD0mVXX89TPaAs420yeGSyQHld8edseHx+3w8PDE6+YEwC8dOnSlm2iHmgc8pPvWbcE9MTzhQsXTgDjXlDGqQcInQ+/l2whwSzr4kCUgZCkR0nn9M3AKFcQeDCL5LJxOz8lIwbwvI+4rWeeaRyQXujNImrTw8PDaBfS4YmSAfWZhzPSdlCmPramccLl5PeTfe7Jb3Tcn0u9YEQa21L5p6UlOLDQQncmLQGCM6IKYJBuRuTIwb0DdgeLzs+uPPUGRILuEbl4HjdjQJrDx675T5VbgfAR59QdsVEZeVDDgQ0pOYY9qpyWqWu7Ui+fUYeskrO+CeinZtxuR8fJAwA3W+9HqXK6eX8XPr3NKuCY+g1BjYNpt6Esy5/vBb+meOfzFX+kFBxIIMjJ69JLo99pvCAwa+3krLMHjtI4xLpV3wya+NsmUj16unUW/ZS2OwUnGeiYE7wQefuk9pL8qiCe51X9H6FKjknX2Gb8T5m11rbasVduasvKZkyR69Wc8e1m0pSdGKnb7WDXF1pooUcuLQGCmdQzypXRnxqQesB4ZCDjMkedOcBBmfsn6WTQYeNSWuc3zRTwuuetsvnapDQb13OGWE6a/Zsjp+SE8ndycFMZvSX2yfF1x0nOlV4/qFcQcquBZtk4A8JtCJylY9niX7Mtqpc7beQtOeA+C0UHb8S5S6Aq3aMe+lLRBCYq8JV0JjmqPX49b85o91ZfUO6sj+tJ4n1Xh9dpTsCDfO5atpfndoMyZL5V27n8aZsS/75Nwesj/vwVqJ4Xn/eVOD29Y1lcsaR7o8DDbSr3dKfVHNVMaAo2kh8S89Nv34LgJ8+v1+st260ZcX7TFjEvLq3n886r18uXqUvP2OeSnUjjl+6lvsx2rUBvspsMXkh/1uv11ms3k7y8fLYBbSFXBPrS+l5wwPse5enA2G0l83A9rtqsWkngH8rL9cX7JMvm2MB2r8YMyqCiNIZVY7h+j+Q90ven0kwFDaZ4mJvXFM2xZwstdF7otP3iTqIlQHAKciM8Cp58QGIaz7+656SlmHq9IZ0XLtFUXhx4/RyDVBcO9iqPvMmJ0eDPZfHr9XoTuPABOjmtyZkakQF5pWOovOWIc9tB5SxU110eiUc6+pKFtgpIhvv7+yfOH/AggK7t7+9v0uib5dOJV1v7vm7JglsTtPyTbUun3IMcvO+yS2CZbeGOHtMlhz8Bv9R/Kl7Tc95ODsKqtiZ5AID9gIBI/CTQ0gt09OxJz7lN5Towdrl7Xml1iW8xSZQAmS8Z9nbyvLwtPXDgvKlunjd5d36SrXObKICmfBJo6dXd25Zgn23Eg+64N9/bT/n6YX9uw/ghuKYMkr0g6NL75Sln1bl6tZ/z5YFnBq11hgcDC9wupfy8DcXrwcHBZixhe1Vb3RLQZTs4sb1FnpYyEA/cdiTbq/s8t2S1unEIp9qAbaEzL7gNMAURpsjtH+vMMSH1cSeODRyvqtfqcgyTnDRmtbYdxEj23uvMevMcBn1XYwj59341l3pjSHUt2beRcaCiqeBEKnNufX08TzwvtNBCdw4tAYIzoOvXr28dmkcaHVj8XorsV0Tn9ejoaMsRExB1J0qOic+G+ACmsjXQuhOmAYSOIAMEdCTTHklf2qt6uINbAXKSrwRwGen+xYsXt/YdTz3rclb6HtFRunTpUtvb29sAfTpbqhcDKlxN4IcTKi3l5Q65HFGvh57nAWV6nnrQ2jYQ9gCCgzMR+fAtJj4bRN7TQZvsB+7UE/C6E0OnyJcCe7kOwlL7VjN/1Syt6pz0w8tI/0f6eXWNdWV/pUwS2GbwgHl52/bqnMpJPArsJr0RHwng877SMJDAOrscqN8k1x9/vzqfSUCmkoHXmXJgX6KepMAJ6+dAnDJjmcyzanO2tw6a1aGMV65c2eQne8WyaJcZjGCfbe0GqGddtZqMY4SI170d3XYISPMQOwZF3fZUdr7XTh5ooHypBwp8OABXECOtKvAAgfg/Ojra1Edg2G3WFFWgUDaWwWvWiecdeB5u/7kKIF2nTvO/2nu1Wm0dAMo+5ecNiCfJywMnrncjNtT7WE+2yaZV/sGuIH4uTelBst09Pe/JgPZxTrBhoYUWOv+0BAhm0mmMpAa13knop+FL+fksufOcnBX/VJR4ddA15bymA4mcPEig/H0wG5FdcmB7NDJwMp3zxvtyogn0eU3p3OnyDwFFD1RO8ePbTZTWg0Ser/OTHOiKJycvu/rNZanVLBd1zdvFQWJynLxcPeNAtSo7pUtt4m1Ryady5npUgYJRmvPsSFmuNy77qm9VuuftlGyD8+h2hwBXRABLPUqAkLyklTKsFwNTrtPef1kO+3rSaQL/Kg/9puxbO/mKO8rSwbae93Eqleezsz1bpHzTtreUr9tDytxXnvkKDefbgwR6zutEchtX9UuNtwxmapxzPUyy8ZUEBMmVLU39sBrvq3GM7dazsalsbxevo/ep1CdJrC+DA2xv19tqHBN58G2KdrG9U8+f1jZPleG2dHSc2aWshRY67zTlm94qHs4LLQGCmVQZTHdOEjmQOGvjmxwQrhzogeQ02KY6pcHW//usbC8fOmuVPKbApr5HHZzEc4+XxBedDyffOtCbdWHZKU937nqAWt+Vw0BAoHqmcirAPwXger+TsztiKFObTrWNp3Vw4KAplcG+mpxnOsKVA56WwU/xnNJ48CLlMWWXdiH2iamyR8qp7ADJQUBvZZYDjgRcCO6SLnDG1OVcyb23VN3bLek8AW3qA14ueXebynKTzjAfXxEhPiogmmZnlT61S89uJf4YKOCsv/poCr4xHz1LXlLwQDyk1WqJVy+v13d1jzrh7UU5V0A3va2F/93+uFy4qqai1D4eJOC19FyVj6/cSfaSbZv6SfXbZTDqYFeBvF3prMF+r5zWan2s/lf2qMfzqL4stNBCdx4tAYKZlByFyon1Z6qI/5xyq2vMSw7HarXaWoLpS7dFGkAVtU/OKPPXQE9Z+JJfT6tXfzE/PkPn1Wezk3Pky+Ep3+ToJhkm4EhHifec0lJmOq6r1Y2zBw4ODsrXFeo57u1kgMHbh8uze86UtyPTaZaQM/R0ZhOQoK54eyS5pz3ofNZ1ZKQfONj2FQ/OD9vJ73F5uf77M+SrCu45EBU5uKJu9OrWK2PquQo0ug6kPKrZYtfxxNuIk5oAusuMbcMl0Wx31zXmy/5UASC3UbKRPVvgs9P6z+fcblTAjjPMrF8lHwIw8iU74HaZZfK+bDCXsWtZO0Eseed5BKyX7vMslKR7KZgh+ek3l9JfuPDQ2SwOWF0WsqsKVOzv72/yUX1oM7lKIgVDPNjjAYGks/7RPV/xpLLFF+urtrh69ermP1cQpJV2lV7pmgcqRG4H0z3qvI9vvoKNK+H0XZ1HQVnKzoh/vfbQgyj8UGZpkoPP+/jE6173arzs0VzQ3BvXqvGPfSc90/NjUr5T9tnL5X8fBxda6DzTWQULT8vDeaElQLADTTnlouRsp7zS4NUrs+fot3bjvcmtPTQAa8+9lpEyLYGbBlZ3kAnGdN8dKPLHQZlgOM2wsE5pIOLg7g69g805gNMdKXf4eN9BnZ6hI5W2AOj8B33LoWYwIDlaDB54mzvI9jakQ+CggqeRS47ij+1BOXCmUw55km0CQg7+Rtso1bGnb5XDT9kmfr1uPoPWc44cvJDXBB56ASXm4XXe1Umsnp+yHf5/yrmsZNQDHASO+hC4STdb294rLf6pi61tH6Dp+kGbKJ1Iq2g0g8s0yjvJgc/pGoEW83b9VP/W81NgzIFnr10pJ+dtb29vAz49QOB9zu2Jt+/BwcEWb3wu6TaveTke8JXN4qGuLg/WW3UlyCYI53jIZ9g3qxUhrJvregKeHgBWYEIgl2BXZw0oUMDD99im/O2A28ntmLdB7z/7iI/xrB/b04Pa2m5BOfNZ8rlarbYCBAzmMFDCwwk9AKC8PBDgOsxnaIOosyS36ZW8RRWgH3nW06WxoMqn6g/edj27n+6N8rvQQgs9cqm/yXahU1MP2HiaOXlOPUPQL+ej2vufHEQvr+d8ez2SA5ZmJXiPjklVF34zfwdkUwDLy2Zad/L8v67xzQT65qsL9ZvXmJ6BAL/mcvLgQKqrz/gngO66QKe0AvOenztxPvOYHDTynIIbSZeSHlHPXBen0nobeoCmCg5MfaoZYJcVX13Wc9ZGPkxfyY759dIwbRXEqMoloE5pK5Do+Ytcz6eCTJ5vFSQQJTvkM6tMl/JNAInPKS8GIKo+48DGZ7fnyDO1X1WnZAvYjyVrHphXrUTr6UvSGW9f8sAgNk+w9zrzTJf9/f12cHCw9bl06VI7ODjYsr08/yXxl+xuJeOkP7QfHgwj8E/11keBAreZyR67DUljQY9SHVPgvxdsoCy4esf5YZ5ue0U+RrBPuDy83tSpEb/A65Nk4/en7OccqviqgHrVjyo7Osr3yJhwlvVeaKGFdqcf/MEfbE9+8pPb5cuX2zOe8Yz2X/7Lf+mmf/vb396e8YxntMuXL7dP/MRPbD/0Qz80u8wlQPAIJjqpadBMlO6nqH1yGCoSkDjtgON1mKpPr57uHLIeCQDwm6940rUeQKrqPgfA9QD81HOpPZNj4g5oemaqHOd1qi69a3Oer8BnpXO9dD1AlvKo/k/x35NxJctdZJec/hSIm0M3y3Gcql+vLefQafivwCXvj8g3Ab4pezaXpvrkSP+oeKgAbJVXj8fRPjFVDwfsKdCTAkmjfbkHUBO/Ige8I3LbxY4mmgseU9Bsl/xbm7+kd2qcqiYxRCPBkduNRmV9M8G6B3MWWuiRSNWYdas/c+knf/In28te9rL2ile8ov3Wb/1We/7zn98+53M+p91///0x/e/93u+1v/k3/2Z7/vOf337rt36rfdu3fVv7xm/8xvbv/t2/m1XussXgjKlqfIFk/917JqWdw8dqtdo6GZkzQlwKqPy5HJ3Oq66T1+Rw8fnWbsyeaSaltbZ57VPPgU7OWs/pouPgsxJ6JnVMtoc7+CpTsyOUKR1Rzpy406mVAVOrEVhfLntXeZSn600FRtbr7ddYuuPF9vGl0cqPe4z1nC/V9DZhGanMXnskSul4LTn5DOBMATW2HduX17zvet2THFKfdfl5+cxDadkurLvrqOcpogxSX0lgd7Rteu3vabgloAqUuW67ftJO+TLoUV6ZP/uZ8hWvBMiUsdtKr4Oe9/ycuEWButfa9uF71A/O8nu/dLvIJdkuUz2vYCd1javMuJ1Iea5Wqy27ro/bJr7CMNlHJ7a367TGC/ZrfrMM2VvJT9uouIXLt05wllpyVp7edj42UjbMy1dA6J5vMfAVGWmcEy9ui8iT0rQ2dnq/j23k0WXqetbzAVI5SXb68FnKMK2k8Hxau7E1yK+xHVy+blMrnis76PJONMc2jlDVZ9w36o1XaRyd4nEXXhdaaKGzpe/+7u9uX/M1X9P+wT/4B6211l772te2//Sf/lN73ete117zmtecSP9DP/RD7eM+7uPaa1/72tZaa5/yKZ/SfvM3f7P983/+z9vf/bt/d7jc22YFwdHRUfvWb/3W9mmf9mnt0Y9+dHvCE57QXvKSl7Q/+qM/6j73Uz/1U+2Zz3xm+4iP+Ij26Ec/un36p396+9f/+l+fSPeHf/iH7e///b/fPuqjPqo96lGPap/+6Z/e3vGOd5yK5+R8TTnXyZj7/alr1f/kJHKfIz+Hh4ebe+6oVM4O97BzqaCWcNJpE0BVUEKDlpZ80pl2p3fKsVHeqhf5T0s3WRcHgSzXl63edddd7fLly+3SpUsnPlrKqs/ly5c3y1p9mSsPJ6RjXjlW7oTywyAPl607EFRdq3dHe36Hh4ft6tWr7erVqxvd0LfrjesS24B7atNS6tRX/F7SY3f46PSp7mw7yZ+yd2K7+7aPpN/cKkJwkpz5pL/UT7ahbz+oHGWXQVq6zOddr72eCbClQBf10uvnAQtP64EPD9w4yKB+UD/Vj32JctWu5KNnO53XFHRwu8Q+LN2gnlHGDsKkB6xb1bfYd2mnk01zm6El68xfdphy5zJ8t1GqF1/J6vb36tWr7cqVKxvboT3/LjvXNdcfjlfi9fDwcCtvyYf64G3H/n/XXXe1Rz3qUe1Rj3pUu3z5cnvUox7VHv3oR2/sumw7xyQGGVwfWHf2PfFc2WcGB1QP1kfPuT729NrTsh8l+1MFFfz8AA8KMxCpuvt4nbYMJDvmtkz9mX3F7aPruusMeUq+i/ePJN/K1lXtkAIdPRoF4LuA8IqPdN373hS/1fOj9JrXvKY961nPanfffXd73OMe1/723/7b7d3vfveJsl75yle2JzzhCe2uu+5qL3jBC9pv//ZvzypnoYUeyXR4eNje8Y53tBe96EVb11/0ohe1X/3VX43P/Nqv/dqJ9C9+8Yvbb/7mb8bDhyu6bVYQfOhDH2rvfOc72z/5J/+k/ZW/8lfa+9///vayl72sff7nf377zd/8zfK5j/zIj2yveMUr2lOf+tR2cHDQfvZnf7Z91Vd9VXvc4x7XXvziF7fWWnv/+9/fnve857X/7//7/9rP/dzPtcc97nHtf//v/90+4iM+Ymd+fbDhAF/NWiqtBjqfmZ4qo7U80KcBT+WkAVcrCHRwE2dVNNOnmQTnmYCAzvB6fWPGhjMzkgudZc3mVAMnZzE5o8M606FkvSuQIkeimsUkj/v7+1szVs4rHV7fbkAQI6eb5aUZMNZRdWN+nob18/xdRp6Webd240BLrgDRrCZ1RPJxGSgPnwVyoKV6OID1e14HOoNsU9ZZZfEQSA9AJV3yGTcHwKwvHW/nyfmqyB1d5d+bfXO5JPmtVtszuJS76yX7cwL2PpvtvCj/kfoyrQd0Wts+4M/5kIzUZ1meA6GeHZH+VsEcT1/Z4opPypABOOan/uH64sEV2vu9vb1NPyS5jqZ7VfCNPLrNYnpfOZCAh9rO7e/+/v5WGf49Ms6RN8lFsiTPfpBreotFaw85WLIL169f3wRf2FbeFypg5ECUADUF1ClHBW0cxFZnA/WI+pLkOwoGk37JllS6532Rsk1gPNlLL1/5eDDBbYfnlwKn6V7Vnj19TJTu9QB0Gq9Su03Z016a1D9HaU7aufT2t7+9vfSlL23Petaz2vHxcXvFK17RXvSiF7Xf+Z3faY9+9KNba639s3/2z9p3f/d3tze+8Y3tkz/5k9urXvWq9sIXvrC9+93vbnffffdN422hO5Pm9o+bxUNrrT344INb1zXZ6PTHf/zH7dq1a+2ee+7Zun7PPfe0Bx54IJbxwAMPxPTHx8ftj//4j9vHfMzHDPF62wQIHvvYx7a3ve1tW9e+7/u+r33GZ3xGu//++9vHfdzHxede8IIXbP3/pm/6pvYjP/Ij7Vd+5Vc2AYLv+q7vak960pPaG97whk26T/iETzhT/klysqZo7kC0SxqlS84MB13/z+cqSrMUFy5c6Do8vix0Ljk/dDr8VW0V8ExEUOi/dZ9OpH8IvvTfQfKUY0Keva6VYzJ1fY5TISBDJ5H8UNasL/Ur8eTtkfjqAbNePUipXaZ0IJWZQIbr7BS/I0QgVeXn/FftXTmfXicHmKetg5c/J3jgvFWAd45zP8Uf8634GC3HgZm3I3mu9D318QSwEu9T40fVH+fUIQUmUxlKu6sD5jbCbY34SvLwtnJ9UuCaYHS9Xp+w2alvV4HZ3odpPL0H2qv2T/13VK6uw9WERe/ZRF5+Ckb09Dnd6/kCPV1y34WUgsn+7JTt4LPVmPVw0RxdOItxalf6j//xP279f8Mb3tAe97jHtXe84x3tr//1v97W63V77Wtf217xile0L/iCL2ittfYjP/Ij7Z577mlvetOb2td93dc9HGwvtNAtoSc96Ulb/7/927+9vfKVryzTJ/+o17crf2qOPbhtAgSJPvCBD7TVajU8079er9sv/MIvtHe/+93tu77ruzbX3/zmN7cXv/jF7Qu/8Avb29/+9vbEJz6x3Xvvve1rv/Zry7y0rFHk0R6SAKHPDFbksyM3kzSAcqmuryBYrVabswG4bC/xVwUFOOOuOvrMC9OrPDmDlRPKcpJT3Vut4TPxzMudJ82CaJml6sM6u+OYgghV8ID30+n50h+WJZ59RsfBjtrL68k05J+BAMqKjjlnCJPDqTarZkZZF5ate8n5Y3DC2ykR5U9ZJ4eOYMGdSult6r8sP7VRNctWleU6vFqttla2pDry2+U2Zex9xUQFilJ51b3Rsp0cJCkP8kPwlsCez1L2AMYojw4ovN9WgG2qDNcd2rDeGCEZ+Sou5zH9b+3GHuzEC+01+y/1L/VP55kzvuw7skW+/17PcoxwXes5PNQb2ibpi5+pw9UgPuaID+alMqijlIEHKGh3faaa35SDbL/GVq+fvnv6xL5Q6T5tDO19Rb6iLKXlyhLy6nLjf6ZxPr3fUz7USx8jUrBlF6qc5eTv3Cownvwb58v1MdFcINHjJdGf/dmfbfnD1cyn0wc+8IHW2kOrflt76CC1Bx54YGsp9KVLl9pnfdZntV/91V9dAgQLPaLpPe95T3vMYx6z+V/1oY/+6I9uFy9ePLFa4H3ve9+JVQKixz/+8TH93t5e+6iP+qhhHm/bAMGVK1faP/7H/7h96Zd+6ZYQE33gAx9oT3ziE9vVq1fbxYsX2w/+4A+2F77whZv7/+f//J/2ute9rt13333t277t29qv//qvt2/8xm9sly5dai95yUtinq95zWvad3zHd5RlukNTOX0VyK4M/S4DTCrDwZ/2PV65cmXjHF28eLHt7++31k6+P1nvzNZ9JwfLykuOBJ0ZdyD29vbaox71qK29sWl5otcxLREn4CFvHujgM2wrHl4l4O6vxNJznodflyx8i0EKIngARc/S0fY6cAm9t6+IS8cTOBUPCbTqGYI0yk9pKB/fUkI+Kqe0FyAgnywzgX62HeVDnat0hIeocZ9r5Ripz+zt7W1kkwIjXj9eS/UXv4eHh1FWDpSdknySXpHPKl2Vn+dTgVTm4fbNdY7tlMr14AB1jAf7kQ+XQQpSkaZsjedZBa4qG+FgkpSW94vENwO4DhB0z+vYqwv7A/eMS5YC0NVrBv2cmdba1rJutg+D6+qfGh+UBz/OM4my9z6muri98QMN9/f3Nzzq9/7+fjs+Pt6cL3J4eHhiiTvbxMGp5KPxi894wKAXmGA9XQ4pGFCNPSkvDxZUMvZANdOov3kgswqYsM7ev0U8QFflyoegjD2v9N/r63V0W+Nyqny0XWhugGEKzPcCArQxrZ20z0zfCyZU6cgLy/nUT/3UrTymZj71/H333df+2l/7a+1pT3taa61tAExaCv37v//73fwWWmgXqsb8W81Da6095jGPmcS2rbV2cHDQnvGMZ7S3ve1t7e/8nb+zuf62t72t/a2/9bfiM8997nPbf/gP/2Hr2lvf+tb2zGc+s8R0iR62AMGP//iPb0UIf+7nfq49//nPb609dGDhl3zJl7Tr16+3H/zBH5zM6+67727vete72p//+Z+3//yf/3O777772id+4ie2F7zgBa21hwbrZz7zme3Vr351a621pz/96e23f/u32+te97oyQPDyl7+83XfffZv/Dz744IklISR3lmlcRwegajBJQYQRJacjc3h42Pb3908ECAjwBJroAHK22cGX0uq+HMAU2ZdDq0OvLl++vOWAJN5FyWnhDJjqSZ6VB/kk2HAQ74c1JScsgXo6rHyWQNr3yjpgo2wrB1PkB4ZVyyldHx2MOe9eR18d4ECNqytcXlPtSkevxy/BfZrNVdkMFOg69TABOp8NVT+hrBJ4JR8JQLCelC3v0/klv06r1fbqgirQ5PL136y/92fqn8rg86yn7lFOFVVgmWeS8CwSpfeVFL4ixGdpq/6Yyk/O8GiAwAFNFZRIeVXAr+q/usb9/e7063nKU/f8EEp/Tn2lshkK2ooXzh7zzBnmSWDo/PLNArKJDDJOrbiTzjIYwZUP5FGy0DdtPYkBAh42qVV2h4eHW+Wx/+jjh4TyEEg/NFdykhx6qwjYTmwX1s37awr4ep6Jko1L44PbELav9+0UIHUb7Cs+JBv6EH6YVgockMepurpdpxxdFlP59PJ1m9bz6xL17Jrf09iR7NFc6j3De7/zO7/TnvjEJ27+j6we+Ef/6B+1//bf/lv7lV/5lRP3poIkCy10p9N9993XvvzLv7w985nPbM997nPb61//+nb//fe3r//6r2+tPYRX//AP/7D96I/+aGutta//+q9v3//939/uu+++9rVf+7Xt137t19oP//APt5/4iZ+YVe7DFiD4/M///PbsZz97818G5+joqH3RF31R+73f+732C7/wC0MRlgsXLrS/9Jf+UmuttU//9E9v//N//s/2mte8ZhMg+JiP+ZgTUc9P+ZRP6b4TsrdsymcPRaPAvWfER/Pg83Q4U94avNJpywRTDqx9prOqCx2f5JCmZ/yk7xFyJ0PXqgG1cnD0HGew/IR3Efnzped0gqql7vzNOviAn8CLvqeWUjJNyqvSjaRnDnqZpz7ukHjb9xwxdx6pJ73l7+m3b9WonOr0fNIl6rrqmeqve9IbDwZ4W3sZLueR/sUyp4DoFOit7Ivz7fXplZnqUck3rehgH6vqxzxS/+nRlF1Nuio+Pbgw6oz36jEFHlIf8T5VBQjcXiWbzLoxLYNlHkjSc9yO5rJ34MbvarXAiP2vAJLnQ53lqoJ0OK2e8UDmarXarAro9WHV1cdPpvM2U0AjpduF1DYpyDICtFKAgLqRdLCXT/VfZUzVpVpVksqr+g1pKp8q7xHQWsnX+8ytojm+Y4+mAih33333kF8u+oZv+Ib25je/uf3yL/9y+9iP/djN9cc//vGttYdWEvDQtN7S6YUWOg2dxtaeJQ9z6Yu/+Ivbn/zJn7Tv/M7vbO9973vb0572tPaWt7ylffzHf3xrrbX3vve97f7779+kf/KTn9ze8pa3tG/+5m9uP/ADP9Ce8IQntO/93u+d9YrD1h7GAMHdd9994pRSBQd+93d/t/3iL/7irL0SpPV6vbXE8XnPe96J16v8r//1vzbCPUtKRnqOQoykHRkYe/fd4eRySV+6Vy1hnSovOdS9tJohSmV44CLVpcpzvb4xg8XZ/bR0m3xOLXv1a8wzlZOe9XokUO/y4IxyTxY+sM/RyyqgIPJtB2mmPjn0U+VX/3uBAv94Paaeq/57wKNK4zSn/470IaZLQYKqbVM+rIvzkvrACG9zKbWVB96S7jpxZtfrR9A7FVzr0Vk72/qf9DS1SQoMeMAi1a+ykz1w7d/V7HsPnPM3+1BVN/E/1Xd7sqrqTRmxHE9byYIrMKbsTGv1DPaIDvX6b6+9KvCb2jOl8bFpZJxKIJl6ODKTP9qv3CdIQYsqGJVW352Wn9bODoTfbDoNn9V4Pdfmr9fr9g3f8A3tp3/6p9sv/dIvtSc/+clb95/85Ce3xz/+8e1tb3tbe/rTn95ae+iNI29/+9u3zhBbaKGFWrv33nvbvffeG++98Y1vPHHtsz7rs9o73/nOU5V525xBcHx83P7e3/t77Z3vfGf72Z/92Xbt2rXNHqWP/MiPbAcHB6211l7ykpe0Jz7xie01r3lNa+2hswKe+cxntk/6pE9qh4eH7S1veUv70R/90fa6171uk/c3f/M3t8/8zM9sr371q9sXfdEXtV//9V9vr3/969vrX//6nXitnDJRcog8rTtRVdqUZ48vd9ASaeD0lQQ69Ono6OiEE8LlwByIfZ8qeSUv1QFHvO+zyykwkBwDlrtarTZ7bHjf97z6O+95XoAcJ7ZTcqT8nrZP6BqX0aZ2TGDa68MtFJrV4351X/GQ8kk8p3uSU2s3dImOteSh5bPKSwEDfXyZul+reEuyYJ5eB28v5jXlPCfnn/xSVx0AMR37mfc5B2rUW69nWn2QbIq3CcvpyZW8sm/1wFYFNHqg3MtL/7m9x4l9j/IhcZuE8nYdGJ2B9PbiPV6rAGKyTele6hOuVz7jr7pq6XqaeZYukE/Zcc/L9cltHK9zX790zscXpbt27drW3nGW0Vr/wFr9r/qjy4Y8uizYv3r9h31OZafVZK3dCIYmAHx0dLRVJsEszzHwdlN9fCVWsjdOSaYpbbKRaUtHstm8Lt2lPnl70p/g70ruekbfU+OVb+ngeMjyuKVDW0Wq7Q4su5LjXIBdjas9P8zb3Z+v7jFfLyfZ495zU/WZSlfRS1/60vamN72p/czP/Ey7++67N/78Yx/72HbXXXe11WrVXvayl7VXv/rV7SlPeUp7ylOe0l796le3Rz3qUe1Lv/RLdypzoYUWOju6bQIEf/AHf9De/OY3t9Ye2iZA+sVf/MX2ghe8oLXW2v333781mH3wgx9s9957b/uDP/iDdtddd7WnPvWp7cd+7MfaF3/xF2/SPOtZz2o//dM/3V7+8pe37/zO72xPfvKT22tf+9r2ZV/2ZafiORno3iDjg6oDjCptyk8D4xTwSkA7BQZau3FiPSP3csTTssO0NNN5p1NCXug0CShozyEDDwlU8T+dVt8O4GCRjpDA+/7+/sYp5HMVuPFrBDvKz+uewJMP5ty/6Y6yrsn5cafLzzig45+o52wzb38PewKz/CQHVCS5OBBJMmFbe4DK5c5rKaiQZM9vXy6dnFim5z0HVxVRVytdTu3u5dNZp3M55RCyH1BGaR90etbTuP4kmXk/oqz8rA/m4dsgPKDhsuwBn1QXtymkKmBAOVCWKdhTBQhUf7Yz+6jbILfTHohNAQwPbHr7uV32b/Hp7cL99KwXy1SgwMEYy/DxiMv4eQAidSet9PLgh+uH67v3VQftblNauzE+MFDq4xLLViBH17SVz3Wg0ifWp9cnWffkT6T6UKZuR5kn+XBbymd9TPDAQKqn1z/ZQtaR/BH8qw14QCTLVn/Rh0EC5u+BpGTf0++Kkr12qspJvqDrgtv6alyb+u/1quykp92FNEn3gv+/7y56wxve0L7yK7+ytdbat3zLt7QPf/jD7d57723vf//727Of/ez21re+9cTq4oUWOgtKfefh4OG80G0TIPiET/iEIcH90i/90tb/V73qVe1Vr3rV5HOf93mf1z7v8z5vV/YmyQ27rhHE90Cbgy8/rMsB1FzyCD8dZc04afk6Z6t7S/wqXjio0XlPsymctUmyUFlp+wF5oEPhp21zVtxPvk/lV45bqiMDBDyFmWnojPD5Ckx4meKHDqg7z+JF9wkiXa7ukCTgkICnt787qwmsKR3BqDv4U85LAg2+cqBqn56zzdUXyfGacnRdz6d01MEur+ua9xeCSq9fkpunc7k5uJsaMHvyY5rksCYdTu3ngQuXHWVFkJmA6ijfU7a0smsJnFb89q57vq1tHxBKMJpO1a/GG/LnQScvj/dYH8pT/wnAPSjLsrX6jDqbZpzdrjvwTPY4gSbmyz5UrTBjOubhdssPPmUQwAPzDnZ7gNl5mUs94Jjq5HaykqPXx/NiOi+7tRtBfT7rbeh9zuVVycdl6c/7SgIFBnwFQeoDlU821WbV/WSzqnJG7ILbdh+Xma+P6z3q+aIsr+prIzTip65Wq/bKV76yvXLiLQgLLbTQraf5J7gs1Fq7+VGgXQzyLpQAzBSouVmUZu9HKD2TBjefjdq1vKr8HiityhjVo5QuzcDQkffnU9tOldPTB9eZdF3P0QmcAmdOFbiZorSSwZfLVh+/f1oazadqvymaI9O59aoA5txnK/mm36ct9+GmqYBBFYiaynPkXuqX3h9HyPtEms33tFXwL/F72jG0qpPbmik75c8nSgDc//d0mTzP0flRnm42JVs6NZachio5TJXj9vNm+2lO58lGLbTQQgv16LZZQXCeqQe0elsAdiVFiH1JrS/PTTxp6d3Fixc3M9JcLXB0dBSXxlcBguTkpOi0+NNZBGlJtWZ+OOPP+nj03J1SXx2QlkQyrc+wJCebUXsvMznNTN9zEv3TS1sth16tVlurPXhtZAWBO1G65o6zX097blP5Klsy5gyf647/7znhPZBCfqol135fvLluJn1IVAVGnG/OlHubeF+unOMUsHNg5v1J7ZH6cK+snrPLvs7/TlzCTr6q4BzbSTy43CQD7g9XWi6hVrlV/U8DpL3PsO9XgNT7nJfHV87yek9vkj0U+aoUPUcZsx1cb/1bsta4sVqttrYdSP7+CkXvx84reRPPlAXzT/3fZUOdUJ5cwaTrrLvS9Gb89TpEPc+zbvw8AhHH2CQHrT5LdRgl10EP0pDY/tzu56siki7Rtisv9inWXWl7upVWS7le+NjBcryv8nfa6kAZTNm39Nwo7fJM4sdtXvpdtbHuVTZsyrbf6sDKQgvdCur5cbeSh/NCS4DgFJQG/DTQa8AaDRZU6dwZTEC0NygqAKBD7vhu69VqtXFymH69Xm+Wz3PJoDsT6Ztly8nlYO8OqvZ9Hh4ebpxPX17tzrCDfIIE7s2nM0KH2Q9Kc+chgT0FOqo8ExhlXgQ4dLJcbjzkyrd6eD7cKuGg2In3va6u06yLeKgOpvSgAGXD/Fhn8pzApJeRyqHz6EA0Pa+60vlkejmXfA895U4Z+n0OQN7+upZWXxAYuqPsZfgSZu8LfNb7G+XgdfYyUh/vAZlkf9KrTLkFSHkmsOjgwgG39FFbpGTPvC+meqjOvnTZ29DJ9TeNAcyXz/CT9uunQENrJ7ceOD+uB0qTVqPQ7rHv8Z7rrWy3ytF5A3xNrsphX0/gzW2KiDyrngzwuW1w3WEQJdm/dC8dvJuCSBqbrl+/vgXmDw4ONuPi/v5+u3r16kZODJRoyTtJgYE0vqVteBV5fSijyo6wDNcpD5bTJnELIp9z++tBhNRHpEO0Q2wj6abrtQcBaAv9vI6qH1fX0niTfqfnk32cAuc9oMB6noYqvivfIPExmnahhRZ6ZNESILjJ5E5zAp8jA0aVdyI6VCINxhcuXNg6nFAD/2q12hwSKOJAn/aKOrhITn4KYiTnnQ7O/v7+CV6Un4iAWN/Mx2eIVa6DUefVZ7mTvFmuO74JJLEMOtOpPDlYPBjMwRufd3nQ2XLn0IMCyQlJM/2+qqMKENCZUx5yqF0+7kA6KHEAm/THgacHBziT6WCHwMLbzB1MtlkCxAnAMg3rQFClvB1Y8llvc7alnpFe6xodb+bvoMGdc8/f28b1xq87iS/vK+yDDh5TGzsoIMhWfb3MZIucPECQ0jlvqY78TR4T+CPY4rUkb/YhrkBINpVt4HrJ8nt9racfAr1VMIKA3nWm96Yb8qG0tDUElG5HaaOZ1svyFQTiT8HhtJrN8yCgZ4BA/DIv2k8FGS9cuHBCTyUvrlwicKdseuT20HVDMvH2IrBmoNxtuD9PHWBeHDvIfxoj1X7JH2B9PPjO8vjfg3zer5mW9ax8M5dtz45M0VQgoLItKQ/y7BMPnq4a453crng5ZxWsWGihhc4XLQGCHejhNJSnGahau+Es+UyAD6pTs2vVDKN+Vw6hg1ZP4zMQU4OnO3aprOTwOh/JqUyzIMmpGam/E4Enn+P9Hjh1nlPaxIMP9ilPd/wIaCuwKrnyPwFqAp/+O8mhd93bcEoXPI/qd1rlkt7YkRyz6j/1J8nEeZ5qF79OUKVgWaWDI/o5h5if88g+5+A2tXN1TWXQmfVPL4+Kkk4nnexRkqf6Y2qL1Bc8kJN0I60G4f1UN+ZXgapUF9dHzfh6oC0BvNZOzhBX5OCvtXai7yV74fpQkQNvl6fK82tJhmkcWa/XJ1aurFY3gg+p/rQBLnu3E7o+qo+pvKr9/ZvPVrrD/pb6YqWHU7ab16rxe4Tm2rWztoVzynPZj/BxVvW71fVeaKHbgeaO7TeLh/NCS4DgjCk5y3NoasbgVigXZwH4oUMg8Jf4GuHRZ6rdWaVT6ntaW9s+Q4Cn0evZHpD362yv6vTsKUclDfIJNFB+PuPiS9wr4JKMnP6n4EoKfkju1T09r3ZPs71VACLJwWfpErhI7ZWWy7ojT4e711aVLrgMXfbeHkwzqh/MX2VLfytwm9rPAwWVQ+4zfEm/TkNeV7aHZMPZP2/zBCqr/sp0BE2p7VQ/lsk25Ladqo+lPNnv0jL0JB+XSZU/A3spvwTiWzu5wod1TpR0NPV/D+Yknh0kO7iVLa3qlGy0dIb5J1mp7Ub6XhUIae3GyhNf+UR+qCNcCeH155J4yUDXNIapLKX3LUysQy94XNW5B8IruzR1P5Up2fRWbVS8i6oxjDL28Y5t6RMZfGtB9UrQHn9z7OFpwHVlK3Ypu7L/u5Lnddb5L7TQQueLlgDBTBoZGNJA3ZsRHx1sRtOlMjzwkECPl6UBWHv7NGBwOT/TusPdA4HJMaHTceHChba/v7+1D7Fafsjlp621chsBgwourwqccPsC09JR5Mz5CNDwNiF40X9/TVNqm3RdS9i1zzs52ZKjO6Eq28EGl+uz3i7DVMcU+FEa8kjArPLYXkybgga+190Bmq4lXUyOqLdHbwWF65rX2fV6tbqxrcfBWI8q5zI5dtwSpHK0V79nRxIviS/vM94H1+v1iTbUdc4yOy/+eleuKCJgpR46UFE9W7sBtNSXtEc5vSM96QDro/z8XuJJvBPwTQVmVM/ULymPyk4xH36zPf3bVy6wDV2GCRyn4GxPj12m7IMOvCqgfvXq1RP931ci+LO+4q21+gDB1m7oIbex8Ewc2SSukuB4KeLWAx6qqXyYvgrYVkHSKiAwAurY5r59g9/Md39/P+pNKj9tX2G5BPmUW/r2VYy8r358dHS09d+35nm99XtkPHN58FnvW8kupPbYJcAwNx/3v1rL7VY9u9BCjzTqYZ5bycN5oSVAcAqi8Z8Tba3A1GkHlLmBBu8sBCsaSHyfbxr404xaNXjKeUhLZX1p6f7+/tZsER2ldOaAnveTzAVK+EkzNO7YKF85edw3rO/kSLiT5Y66g1OlSc6S/qf2o9PrZ0QkXeBzDirIt68wcNBGmbn+sr287krT2snDIcWP2jgFCRII4IfLuVMgiOVXANjBSHJQmY5gMMnaf+s/HUyChOTk92xEAgS+15nP+AqRns1wXhwgss106B15dgDJ2Va1pdclzSqrP6stfIk228K3bxBUXLt2besgOV967m3m/0dAPmXEoFqlR5ILbWlaAaT01coolwPzT/vvRW5bEi8JHLH9kp3nNQX3WBYBM8cZBpJc9rrGtyhUtoG8pvykE/rmuESd8zag7eS442OnniGoVjnSRdWFAQzXR2+3VE/XCda7B3yT7WRdSTqoWORjmgc604fktpRBcV8NwDQK8jFAcHx83A4PD9v169fb0dFRGdDt2X4fs51Xl+mUr1WlmQsOej5hyjPJ2X2NXlk9HhZaaKE7i5YAwUyacg4JGOY440x3Wr6m8qCTWvFEJ4qON7+TM5fIB2Q6Fb63mwManVBfWswAgc9QJmepcqrZTszHwY+D5zQ7kZzQBPATL1VwoHJcyEeaPew5JwmwJn2gY0RA5rLulcVAE8FAWpqcgKevEknluSNKXUn9wuuRZlWq9nMZutNYBWd6DrsDXt5zB9fL7ZGDDi/DZ4gTv4mf1Ga+0oZ1U1kMHlXt5cAz5ZX6jsjBKa8xKEDQmdLqt+6xX1Xtm/Qy8cD8HIhTHikwVwXJEu8qx9uKlOxKz7anPpQCBCpXtpp6WIG21BYuP++PXN3keVR6onYnCKUuErAz6OgA2Ps6zyI4Ojo68cpH7+dcHUc+E/kYVq3aSG1MWaVyes94fb0fuM/jvHn+qU09Px+L+Jv9h23IAMOUb5PoZoBgt9ej+Tuo742xc/zF3vji+S600EILLQGCM6Rdwf1ZlT3HsCenOc2+efreIO48jAzUDgjTDKHIl9dWjuAc8pUMVf7JUfa6uhPUA+Re/lyHplcfgo7Er7dVFSBI9XEnvOI5OSOiauUCqXIQp8jbxO+R/zlBLtbD658cucoJnwL4I9dH9Lzqw85/Cg70yEGKg30vi+n8t9cn1dGdZb+vOriO9GxXuu/XUj6JUl/y+1NA+CzGjV6AIoF6t3sJbLiu9sBOZT9T3Qg203O9fpvaWeNY4pO80DZy7PP8fEUAy+mR2zgH1vrN8Y5BgvX6oW1XfLtQtTLiNORt7Tpa1cnTT1HV/ruMcykwwrFzrh07C55udp69sXVucGAq/15eS8BgoUcKnZWffVoezgstAYKZNOrYV8vCz2LQGAUI7kTLOdKMiZZq6pWCXObsgy+Xdcqpqpa70pFLjqjzt7+/H0GjO/6clfJZbJXhwERER6s38NKJ0+/kcPLb+faPz3i5g+qzmhVvJJ8ZJo9yLCkvz4tlJbBEB9kdcDrrXn+XTwIMCUxyuTfz91nwNHPm/CS5e/318a0c7jT1QE4CehXwpl6xHB5ilvSzaj/ywGe8v0hmvM8D05x69imd7UHAk3jlyo8qSNDTlyTD9BpD2SgPJkgeWo48J5jQI6bhWRVu85jOZ5wJzCo9qyjZIMqXedMOKI0fmpdWu7n9cL1i+qqNV6vVieX6ov39/RNlsgzWgf2T5TOwXcnJ9Ur58AwCgnXdm1oN5Hae5WgLlfbGc7XcxYsXN/kfHx9vXp+oMw2UlraJZXJ8dnuY+KSsfNUU5Vyt3nFZ+3iT0nm/n6tDaSzmIZCiZO+YZ4/PuVTZhHS9GhvJmxPHlKngQI/HNDb1+F9ooYUWSrQECE5Ju0RyfcBvLS+XJdEpcFA8ypvv89S+PQ28Fy9e3DhtGmS4/1f7JTnTz/2fHt2XY6607nysVqvN8v29vb3NmQNp/6EvSXensZKFOxq+/FF5pgPxKAeRz3x54IGAhACCDg4BcTqIsNIBn+1Oy3ZFCvq01jb7wwmKp4jAS8/4Cg4Hpz0wLdnzo2dZhuqVAi2UJWVC4K3ykmOdZKk6Vg6c+O6Bdv0mb74nmf3IHXP9d6DpvCY99/7E67pGvtx2zLFd0iM/pNT7V3WdVOkMAycOVJiOASUPwKUgnP+m7BxsVaCDvKSl1n5GCfuIb+dQ/aq+mJZp87fb/6SPXpe0xJz78Mm7y8UDH/r2MYBL6t328jrbl6BGY0zV91mnKsDl5buOeWBV45zrG3VMcqAuO38qQ/1DwP/4+HgTKFBAkIEBfQ4PD9vx8XHb39/f2lsvmbB9aJ/9EF1vYxLblGPQtWvXts4Rcd+B7eMy4QGxyU5S76p2oy7xt+qnNkpnElRBiwps93y2lN6vVT5bZYtTGVPk+fTaNfFRBQlS0KAaI88iqLLQQgudX1oCBGdMI9Hk6prfTwaayx8rA94rj2CBKwhWq9VmBo6RejpjDmh4iF9yJnwGKgVFeF/566AhdypbOwnsWFZaLp5AitfNHUk5J9WA6c67y1lOd5pRZBrOaPaocg6S48N68Rl3/vzbZZCAAuvuzrTnQ96r4ADz4ess/eMzhJRHmhWrZMT2JilIk/Z8u34mcJ1AbgI/fl/ydCet4jPJ1wNEzLsCuXTYU5uz7ixXe6r9jQUiOvh6PgUOvI4pWCOeEphgsIugkuTneBBIsG5JdlP90XmlDlfkM6qysdUql4oqwFAFCFSvBJSVtuLDr3mA2sGf9+1qpUgC2OLDA4DUYbYNQaF/Up096Mi8Uz8lT3petoY2R2kZBOeYyNVxGi9l6zxgzNVER0dHmwA+xxTy5jQVHPC2VP3cHrHO3gYMZE6Nh5XOpf7lbUUefAyhzFPbM89kf/V8r5/Qd6EueDrXpVSvqr7puaSD/kxFVVlV2XNo1CYutNDtTHPG95vJw3mhGuksdOa0i0N4VpSUks6zd5wKfFbPV2l610nuTCTQ7tfT8kp/LlHPoWEeu1ByGJIsq0/Ka9fyEw+Vc+y83Sya48QmZ95/j6br6W/l5FWzuL3gwJTuJYA26gRW93p17tXP01Vlpb41ymNPVp5mRA69/s36plniEVnoGadeHxnNd4r/syQvp/owPb9bO1mvyjakNk+8pN+9vAhMSYknb3t9+2/+7wUXUv5OrmusHwFtujby8ZU6p6XRcdhXmhDMzh0bbqaOt3a+nO2KVIebJavT+GULLbTQnUvLCoJT0ohRV2R3BJiOGu2es93a2AoFBizciUqnN/fy1BJ01oOzKs43o/D8rNcPvRrKZ0z4rPLjaopqkHXHTOl8povLJF1O/O1OK5ffVs6zr1zg1gJfCl+Vzf8jjhr5pE5MgYIecGGZ1NUe+ODSY8q5+qS29VllL5PlJEr9irJM4MVXkEjmPRDr7TwaBPH8EnjrtfdoMKL3fCVXrhaotgv4c5VezeFjDt/Ub+9XvoqgCpp5kNO3L/B6BS6n2ih9+IaUZLuTPXIQLf0YCU7o2+0g7b3b4ymaCpb0+p74mbIhPZl7cMBXzCQbzHzFg78elLJy/fGtKq1tr0RK2008oL1aba+a0LkFPJvh8uXL7ejoaGtLgK+aotyVp9eB36q7eEpjMGXDbShuBz0I4v+93V1uHmBh2tR/tfLO314wNckxx7eq8mBeiVgG+2WvDO/LKb+5NrFXXvV/oYUWWshpCRCcgpIDTMPfc/SqfKp7dHR6IHYkTz1Dh4oDrjshSpfAN8vnQYYi3xLBPaoidyh4JgIDDe5IsHyfxWHeviSZ6QSA0j7O5HBUy275353vJOsqQODLrXnNHd9U5+R0uSPOGarKKSclp59lJidTPGuJbSqTsqeDrHKoT67/DEb5klhvf+c1tWNykpW3toJ4XyRxv6zalSBATndahu5BirSNo3IWe87qXGJbeNDG7zmlrQQVH+k+9aYXiPLnxGMC7q21LVDT2rasdT29k16UwIwHFFLwwftzko8ftqjf3IefZEJdJIDt6QLzp0xTf1K9vK4JcDo4J48KBjLoQLm6vLiEnIcEVjbWZc+2pq2tbBy/feySXKhHomobhPq4y269Xm8FYHj+hOwLDzCULdzf399sN7hy5combdI3yjTJlb/Zn/f29jYft3/KU2VSvtqyRv3x30mf/OPnSrB9fazUuQz+SQGC5I/19E9pkq1Revcf/Fkvd1cQnnTLf/d4cb57eU7xUMljoYXOI52mX54lD+eFlgDBTJrr/PaCBJVTR3Ce8q+Mfc+I+zNpho2HJwms0elwp5L8trb9FgQ6I1yRQGfXB28/yZ2O/2q1OjErQ75SvirP90zTYRWATc6BOy0kT+szjWwn1UNnKwhwUvaUlZfDIEvixcmNoMrjbD5XTLjjTIAqIuBlvVlX6oWcRA8Q9IAnA0IqW0BBdXbQQV7ooFJWDj4pZ+c9paV+OThgudJxggnqWgJKJAfffrigp+39n7qe0qgODOaMriBwGYw4mAm4jdSDsmQ+AhOUv4Af+fR+lAIL3occjHrf0L1UB+qU5Om2lDpCMJX0mXIlD+x/ST6VDBMoZlDWgVcaS/jbQbX+EySTR+ZJ/SEvbIPUFj7LLT3gYa3Ubdc5HzNcf1muy5X3GbCi3Fgv8s+DWWWXFEgUCNeKAr6dJp1fk/Ta3yDh9k466cFbb1/vVy6ryr4zH57NU63G8HKZpgoOMHBBm91zxNnmlR9GmfqzU3n2KNnEZDMSf95np/y/NG6kZ0b9yIUWWujOoSVAsCOdpRFNs+Nzyu0NcL1n6QT60r9R4oBM0CWn1nlzUJccz/Tqt2owdQcvlUdA404pnaIpp8Lz9oG7Ih/Qfdlkep78END2yqj48JUKCSyIEvjr6VeVnwOi5Dz6t8tWeYl/8SfgRN2jzCo+GWhJAYYEVr2MJJ+q/p4mybXH76jDeRpyvlI7EdSmupHf6n5K33O+pxzWSp4CEg5G9YyvyqHd8JUDHgRI3ykf55Mfpk8yq/57Gcn2pH6a7KcT+x/7VwqGpbxZtgcTKNcEvKs8e/qWgjd+TzZDB+96Wm+TFBRxHXWbTbn5+EfA6uX5dQWxuNpEpJl9bUWpJg5Yt6THlX2uVv6ID75RqAqA8VnXXecvyVO/E9/+4WoRrkTwvKhnPR2+2fZ1F0rjzs2kkUDJQgs9EmjKx79VPJwXWgIEtyH1nIDTEAed5KilpZsEY3SOfQkhf1eOI8urAKrzpPsCm3SCHMQlSiBQ6ZNTlPJKS44pi6mB3AMw5K3iu3J4nA/WaQRwMh/xziXLBNGjQJCy9CXVvFY5j1POPnnlkmHmw3pQbg7IvOyKPD37iwdrUl9IlECgO7KJxzl8j5Qvnr0PeJux7VL5Pd2dw+sujqnbE9d/X8XhPFcBUc/Pr1fL3VMbud4nkMbrCSAmG1HZjbkyZDtXwN2BtJfvvPjzCfSloKjLO/HjfZtjVFoFwnx6PPqYJ1uSnnO7zPGN9qfSH9cB2ih9M7jFgA2X7qfVGCJOOFR9dkSH0pjFdCmwm8ZZB/lOPT2o2tmfezhol/LPCvTfzLovgYKFFlqotSVAcCY0alAro17NIpN6+feAZq88fWsGQ4cDcuaFS7vF4wgYp4OnpZHuPLszkJwzBzByEHxLQeWAJADE38lxTEtmq09ymt3B4QyMO4oeDEp1qtrXgyTugCuf1C5qk/V6vbXdQDImsE4z/atV3q/uaX1vawIXBHV0tHXN6+qBAqVVWb5ihI51BdIdqIuUX8+55UxrL7iX5MsyVUcFwqjjynvKMayc/mpJsbfp/v7+VpsmAECd9PIICpjeeaOc1eZVn05ltNa2QIP6GPdze/pKRszDy/byevL3tldbet+gDPWc6zHLlb7zINgU+EqydRk4YGY7ss68rzp4cMTz8udT8NTtkz9LmdDGqk8wP7a7A0iOE058nuA+tQ/7rJNvoeDvCvSm4OLe3t4WL9pWpWfZL5mHVtr5OCW5VmOH2wGuFOIYy1fx6jm3+9SfStYJ4Hs/VxtqGx4/fs6At7vLmP8rf8Xl1AuEeHrPw8usqOej9fqs//d+4P+r/Ef4Sfa7teltjQsttNAjj5YAwQ7UGyQqcodY+dAge5o0KHmeo2U50SFWgODo6KhdvHhxs0SXAM8dn2rAcYfEVx0QsCUwW4Fupfd9jHqOjgfrLkdI+dFZ93zJA/P0b6ZnnswvOUW+LJlA2OvB+vEZOrRTRP1JIFjtnZzw1m4EhVS+A2oeVCVHtwLtFVCkzNN/P2TO6+Pyd14TOY89gEWAINBD2fK/DihMeTo/vT7KfsD+NhVIrMrkNhq1s84Z8RUfKWjg/FIuSpN44/NpebK3K/tDanPmT1CRAIXSEGgl2bTWToAsXfPyxKPkpWsp+EQZSc4ss3dAqPd1lu1l9fpUBThYjrehr9ARry7LpGuSIfu7B1UcbFa88SA/lcvATwoKeXluX1VX2me2Beuu3354Le275+Mrr3zcrMa2/f39TV1VLoPZq9WqHRwcbK5JD1R35S9wzfKSTno/T8HC1h7yB/zsAaWTTvfOsmE7pLMCfJzkdgZdVx3JS5WfU+/eXEoAPPUDXk/PJDuWaIrnUV48fWXPe2kXWuiRQmdlD07Lw3mhJUBwBjQK5HuDwWmUpud0p7LotOs7OVfV7MQUQKETlgB3azdWA7jDpbLTbJzzLV6U3h1Cd4oIluj4eb28rvy4TAgU3Pn0g7M4SyUZiNyxq4AoeU4AqiJ33AiEKmeml4c7ljz4sALrLDc5kuk3ZUdivgLmDjqqGUF3ZMVPAsHpN/ljO/kqmUp+nJFMoNtnWMl7kpOXwfs9EMrgjdqM11iWXyO/3rZTzqpT5UT7NdcN2iWfSXaAlGa/CXh9FQGvk0fO9Hp9K74deCVARX6YTjwdHR119bE39lB2FQ+i69e3D5RNgD61L22k2xm3YUrDLWP69kMunUfXy7SCgERb5PVUWzoAdrnp21/9S2DLsYVBDfLqsmNb6LqvLNJqEtlYjnG0bR4wdxlSBiqHOsAAIYNj6ktu95Nepz6Q/IDkSxD0V4F5nxxIY2IaU3alqk+xP8nuk4fesz0aAe3+u0o3Wr7bhpG8F1pooTuDbs5m94VuC9rFSa+cOk+XykrOQnLuEuCbIl8mXgG99FzitSLWuzco+/8esEj1PYvBdtRpOA1Vbar//PZrc/Wvqo/Ltro2IoMqTS9INEpzn6nkWAHGOfLs9cVqxi8FOKbKPI3ezXm2F0RK+SSdmAIpu1LS9QSedJ3P9PrUSJuN8DZFybbtYqN36fOp/IqvXeg0PPVWkE3pXZV26nnyze80/vG360laRZXGQpbBOiTedgG9ni+JExRV2pG+ehpQfjuS1/Fm1GuXPB8p8l1ooYXGaFlBcAbUc0J6RnXk3pRRTvcTP73INGdC/J3CvJ9m9R3EtLY986TZEc2u9JZg93j151g2902m2RNfrql6VxHz5MgkJ49pV6vViWWPvrVAv7nFwIkOoa+IIH/uOKkuydmbM6vC7QK+lJSf1Wq1tXrAZ6TFU69s1T+9Pkt1S/emiHVO8uDKFaajc09dZVs6f4nnpIO6L/IVNLyuPLgnmP3Jl+KrDO+Paiu2C9uQYCIBVxFl43Ji3+tRz/54XZIMdZ19yj8u4xSo87JVDwfEqV/pm5/U5/QcZ2lbq1cOOLjT87omXXD+EoifM97485UcerbabRl1Sjz2+iLrwrIlW7av90OV49sA2MfTuNLTVZcnQaz6TQJwshcaB3wlEGVTAWWmW6/XW7ZYZxDQJqosjil6+08ViPBxkdvE9Dz7E20KbX8a9yv7Rz3wsZTypQ/C8w/ol1AXErl854LaxPNU+mocSfmO8jVlW0TVWDNVPp+v7Pscfhda6DzQVGD2VvFwXmgJEJwxJcdgxLieVUR3aiBK+1t5BsHe3t5mb7r2OWpgTyBcoIP/CTAEmLl/UnnQmUyUQILn72Ccz6VZvAT0K2fKrydnlfXUMwmwTDkcaaCXXP1EdueVwMV/V84sy/S2JIDc398/4Uh68IBBhNReqazWbgASDwKsVjde/TXVl0b7FtvQ9cFllYB9pTd0qBxcVU6jg/lK9wg6BAamACCB6f7+ftvb2zsRDNB17o33PlgtkWZ9uPy44iutnElt4eWkvs/+l84fSMGBapZSfCd7ncp2EOABJg+Ksl8Q/DOoqbw8QFD1UQI/gScH4u7si7yNGNzRf7el3g+8/ilPbk+owCll6rY1OU8OEskD82YeFe+JH17zpevURw+kyeZpGwDtGJfs0965HNKYQH3gK0b1WwcI6zBD1VmvQvQgGoPW4kl5yxYwHx70yfTpt+tANYam9kxBgWvXrm0dVKjzB46Pjzcf1Yft0xsX2M4jPhOpB/5HxqLKvvlvv+Z9OeXn9Un6XN1LvPfs3sg4u9BCCz2yaAkQnJKSEXdnce5SzSqvqTQ9AKp07nwq7+Pj47a3t7dxPOm4VYcBucOQHFzOkLI8XUugkvdZVvqvmTXOsAl4pCXTDhiSQ+N8JICeZvOmHN2qnMqhTcGHVF5r+YCsRFNp5ATT+fWZI19NoBlqzuRV9U6AzwMEqkul94n/yinyND5DmfJIQYNqBYE7j3SoqnsVsEzA0NuI+5tTf2fb7e/vbwAAy1NwwPuu6kkA3JMVgxepr1XkwZaeY+vPUF8INNgnHOhS7sxLoDLJ3h1vysJnT9NMNVfWMP+kGy5DAl/OhHv9nFzfe6BYees+9Vu/nXd/nrx6+vQc9cjrojHm6OjohGzT6gHdS+T9kNenwKDPoKcVCyr74OCgtXbjkEEf33rt6eUq/1Q/lwVlmuwnZSp7wZUG1DXaAAfsKoN6TPuS5Ov10X8fb32s9CCQrxpggCCNr953q7ae0oHkz1XjM+vKZ6tAgY8ZUzRiF5ku/U9tMRUASLY5lbPQQgs9smkJEJwhVQ7L7UAjvFUAtAJ+ouT8jgDVqYFvarCns8PZNOeBdR8pt8cPv53HanWBD/S9gESiapaT15LjSf56ebsT0GtPpun9T06W7k2Rr1Rhvk5+LdU3OUQOTJOD6byfFTlQSnxWQNIDCiQP0PE/HfzR/urA2Gmk//LZyjkdzdcDC/xdrQJwPUoAu2oP3uN/p6Rvbn+8j/hzo8BeQK7Hzy6U+qvLZIrfqfv6ndrDfyut24KeTdgVzHieVeDE28CBfRo/mf+IrRIxGMA+7IE7AXjmpZVGHMOr8dPtvwc62F5pRV6qVyXX6l6y9e6DPFw0GlCgLE47XiRgfrPGIP2u7i200COJTuP/nyUP54WWAMEZki/bPKs8zyoNnQs+p3t8pRBfc+jANzlyFeDwJbA9R7Saee8FCUR0qNLyTpVF/ioQm1YXJGDhaZxSWpY79Rzl4nLgzF01K5XKYbtQXnQWk8OoZ9J9D4Yk509pXP+4XHTKEeuBLgfSVfl+P818J2DrjqrLttIDd+ZZH7Zl6sO6569PrMCZAwk/ayDVn3l4fuwvqU5T11J9RnQ+3Uv2JwExtlVKw3T83wsESKaUh6+4aG07YFnpcmqHKaCVeGP5rA/tRVXH1H892Ei5pYBFdd3rkWThNrACg97/0itPWU7ijeTbE7jqzvXPZcjrajvNsh8dHW3ZYdaH24Jcj5xv1rdauaBgAN+o4M8n267xUHbh4ODgxPkDzIdvM+D1no2m/JU+tVVaTeD9trcSr1em/55LPV3upfN2OA0PI/Z2bhk9fnv3FlpooTuXlgDBDtQLApxFcGAKDM/Nq7VtxzHNNGtA1hJPXfNXN3Hw5lLUCoRUTqUcGDoLXD7ozo3K5kyoyB0j8awloKyf8+PtRec4BUY8HzqAFSDxsnrA3Sk5LO7QVu1Jp5VOpv5rmTmXm9NhpIPrQFfXtPzTAVQF4uhA+97YHrHcxGsP+LO9HOSlbTGsq/Kqgkb+7TLwfJwP5z3JgrJ23VJaPzxMS6C1P1rX/LkKrLLcpHNOUw6z553qmWSTlj1zGbL3Uf844KNuus74NV8aTvDvQQHWMZ094B/qZ1Wm/jMIofoocMv6qM4OUr0tKWfJyM9Q8Xbg875yi3xRngKzvlRe8vRX2nnAkG3ndeF92n0/tyXZ3J6tdaCaxojUPiJt59GzGk9VLm0Xx78EvqmPPgayHm6TGBh3G6czZQ4ODjbBAg92efBZfKfx3fWW/T7ZK9c99tNq3BWRN17z/H2sSnrj96ZoF9DsbUQeUh1cNys/orKb6Xpll6u6V/VMeS200HmkRY/HaQkQ3GRKs46tTQNCd+aqZ0by9HTJ4aHDpgPirl271i5durRZXcBZFw7mcjTEg4MMEmdDmcdqtdo6nOjChYcOU2ut3qedyqADpudba5s6uVwdzCoNHVZ3YilTB76UdSVnPl+1WW9LCB1i51u/OftD0EDHjmcI+BsK9Jy/09sDBK4H+iTgoXx7Z1pU5KA+naZdOdmqCx1OPUvHVzrsYNAdXfJeOafJuVa51EE61q4PBFje3u6g+zkQq9VDATL2NwdqDogJQlK79JzEyhFl2yR9px75c9St4+Pjrbb0Q+u8z+pDnWNdqzpWQScH88nG6Vm1RS9IkMqoVh6kgDT7q+qiA9xUV9m81C4OxvztKyoj1V/3enKsgiEilcHDSNNbdFJwQEEv6i/P2RB/bH/XE/Lrdky/3YZ63zs8PGwXLlzYBEg5U6+8tLpAz/FA16QTDigpS/3mQX1qvwREeU3yueuuuza2gTpBmfBgxBG99zb1scaDNPztQT7JncEDl4OPQbLRKqs3jji5j5XA9gigoB/gdZ7Dj/snFfgf5Sf9791L/xdaaKE7k5YAwcNEIwNHz1Dz+dFBqBps9DxXCRwdHcWAQOW0uQPZ2kmHl/VJswvuFDhw8MGc5LLwpZM+E9eTl4M/d5x5j7N4rGMKDqSB2EGaOzxOPnuXdMCdAeWXgH4CMZUsknPmZet6aksFmqhDemaUHMz22pPy8IAF+XcAJ7nOcRJdZ/gMZVeBKT5TgU/qoQNMLh8WpdnBRAm0k/+kV1P3ec9/z3WYHcBUdiL1WQeAaabTy0qy0O/UZv67WqmR8kh9bopYBvub64jqlPTO5ZSeY3CQ9iK1s9sXfya1vbdFshsEjw4KvZwkewWWyHc1jrhMeD3pGOutwJDb7Yp/1d9tqvOTVsz5CirqQGU7FARW0JBBDOc55UH+qkCWy8Rlym+vJ+Xsv0cpjUderymfqndvrr/Gvje3j48QbVuvnJ5NG6W5bbHQQgudf1oCBGdAuxjcsxowdgFXFbmDR1BF56oCk1VePaeOfFXgdM6sQI+vHkjbhXoO5S55jYCF5Ii3lgMkvCcQSTDJ4MAUb9KDKnghB9yX9vao57AlIDWid873SNoElnjd0/V+p/8kD6RUuj+lwy6fdKo483Gnfk5/6t2b0xZ6JgWwmCaBM8+nyt//94BGL/DRk5XXuweiekGFKp/T0lQQYyQ4MEUpcDNCvXZxW8RAnQejpvJPNCefXv4uS8mBvxmwYfn+XMXbCNgdGetoO9N2GL/P5xnE7VEaE9I4Veld9bkT6GYEDm5Gebeaz4UWuhl0O9iV24GHUVoCBDOJEf0KKLW2vdyOy5qnKIHkykGonunlm5QzlXnt2rV28eLFzYGFjFS7cyJQqLrzYDTPX0ulvTzlzXt0vJgH865mrSqnng5RmimeIncG095dpu2Rg/pRQNub8ZH8+P3/a+/qg+2qqvu6yXv3JYYQvkn4iqCikAhUQArIN03FooAdwMq0qG1HRBwiTC1aW4LVwoiDMMNHBa1DO50J7fAxVNEaKiAMo0WEAYE6iECQBijId8i77+Wd/sGsm9/9vd/a59z3XpKXsH4zd+695+yz99prr732Wmt/HDQAOTDAjjfT4MYubtHwmS1sX8w7Mv7Vf/7G/oOyEC3bVnkg7SyjygllJwRXhbhMKsdCOa9NAh6cTxQ08Lx4a4CScfWmEe+HnA/Tw+3JdHHdI36rZ/F5/62eY2dEzSCzM+b58ZLkyHnldua6qEAFO60lx97ToqziddZBKpigeFbiK8ocz5IzbzGtB31xRY+C90OmD7cleHmoT1VdcJsPlol6f3BwsJu36x21HYP/Y914rOBVXs4n79dqVVOpHZCH/p/rq/qn0+ByinxF2rl/cfDG+6tvH8IxkuXB0/nrTgcHB8fxx+VvYGDAqurN1YP8KlElq2rsRF5gH3Y+84e3Bfn2CawX5l0KINSNnaW2jK430XX8XMQXziey6/opq8n9pvk10T+JROKtgwwQTAKlmVy/zwYmot/ZlyY0YGBClVFn1LPhjVsNPA3uoTSznmXb6ICrVQSeN9PsRg8bBBxc8W/cL45BG1W2oo2dADUwK+MTnY+SM4J1iJwJxQssI0qr2pAdZm+fwcHBcSsGmBZVV+SHG+rOa1967GlUEIKNSA4cqLJ5GS0+z2dc8BJW5pUK1nA78n3kgTs87HgrJ1Plj2m5nkquSqs4SkEefh7rze2NPGNasA3Uih3lVHN/xXv4TCTPzAfMC88X4GABL4uODi3EfqkCKMoZQ3qcDyogyUEbv+a60b/RoeNAAOst7uclIz1ykNAR9bb0vouOOfLMeauc3AjIY+RR5GCjzsTzJPx5HE+qqurZZ4/6huuL9Pg3jk+YN7anBwiQB0rGVR283ZB3zmvMz8y6S/pRb6gAFI+vnp6DG9jfOcDBMu/6f3BwsEsH0+78wXMdOp1Ol+ejo6PW6XR6+BIFCJAGbhvny+joaLdt8cwMv+7ywWdRROMsy1wTZzgae0vyW5efClqU8qujs2QfqOt1/VXljc9Fz0bjXSKR2PyRAYIJoBRpReNMpa9T/GZ6dUJ0jRV4aWVDkzxxsPMAAc5UoIOGdcFoPztxmC/WnQd9dtx5dsRMH6CERlvJ2WeHIErr9yOwsa0cXyUjpTx5gK8zNtgxYWfcAwP+jas60ICNHGfkMRvf/o3GtnJgOSiBBm/ED3SeOAiBaZC+iK/IL5RzljtuH5wxU7zm/JsagVGe+F/VBR1O/0anx+lyxyrKk2eYuaxSkALz5OeilTiqz/tvTosOuefJzgHqBGw7dEBYt3hbKl3JNKM+Q9ni55GfKIe8hcf1JgYIkNecD/Mp4j/SWApIYZDA0yGv1Cwtt1nUt7A/IV84qIa89LZyGWV5dL5h23oaDnwzL5wmT8sBRaX7Ud6ULvdgKJbh5WDA09NhHT09Bme5HNZjnq40FmCZ2L44bmN+vmrAVxB4Hhgg8DTIW3xrCB92WTeOqWsc3MO2Utf5FYvO96gMhTqHuR+nug7R+BmNBWgjsj7q116sQ9M6so3RNJiRSGwqmA6BrulAQ1PUW4SJIkpGf3SthCZG+kSh8u63vMgAaBppnwii/CMHsFROXXvVPV9HYx0fovuTHYTZEGbnxkyvsIgcU6aTHTYVIGEDu19FGPWfkvM8VVDtx84pXle/GXVyqBxq9cF7anVG6TkuqxRQaYrIiO0HEU9VUICfm2pMhCcc+IryUbIbPcvpSijJ4ET7S1M9zuXWBcowb3SeVXCjJMulFVARbdH/EqJ8ebxhGWUdqPRik/Gh1AdUW6vgOOt/XqWi0vB40Y+OiXil+IP8wzQcrNqUsKk50ZsavYlEYsMjVxBMABwl9t8Mjsj6s2jw8Ay+z05ES33r6KrbthAFBNhoRUOhqqruEsDR0dHuXkWcBVEOporQY71wNtrr7mkwb1XH0dHRLn+R3qqqet5F3YR/WAdftsnGlbej4i/znWcLvQzF86aBDTam/XmnEc8c8BUEuNRWvbIM+R85xlimWkGCeeCrzzx/3L+PvGY+oLzhtabG6EQNniiggUYrzmappc78bNQXkE5lqCu58VlAb8NodYbnxbO3ZutkVjlXyFvsiwr4jDL6sUxPUxdMQRrRQeDVADzr6M9EjhfPxPo366wokMJtUedwmY3fCqL6ab8BAZw1LQVUSkCdW9eXFC8Yqs/gLDb3Gb/nWwsUz1EGUQ+brXs1LqdxneT5sD5VDrwKRHG9/bsUqFI8QRlzOnyc6nQ6Yd9HmedyuS1Kug4de5dBf60ir5bA8W5gYKBnzHTe+4oDNZsf6UzWDcr559UDpXaIyovaJLLDmNYI/aRtghI9fA3rhmlKNmSUH+ZZkpkmumBTDdokEonJIQMEfaKkUOuMPh7wq6oaZ5D7oIlBApwBZgc1MtQd6HzjklhOw4YxGshjY2M2PDxsrVbL1qxZYzNnzrShoSHpFCmjSjlDDjdC+HkHn5zv9RwZGen+xzx9Wb0/g3VWAx0vkVcOBG6xQNQZkcqh6sdgUGCnw53GdrvdExBww5CdSTY80Kh3nvl3qS2ZBjwICwMFHKzh573N0LnFstgJVoYp5h9Byb3nowwwMxu3t9fzcVpRZlSayMjl+9imHthh+fOyPB07sLiUnfsKLrf265GBWQowqvZThz8qBwH7sIO3unjgT+k4diTU0mSkE3nDOhK320TOahTkU0EAbifkt2rziPesTzg4UHJwI/3itOJ2Bw48K+dE6Qml4/15DOhgfc2sJzipdGQUjHHnlcc27JdetvOcZYoP22P+ouOKjrQKNPAMt9L73FYjIyPdsr0dvF5eTz4HAvU6ymPUfzmdOrOEeYOB5Ha7be12u5u3j5ujo6PjXonodcV6eZsxcDsLnjkQnUGA+dc5yKX/iJItpsbnpnkoOS71bWUrlcqJ+rUKIkRpMC8lOzxuqjplcCCxOWE6yPN0oKEpMkAwAaiZtpJzgs+Z6ZP3zeJZYsRUbEFQAwsaFO604wqCTqdjM2bMsE6n0z1pusnAhHR7OWxU4YGDmJ8yoNjAQ+deBQN4Tyzmz3V3B0sFDTCt1weNSLU8Mppt5jSYh0KUr9OKh1B5XTHwws4Q1g8NbTZu0QDkGSCmA2WizlnHZ7EeeKibgx0T/I4M5gjssKlgA4K3UWA+WAemmfsoO8oqTavVuxcY+cOnyKs2RUfdP34CvHLwuC4RlOyjM4b9o+TAIk85b8/Lzzxxx8TLRUfP82AHj/UR6i7lSKvVF/7N/Oa25f6HgTLlzLleiQxzBMsT98kSn1lvOq+9X/FMMpaHbaLGmJJjjN8YrHHe8DkQ2G9QBzC/zKxn3zw73biShMcWpcf4Op/X4XSo/KItBf7N+gTLcAd45syZ1m63x7WT54+0cCAL06v2w6DC0NBQt90d6lXFTk+73bbBwcGeNmy1WtZut62q3gzy4jiAvFdnnmA++LYC5CMHD/AZzsvLVSiNFcyrJs8wX0v/Mb+S06/u81jE5fcDFVhommeTcXOidCUSiU0bGSDYyIgiznitiYKOBtC6gS4CG9BqMI+gjFZFF37UDElpmTAaGm7UsQGoBk5FB9OkrpcQLZPEcpVBwHVSK0Qimplv6LCgwY1lRIalaiesCxqE7Kz5cyp4ExlRyjnG9mZjuanMTgR1+bLR38SgMpuYgcbtyA5VlNasfua/9B/pbFI/bMdIdlQ+ikbmr8uRBx/M1jk3qpyo37EzxU5dFBzAZ0t1Z/3FfZL5oNoPv7kOagab05X0XUT3RODOaqkfcvuh8+6z5WY6aBrJNuaNZURvHYicPeXYK346cGXMRKD0YEn+lAzj805TaQxBhxj1B9cVn+OxgwMIHFxkvRzVp8QPFXCJeNAUE3lOyXLdOBPdx74c3Y+CCwp1fbkfXd0vb5QcTkZ3JBLTCdMh2DUdaGiKDBBMAOx8lQaFqRaGaGCucy7VrJAyjHn2kp0TjPxHM6sKkWHDH/WMqjc+j+nZKMPnlENRN+Ar1BkKfC3Kj1eiRLMn/p/PE/DVHmq5M8Jp5SXL/psDAMpwQn4qBx+Nd5Qjd+58ibM/W9f2TLsysEvOaSlYo2hvApY1rw87tE2DAqxH0LDn9lRGfOQkOJoGnCKa2ElVThvKBubTJPCiHAZcFRQ5yWo2N6qT0hElmVOrNSIHlttGBXIwPddfOY7KaSql8fwVf9U3PsPyUecMRNuO/FkVKK1bjcBgPqtnMSimVnFgcAKfY53H32oVTkRbPw4flsmBdtSHKj0GBjDoqsZellWm38tiPcPBeVUv7hO+AsFXKaiVRK77eSuQckIj8OtOmb6Svm+KUh+psxVUPnXX6/pZZEf0ExhQzzW5328wI5FIbL7IAMEEoBzrJmiyPSBy5HlQUb+V46boQ2OAHU5c7u330CDz9yJ3Op2e/eZsUDtw8GUDg6/he6/xWZwJYYeHnSdfpsyvcUJHBj/q3eleptpz6uCZMmwjpydyLnCgL638cPj5Arg/nQ08DxQoQ48NBGUcK2dEGaCqrl4PP4QMDVnfmuKygnlwwIPzZzoipx/bFdPxddUGyGtlUEeOr3/7EluXJa4fl+tt5O3F72t3XiknFLdg4PXI4KxbXYDyUnrXfGTQq/6szhXgZ9HRx+XfKIfOS3SOlOPBfRDpNutdXu/ls27jmVbkQ8QTdJCUo6UcPuZBP/2SeadkmsvkbRkYfEG5Q10ZyRLqSj4DQNUR6eJ8Ir1iZuNkHOkys3F9hvnubYln1ODYUVVVV0+NjIyEYwBvWcF9+EqvoH7APHBMxjKrquoeDujP4woqpEvJIgcXUSZVe6Aj32q1uufFuF7GrRVcJ/6uqmrcaxFdjlRQIDp7AHms+gf2Az8gmc+6YFoxr5JjrHikEI0Nfo3vR/2+FGxoMhYpmprcq/vfb/6JROKtgwwQ9AlliPXz7ETTqIGbjah+80Uj2uvlRgMHCszWBQhGRkas0+nY0NDQOEMKoQZ9BxvlXrZy1tF4YgcenS43JkZGRnqM3bVr13brVXI0lOMTOZleJ7UcXn0UX/CbHWQMMLgxN3v27K5Rhu3i/FBGKtOujGCcpcH8sF74rQwaM+seNOV73x1otLpMcTAqKkc5mMoYjBwV5cg0Rcn4Q9lDxwvljh1GdvZ9D7DziB0ebl90nkpOll9jmpCXXo4DHQivswqS+T10SpwfWC7KGD7H99CB8HyYn3idZ2CRnpkzZ447NI0dR5QFdI7M1gV7uK0wKOf3vf04SID0YFvgCh3kF8IdV+6fypnApecI7juenvu40+un7GPdFZD3TqdKz3Kh0kTODz6DwTbPQ+l/5RTzTHWk71xfoWOr+hfWC/sS921VN6YBy8dAAfdvXNXl8udl+pjGBxnymQWYHldYeLAZAwT8thkvF9sZZ/IHBwd7nmu1Wj3BD+fp2rVrrdPpdIMjuPow4rnXH/PA9mLdV9Lv0VjV9L4CO/uYV53zHgUGSumUjafkjXUm639+rs7WrAueJBKbGqaDTE8HGpoiAwRTgH6W8k4lStHhpkKoDAy1xNkRnToc0YS04CDFzjca2Hg9crKddjSCzNadleC/2bhnmkrLZqNyeQDletU9r57lvNmZHBgY6K4kQKOPnR4VfGAnDWdm2FBTM6ZIVyTrmJ+nwdd2sUPKThiX1cSQKhnjyI/ImVF1VManelY5H0rOVBnRyg/kcWTooaGu8i79r0vP1yJ9gv2qaVnK6UJHQDnFLjecFtNz2Sif2Jc4kIHBKbXSoqR3ME8MoiKtipdKpllWMZCAH24LFYRgmY94iro36s/qOusLVcd+5QKf83KxblF7+j1uI3+W6WDHGx3PaBWZkgHvfxwYZJQCY2ZvvgUA3zjD5eDY6rSxzozo9Hs8/vm3Cm5FugDLwbZhfW62bhUS1puDMvhdB5ZhDJqUnomuMX/wvl+L0pTKK41fqp82Qan8pnlM5rkMEiQSickfif8WR51DwCgNxCUFPtFBoSlNHBBQjiojiv6XoBwFVVbk7HDaaAaNy2QjmQ3xiYBpaZIW/0d8RgcyCtiUeBWBnVoOHtShJOuqPZRTrdqiJDultplsn+hH3jB9v/Q0cdxVeZNFP/JZlw86ZU3TRogCcqX0TcpSvxVfozrU9a9S3Zo6wl4f5bwy+tVLkzHmlcPHefbTZv3KW1M9NBG9h8/1A6Uvo7GLUeonJT2Mzjjm36RczpfBsjxRRPogGqMn4iCjPGyoyRfuk/0+sz7omKrn1qf9mEgkNk/kCoIpgHJUMeIfzULyM3UrEdjIbZpWAQ1Cns2MHFKfbaiqqnsWgS9X5JkbtSIAv83Gz+7ynnRPg99+X82IRU6Bp/MljmbWs1+eDapoBs7zxGWtvm2BecttUTKSUH7wvAF/rt1u98w0q5kzpJ35xXVSe7hZVtFgxTLN1i1HVwGAaGbcy/ElzX6GRWQIR4GDUqBFOfMlmWBEPC3l77/rAji83YCXpHM+XD7yuEk9eHbRbN3+blwqrNoQaTYbv9ybaUHwjL+iC+WO+x3TUer/vGTe7+PKIixbfbBMfKUeO0Hc9zwdPq+2W3DdI0SrcpjOaCxp2lc4Dx67cFUS6z9euo95Yl74aVJ/HhOQFmxPVS8vl2n0e7h036+5/ivJN/YRp4XroYIAKP/RGIy60J9huXI5Z5qwvZjHuHWBdQ2eb8Lju5fpdOEKEdUnmffIR1/thml8tYDrftWmzB/8rXRJSc7rEMlvE7BubZp/U0R6timdqC9Un+J+WBcIqdNbicSmhOkgy9OBhqbIAEGfwCWpZvqd557O/0f7RX0JoNl4J4SX4OGAioaT58P0lIIH0Wn4vtSRD4Eysx6HzwMEw8PDVlVVj5OMjjM7VaVZGCzPnVivh6of8jZyBjEd7/vE/ZJshKvTrNFRVrxGw4wN8CaDuxtxQ0NDNjg42H1fdqvVGmfUseHIUAoIaeS9zujYq/bBumC92Tlw2vyD1zE44OX5klQ01hWUUaYCF3V8RvkqtQWXwXKs6q2crmh5L95jh5wdBeZB02vcXizH3ifQ2XB4e3CfVEa6Co4hXcq5wyXemBfLXRM5jJwWh+tYdlbZMXId6M9g27J+wvpF+gzbguuEbcBL0fEZdESxnFKQgGWWHW4VtME2drlQDmO0tYP5o4LMEZBmHA9V8JzbhvmBus3pQl2JY5fZOocVA0r+LAdPuS4cAPfyvQ6YD7YtpkM9jHnxlhWzdWMS6lmWa6+X92vcQuC/PfDMuoaX8LO8sX5Tco1lOF0zZ87s0uVnhChdqoDyp7YzYpuWEKVR44Xqy2rsUc+rukT1477OadUYoOhS9EXPl3hdQhMeJxKJzQ8ZIOgT0WCgnARMhzNaHETwdBwE4Px5ZgxpYGMlcrjYWPeIvxvIyiFCY8Rp9hUEVVXZrFmzeuqDziajZFSjI6KcH89bDdRMMz6HAQfP089Q8DwxoON8UrSi4aYcW2XEq7bgWUbnWbvdtna73eUpO8GeluuowAYeG/yRMRQZHEgr89t5iG+2wDxx5Qbu4eWgR+R8s4Gt6CgZaJwuMqw8X2UUq7yjvhg5luw4RbKF9eR6R3LHjmmd8W3WO0OKz3Fe3BfYsWW+el3UXuNoP3GkL/ie08pBOe5zHOjAOqk+6QECfIOCkvlIz6jgLLdx1GdLgQSVTrWt84NnzPlbOQ2oe9lJxD36Xo4KUip5bwIVJIicHRwjWUcoueLAkNOOfQjHVZQl3CuPe/U5iIE85TGa29HT4ttP/DkOIGI7ehtgUAxtAgzgYD5eJupmfNZpcN6oQAG2k9L7GORwOwL54CsMI32gZBzHDPzNNDH/I5TSROWXxpPofxNw/6sLAvgzdWWV7rMeiMZ5LKsJXxOJxOaLDBBMAdgoYOBg3ESJ15WFaZWzUPc8G71R2cqQZuMYI/vsSChjDxENxMo4jNDEeePy2OCIDF4VHGBjL3LKSgMrGnaKZpYXdrxKKJWL7YXpSvUvyUdEe117qwAQOnqREzPVUAZQnSyWHDT1XIkfjqk0whTvpoKX7BTUbW9qUk4Tea7LW7VXXbuW9DQax1E/n6wO7xdNdIpy5CZTFualgkL95rOhoBxyRD9ji+eH/PffPLapIEEpT6TV9SGuoEAam+hqzI/1O+YVyW8pOBfdx3w5fw9KRON7P/LB4/VUoh86mo4NiURiemI69NHpQENTZIBgAqhzquuem0h5ykgp5R9FhR38xgI16+mOKi+n5LzxrQa+DxGXaCI9ymFhurFcD4BExkpk9LCjyZ0SZ17cOMNZI1ySr4wuDAqpJaoqMKJ462l91sdfPxU53Mw/DtIw36OVEAh+ZSI7RGopN/KhFBzgMnFGzNP6zJf/x9nsqO2b9AdMFxmlTRwJLJvT43vMHTyT5jzEb3Q0XP5KBnyJFiy/LjigAhy8YgLpUjzBoGQUGGUZx3MvOL+IXi7T76u6c92wTsrBVyucFG9Kv1V7Rn1MBRtZdyj+cZ5NHFx0PLnvc4BQ8UDp/6p6cytZFCBjfcHXVL0wPfb9qE48i+w6Wp2MzzxDeXXHlVeN4ax+SZ/hmIGyp8YH1bfUZIG/ihfrgeXjGI154nkBWFfeQuB1jwIbauzrF7xy0Pns9fLtDfhKzZGREclfHMdUIF3piSgoosYM/K+emQgiHdCk3Dpa6sZVvody2bS86NpkAo6JRGLTRQYIJoCSsoyWmdYZdmywqvQlQ7w0Y8b/cUsBLkdko7DVao07bI6XhI+NjfWcRYCH66GTh4aNGrTZYTHr3YLBjjCmLRly6reX50seq2rdmQRjY2M95xOUHGt2+tAI57pgmTNmvLmVwIMBmA++X1o5PlgHLwuNOtxK4d/4Si/Fd7WSBA3TSBZ52TzSzDRgG/rzLgv8PLejp2d5Qlli+eFlyNwemG/UviWjjQ/9QifEvz3Qgw6BChzxeRul95mXaFROn+pfyHclU8xzlAXuF9GMJ+pBLw+39Xj5kSPCZbJDw1utWEaRRuWEsowgn5lf/Bvzwbaqc6qUjkb5YL0ROct1be7yxIeRehnYD1lnMY/M1h3Eqpxd5AfLi2oX/nCfwXRcFgc68KBZly0OgCg5936Jfc337Xc6nXFONI8jKkCAdfD/as8904b5jIyM9OjvsbGxcYfWYj546B/yjscPbF/WTZ6XB/n9U7InlO7E8Yt1u9Pp7TQ6OmojIyM2MjLSvYd19o+njdoVaUE6I9si0ufqeaVPFC+iZ+uCEKV7TcqK8lF9sy5IEI1/TQINicSmhFJg7a1EQ1NkgKBPoOGkHEF09NHomegSOTQ+cMaa82yivNkRQydHOQN4z8tQBpfPCLTb7e6zOPAjrdHMHtfZ6XTgvnl0TlSAAPmPxoXiq9OGTjYaJWYml3Qqp8nL5gFVGVGzZs2yoaEhGxoa6lmKye3AtDIPnE4McHBdlYHl+aI8cVmYRsGfjWas2GlCx8T56rKiHAXkHS9XRUdfGehcJzZqI/5GYHl1+fQDufjwQeUEKaPRr+EBjvx8ZGyqOpWMSzaUkUfR3mDs7y7rakbP4Wlw7zauZsHZQ88X9/wr457rhUEHpJGDrBhIwD4cOd8qLfOCy1P6h/W+CjKW0ke6BenA9F5Xv49OFrcXXlN5o2PJPMNnOACnxgamFc8Z4eCq0pUR7X4ddZ5a8YV8dr60WuuC3igfKIseOMBDVJHP7OBjgIh1IJ7o7/1C9WMvw/WIBwf8Gr7xBcfcUgAMx25cqYTt7cERDBBEqxKwHyr9y0Ftf25oaKjLRy/D88U3C2E7YoCg6SGFkR6MEKWL9Gx0v8k1lu9S+Sof9XwE5cyr/hXRqOhMJBJvPWSAYBJQs2f4HaVFZ7luBm0qaOPZITf+Sg4N/8ZBRxmppQ8OhMqBjurORpw/XzKYFe/qDAs00Hh7AdJcQmQgqIEWnUtfRaCcejRaozxVsIDBRnMd3Q41243PsDyotvDy2UDBa2x8KzpxBrMJUMYiI8jr2DR4x8a4/8Y3NygHSTl6mKd/oxPGtPKzXLeSsVl3j/M003us+bvEXyUTzoOmBi87G6V0nJ7r1qTdkbYoKKPom4yuVrLCM9PKKfXr+I31wCCA0p9KV+BqDZYtvM86nfmh6sd1bfqMqpd/Sm/BUPzCvohBIrzGac169ZPiWZ2zxemj8cx5r5x5HKtxxRHqDX5zDPO2FKgqyQzSxuCAAeo65KvrR6fTf3N/U3TU6bUmui/q16VnI/T7TJ0OieS27tm6Mvq1WZro5EQi8dZBBgj6BA80eB3Byw0xPTrvaKiigch5sfHI90tODpeHdCljIjIQ2TliA4JncNiALTmAJTBdnCem4eei9ioZFCVDqB+a0SBttVrdV0n6adJsXEYyouhoykdl1CqnxIHBq0gmIkO4zgGOHBqmVTkQLLdN6j1RqH7mv3H1DW/NifoR/o4MVJZtNp7ZiG5ipKrnEE0cs1KQDOktGZeRXuEyS84iXmcnWuVbqhPnE9W55PhFco+OHcps3XMlKF3r3yUdG+lbDHTxjHKTsYX1WvSZKJSsNalTdB3BKy5UvZSu4bw9gBbRr/Lmb+73EQ/r+m/Ea8UzDLR6kEWtwODyovEmshMi2WDdirYN8ta/S2NGP/2n9H8yeXDf92tTUcZknivlFY0dGRhIbO6YDjI+HWhoigwQ9InI6VSGFT+nUJq54Gf9Hg6uUXm8rNnMerYUoIPjafkVS7iMFuuuluhW1bplj/juZdwPy3WJaMeyvDxeqqkCBE4X7s1Eo4SNHBVcQMPX61MKvvDqDKQdz3hotVrd7QQDAwPdMwjwdVRcFrazCr7gtcigVAaWMtqwLJRJPBdAOcNOM9LB7VRyIDGAgctvuR9ETlaUp9MVLRcv9R3kOb6THGfxfGsBn+PBqy64rzA/vM5YB9xO4w4ny1eTgFfJ2Pd8/L9yBDlwqfhYZ2j6s4ODg+NmfD1/3+POs4XsiHK5fo1lFGmvg9JjuHpC6W1sY9X//T7zDwM22KbR2IArZjA/pxM/uHedzxxhGjFPXvbPq10wDR4mivd5XGCHF8HXfBk/Qx0Ui0vfFS/4GoNnpVmX+aquVqvVLQsPQESasG3wG3WYWoHl5WA63D7F4y/yA+0O1o347bRgu+Pv0dHRbpm+VcPPP/C6Mg/5NbRcLsu3f1fVutduYpk+nvshhX72g28bUechRPqG+at+c33qnmc9FD2reM/pS+WiHqurX6TzmwQvIronej+RSGz+yADBJFAKCvDyQLyG/yMjyqGMY863FKjg9DiDjY48OoMcKEAaVcTfaXCH2o0pNIJKxhvzAJ0VL4cPVeKZIDea3AhBg4qN3mg2hNsPHXNFNxvSWB93ijwYMDAw0A0Q4CFS6IiooAeCDVxeJozp2bhGOcI2ZMfXn3H68HwKNHiRVhV8QR4xfcpwc3rRmCwFMVReOKtXWjWhaFBA559XfbgjwfxjXnIfQuef6+/wfoQHfmIbonMSzWIy7/0/O3aYJ/cvdrxQ3yi6So4u1icKKCGNJYef6VCBK95Hjb9Lq1FYd6i6oP5DZ5+NfQy8IlB3RTyLeMo6AJ1Yv8YHu/G+d5RRdubdeVX609uOVxl5HXlciPocjgnovHL9vZ7orCunHPmh8kDeKV2F9XZd7Y6pf4+MjNjMmTN79ujzBxH1LeSX/+dAkusa5BMHHtQhtuyYR4Ehs3VjtJl1Dw30b7WSAPUNyxL2O+Q1jt0YIPD7Zut0AgYQ165d26WHz0apc6LrbKmIH5x/ye7y/5H+qCuD06r8omAA06noL11TzzGtpXonEom3DjJA0CfU7LkCDoZs7OL/upmuJgo6MmTNeoMSbljw6gA3TOpWDfh/nGkyWzew4N5InI1gI8jpiZxKrheWj3niQI4GtadHIxcHQTagFB951hd5iWUr/qMR6IGBgYEBmz17dpf/UZAkGryRdvVb0cH1xXK8juxY4UcFMrDdVJBGlY91Yb5ynV2GUL6Y7lIZZuODUcpAKvUrlCVvQ1zt4UY814kDbV4P9XYHnMX0dFi+O0QcQEL+sxMZ8Z9lhp0V5A3m43SiA8zg65Gs4b5js/FvDIhoq3PmPW8Hz4J73uoQRq4D9nMMSHpZ7EwzrzidO0UuE+yslpwZ/o/6TzmmuEycHWrXgxy4Yt3ovOMzT6K+iM9if1Dtr2SO80Sg7PESeEzDPGA9X1p1wTRycBJl1ezN2W4fs/1+pJNRf0QrUpSMYxAS9QiPlR68xCA28wbHflz1MDa27rBQM+s64rhygPW715fblOXAr7N8oV3hesz1qvMe81BnAUU6iPkZ/cfrTfJxOv13EzTJuzTG8/26/KJ7pfGtLs8meSQSmyKa9uPNnYamqPd0E43RzwDliIINTYIQEdgY4VkdNaArWtUsk4Iy7vh/6Vpdh2GDJJq1qKOrCdDhi4zZ6Dk2iEq0KkOrKZRB2rRu0bXIMVP3mtI4UUXIhm6EpnT1Y9ypNqz7mOmZtDp+N6G/jnZ2ePqpc9P+N9lnsZ6Kp36vjm9RPyqV2RQqfcmB9ft1eqzpVocm9Kjyo4BBv21aV17kFEZt2YT26H+kOzjAVaJ6MwAANudJREFUUsqvSZmISB6VLu9HN0a6uomTPVVgGhSvMRjQj+4ujV1NbIym43dT+Wyavgmi8tNxTiQSbwXkCoIJoOmAiLNJ6r5Zb5SaoZbaK6jltw61h1ytJGi1emcveBkq51HiA85keRqefVdBBS9HGdU48+D5KX7jbEOJRnyOV4XUGRtYB//gLLHn58tVeT+pmr1iqJlBNN54CXjkHChD1PmJZav6RLPfytjtxyHhWVZ+Vq088RmwyMH0OpXK9Hy4vmrZOPMAl/2ivKitEGr2jNsCaXa5bioXvHye81ZOCfcLFYRBnqhyeSWB2oaAv50/zHvmgd/DGVF8nunot48zWHeoGUpc4VGSOc4D+WQ2fpUY86Ap7bgqy/dqm1l3CbyabfcyWP7UmQ14n+uMzzv/oxVmzoNSAEDpfv5Wy/idD9hPSx+14gBRkh+vk5+PgfBVATzrjjxiPqg+pspVOoz5y6uI+KPONcF8UF789Ya8tYDbKxpH6uBl8goeXPlgNj7g4/YJr2qoGy/rxqKorSPZqLsWldGUhlI5rOf8WpPnUc5KfUA925QfiURi80YGCPoEO0t+De+r32pw44FWKe/IYEDw8lU2fNzQ8UOYfPD1ZbToCPG2AzQqI3q4XH+vPT6v3nWPBifSEfGpqqpxyy4RaBw5zcqZYt763nfMx8tlA5956zT7XkoMCPjWAn6HNRq5WD/Ml404NnzxutdBGebKmGOnFuvstOL+ewfvf/bnsH2UgcltxL9VXrgEll+JxY4Mg6+x04ryh32DjXDvHxhQ87Kx7+AzHDzwcrB+DuQbtp/aguLpXcYdHEDk5eAqH+Z7lI75p/Jmwx63iDh/IlnBNvZ8eGuScjzZ8WOeYv/F4Bqmw8PxIod/7dq14wJlJX55GTwby2UgH5g/3P7Y1/HgQT9nAA9x83t8ICzykN+8ofqKCnBxH1e63J93eplXTCfzEds2SuPPI7+w7/ArAKPzJPA/62bnE17D8dHL8qX5a9as6XmWgwRmvYcMlsY6BrcB8or55OX7WMt8w+CABwSGh4e7QQLMm8tW9kHTQAHLktr2gWnRPjF78wDDKHBRZ4MpuysKJvC4X+dMc96RTlLP1aVR9eBrTYMYdUGRyQRNEolNCXV9+q1CQ1NkgKBPRDPNeL3fZaU+aPYToVbX1ACFg7s7Qny6PgcI0HBUxiI69YoeNGj9eT85GQfeGTNmdA1cdvyUAYJ0IQ1qr2JkFPBvZXhxvVWezF/nbbvd7l7zQwk9HdPNxjnTgbOG7Hzjdee5MghV/oq3bByhjLCxrgw15qvTpOjAfPA55I3LjOeNQZV+jFOkA3mF7csrBPzj+2MxSOD/sc943upATywfeaUMNOcz9jHP2/Nl58vBDqzid2QQNzVsS3oNnSazdYePubPL/FH0mFnX8XU6kL8seyVaI6cfr3OgDtPxPXdWWJYiPnAa1T4oa8gPdP68TNRxPPOryq+qqiu/2A/VaggMajhdygnEN8lEOiTSE8wv5eihXlPONjuW/s28wW8+bLEuWKD0vfdJlwleXeJvAFD1QTq9X6M+wXEAg2TMZzVOsc2A8hIFGZGXo6Oj1ul0um8L4CAp6jGkI7KBItTpazWe+Bjk/MDAv7I9lDPbZIzCtuLrnF5di/SYQp3zHtlUpSBHKX/V57iMpro/kUi89ZABgimEK1yOkm9M8CDP1yPHHJ8pGVVqUFHL3820Aem/HdGAxb+jeyWjqAn6cTz5GZxBRn5jcKDfvJVDrhzrEm3MU3ZMVF3wE836KJlQxnw/9cT/bLypepZWtHD++NuNaG47bDNeaaD6Cc80qf6mVqEg/zAAEBlvzCdlDEZGcMSPfvpFKR/MLzK0zcYHTFgGUdZK+kXxb6rAcq7aXhneJYck0m9cl1I9lMPJwZKoDXiWPxoHsC5+rTR+oHOLdJV0XEmmS7quxBMHryyI5LHUBixb/M26nD+lOnN7sWxFdgPnH+kAxRv18TrylhTUZcwH5EH0v4SoP0ftO5FVCv3qgYk8M5X5NuXfZOhcHzoykdhUMR36wXSgoSkyQDCF8EF3Y5U9Vfn4oMIzEWpAYyPC//sMhc+wtFq9r0/0tFW1bmaRT9vGMqOggJfHS3Xxu2RoRJF4dgK5/l4ezpRGxk+dTKBhikuK+bmJOnURLxVfkJaqWrcXmGfm2Bnia5Gxqxw75XDhbJjZur3WvMIF68UOaNPZMGX4lnhWx98oaMEOcQnMG3R+FA1qdpXpY0clckbUqhV25JWzimUpWvwevs1AyQ2uGuBn/XdTp6HU511P8TYR5qX3SW67iB8InBVmPVn34ZVRSA/XDwMr3BZNnNmSjlcz7yoP1W8icJ34g1tAkI8lfnG+qsyonaLAQQnuUEerQ7ivoq5R/S8K5Kigiep7KBdq7MBtP/gqYtbprB8Zqmy+r+5FMsdl4+qsqqp6Vq6osUJdj2iKgO0f6ViVp3qu3zGa27apU9+krInahZuSE5NIJNYPMkDQJ6JlqXXLb0vXSstW+3EmlKMeDXZ1hhQblwhlEPNA6UuNkQ4f8Hl5Je7R56Xf7BB6GbzVITKwlZPBtHp+Dv+NRr3TY9Z7cBruU+dZDzd0lWy4HOEznh5pV84BOyaqDdSSfEyneIyBDqcFy8UgAfKuZNCUDEzkBRvDWPcZM2bYmjVrultScAsHnvHAfMZAAW6ncZr9Ohv4yvnBlSEqHfIPHTJ8Xm0j4vZz4x5l2J8vGeRmJo19f7YOTjO/Xozp8LTRPXZAmQ5coq32m2NfUnKC20NU/+AgjefHMuv6KILn422G2124DdX2HuQFBhii5zkY4AFW1gXRth2WG0yD8sg6p1R3rodydlkXeRlOaxRM4nZHWeDtAUq3o67k30r2mX91AQGlj5AXmPfQ0JCNjY31OLIquIPP+JJ+5xE75KyTWEdiAJXrhq9pdNnF9vJ+vnbtWhsZGRnXPuqsAdY/SDeC+RXpLGxj1FtervMSdYafl4AyEfU9pqkJWCbQvvD/Ko0qS43NEV1NxlHsw5FNo2iI6FR0RGX676Z8TCQSmwcyQDABNFHAKg0D9+hHgwIahJFxWJoxVf9Z2UeDjPpfohWvj42NWafTGWf0OJ3uWLshwwe6uUGCzgIbqFwmGolsoKngAPOODT+faXGDa3BwsGeGE38jL9G5QLqcT563P49GLNaB24cd9CZgAw/r6s6xr4JA/ipeOo2KNiUTdY6pMjaV44gOWqfTGXfoIwaXMF+sj58xwCe4c1DHecWOAH5cZpEHGMhCJ8S/3bH1upacSq8DloEHz7HDy44PO4re1+rAzpfnp3QbpsP247LYOVUBEAxEYb9HHiEN7lgpmcTyvO0U7Wbjg2gObH+ercf0ng+fCcG6CulQK2DwYEZc6o1BVuWcsRPJOhEddZZfdpwVzSi/yFP+r5woLwfPAED6WdfxoYaRPJd0El5D+vE+041pIycuyhcdaa4DO74qX29fb0sfDzDozPxgujigx+MPBz1Qn/rz3D5eJxVA4/6o6EKeR/0S02D7ug5xOgYGBrq0op3AeiOiE4MJCOYL0hPVFXmkxkBFC9tNEa2RXTURYH6l8dlpV3XivBKJzQFT1cc2dRqaIgMEk4ByolUas3KggAdRlVc/TuFEgAZrP4NCxAM25nBW3r+VEa2MTnWfB3g3Rs3GL0ftB2wEe5AAjSacdUeDRfGGDSDkjzoZnY0lNhzYMKkzhLAufA/rxEYMG92l2fl+ENHPPPPfSBfS5+2inEg2kNzYxpkpL185iPwfZaJuVUaEUv6la8gTd5zN9FJ4/2bniVc+lBCtXHH60FnBQE4UnMRn2enhPFkGsU+zXoicOdYPpbRNgPyMgg6cn3IoUDept1tgP3OnOGpffJa3VqmVCujQo/Ou+BDJZZQn8xx5hEExzpv1C/NP/Wc9WnJOkabI0VNjM9df6UwOFnh+UR9TdGL5M2a8+RpAPBRV8UqNFRgkcBpY5hCu693p9nw96MbnsiD9rJuZ15HeQF4pHvBzqK+QBg8WqAmDEiZikKv6RfnV5R+Nv5xHyfYpXZ8IbSXblcfoUj6JRGLzRQYI+kTkhCmDxcHLZfE3Gtf8O4IyONyoxDIxz7rBiWfTPD1eV4M6Gw3RAMWOCxqseJ8HLXQQlBPB/MRnS7R63dSgq4xbDk7woB8NqqpsdAJ4CwLPpCGP2BlWdYr4gXSh8YfpSzyL5JGdQ7zOQB5iuSoAoGjzb+af80yt5iitqlF8YeM8MvqVgaUMych4jvJU/Ob2idqiru+V6FM0lAxjJe9N61bXb6PnsSzltOJv5n1deao9uc9Gelq1SWTwq6CH2lak5D5C5FhEcs28jOieDCK91ERvofyptE36SImu0vVIHkqInCh0ZJuMOyX6I15iYKlOP3jZaCtgwIrrVBfUVDxTYwnKt/oomlXZanuMkusSjSqt+j3ZPqDkNUoX6SqWGzU+Yj514xHfU2UkEomEIwMEfUJF5c3KBlyk0NUsbGmmlu9xMEE5MwMDAz0OAi5DRWedZ3oUTWpJp1nME6Sz0+n0LM1nZ99nhM2sZ9m9p8XtGG7g8GDp6ZA+NEzwNz6DAynvVXfacDuAmoFjYxWNMH7HNPJOGSQcfPD2wHees6FdMgb8g6se6gIPXhbyEfNEmktLPZkWrivyCw1KdQ9n6qqqsuHh4S5tAwMD3VdM8rkQpRl0zxdnzfxbHZaH8uK8cRlVQSWvL/OI2y9yDjmNop/bSM3KRoGZUjvxb1Wu5xP1C+zTbOD6f+UkME/8GuoqPO9BrXJRvFR8cN3CfRm3F2E5qEc9HdcrgssE6gSsP/KB+yXPXGN+JR2gAquRA8NBT6y74h1CyS/rXtctHthjGVc0cd/gZfWeJpJ7HuuQPuSP2bq2VA6yChIjvZxeBbyRJyyvGCzG/FXf8rHOX1Ho+XF78QdXDng5DA4o+aorLp/1GvMVt874KxX9Mzw8bJ1Ox0ZGRnrO2kAaOFCPrxrl8ZJtFJZ1lGUFvs51ia41BY/3UZ7cD6N+FiF6JnquSfqJ1DeRmI6YDrI8HWhoigwQ9Al20pSzgIii7ma9TqV6DgdNtbJArRLw/HFvJDsZaCzWOapIC9a15ERwXm4kuEExc+bMnsPm3NhHBxaNA3TOPV8ONmDZHAxAYxTp4vq7w8FBAnQKeMYimgHx5zAN8tzlaGRkpPssbl/AgIk7vGpfeEmGWC4wb8wHjUaUE6aZ214Zv0wfIpqVYuNazQx62tHRURsYGOhxNvxaq/Xm/lU/KwLlRpWN+XIwIeo/SBP3Kafdf/u5Ccox4zzYcVA8x+vMe2w/ft4dYMxPOT/YpiznHLDCuuI2Fa6b58Oz5l4mOhO4H1rxAB0mpAcPLkN+qX4eOcklHeJyh8EnrAdvdSmt2OKVBwoceEO6MA3rKC7Dr2OgC51rTBuNaarPqPZFvuFvDNp62X4wnnLokW7Phz/oeKrxjdsfaUWaVd92nnN/QB3Cq5KUHGEf4XqwvnU+jIyM9PCgFOD0Awbx28saGRnpOVsGz2zpdDrdcl2enV6sMwcluA74H3+jHHr7eBDAAwPDw8P2xhtvdP+roAXKldPj9WCZxGA2twVfQ7Cs4zfXmfUf90V+Pgoe8bNMnypf/Vfl+HUOYmM6xYuI5ih9IpF4ayADBH2CZzfNeiPYeC8KDvBA446ccs45Uq/yUQYRG9lozOMzXoY/gwY9GuLK4HKw8Y3Gp3IyWq1Wz2wv1tONXj7F2A0a5I0amLFuTgseGMX7f71cHFT9QDseVKNl+dHsJTs5yB837NasWdNT96GhoW6gAPOeMWNGz2sgmQ4lgwx2mJlHbLQin5QxzfdKwSy/jm2HQKOdHSM2FtEgdLpHR0dt1qxZ0sjF4BK2A5eBqwcweFUKonHADevPDiM7VsqxYUeV5Yx5wW2DjgIGebhtsa+j7DjtvOwYaUOHE3nF9GBd0dHCNmAZdLlXzkhUd9SfkR5gIx/bR+ljpAd5hPXw51Aeub2VnJv1rjrgtlBOGYOdVeaN10WtGIv6N/OCecjyUBc8wLKcnx7Qw3vK2Yo+qKt45UakixHYbpgn93GWdSV7arzGMU7l57pNObVKJjio63n6KoyRkZGuA45lYMAU+zum43yxLvhxnmFbcZvwNayPtzmuHPDfHtxgGeOyzd4cl/EMIy8b64hQY28TsI5AmYzSYf2jPJWTXpcv6yZFF97n/NSYFZXhUHSqvp5IJDZvZICgT7BB4ogMLn4W0+Ksnhu5DHVdOWKcBh0DnI1nh0SVowIB+HxUd57NxzzZKGE6MCDhBybhAI/5orHOzpj/jtopchDqBkA2BksDcXTPf6Oz5v+9LvybjVemdaKDuDKs2Rjn+kQ8ZUQGupLTOqetRDv3HWXA4m/lwHK5pTL5d9TX0XirM9xUnUu6o2SANsm/ZMQi7VwPvld6vlQH1AMRXyJjNirfg2cTBddT1aOqqm45rOf8fonP/pudLc+3CX1NwAGGJk78RMGyovIv6WH8lPpSJLPqXimY5/fV1iGm25+t430drzGgFAX4VL3wNz/H9VaBEh5fOPA2WXge0UoPTIf93p9povMUkJ8s63X0Rn2BdRzXUelElU8/6Dcf1Uea0BXlNRFMhdwkEhsT00GGpwMNTZEBgj7hr+6LgHtLm6If5d4UPgPv74lvt9s9Mzl4mjvOluJsIM9UlxxyM+uZGTIrBxpwi8Hg4GDPlgF/RzSm4aXi6tV8bEDxrDgaL7wUlWnlZXpcd+SlCrZgGjaIxsbGemZ+cFlrq9XqzrT5s7600mlSsz7YZtHMIs9i+TW1goD5xDPbit+REY9QbcZGdFSO2brzKaqq6s6Sedm+pB9n3fBVjr5tg2dqcVbX+RcFcUpOAP+P+ITwctQr7VBu6mZG+ZwL1ZbskKm+4/XEgCcGrKL6Yp/zfPA+ymbdzCTyBXnBKzGQZjb0HSgrER8QWB7T5TOyPMOKs5nMD8xT0ew0ot7l2WLmM/OJ00Yrnbg9on7INPM+88iJYjnGlVtqxh/5wXli8I9XPvAZBJxe8ZvB2zC4Pop3SpdFKAVxvY1RrrF+HERzGcP6sd7GsxP8P74piPsP5ov90Wz8K1VV8Ax5rvQNjr9Oi491Y2NjPb/VGIO6mfmMNgHqK6bBn8W+ouQtaivMh8dEv6+c9giso9QzpXyYliiQi7RH+ZcQjeWJROKthQwQ9Ik1a9b0DOj9zOxExhGCDRtU/OxoKIPZP76f0Z2loaGh7v7sdrttIyMjPYe5+Tc740gXBw2YZjVwOtDoQSPYAwTo2Lkzh0EAd5L9owz1UlswjWyIsSOtjEGsV2mZK95j49j/47JLflMD0uztjOC6+7P4Dm3fwsGODNKCZfCSV66/MuCbGNlYhtOJ3/y7BJRPPkdhbGysu59VvZbStx+4HKmDGpF2NMrNxu8Hr6NZ1RmNYHS4me/omOE1dlqRXjT0OS3LJ/ZlpT+wjq3Wm8E4TOdOILYByjXKF+bF8qgcYXY20DFSQQeuE+tL1GMemGOec9BT8Y0PW2TniT/ssPo3jx2Yj+s9rIeXH/EK+cE6Tm31Yd4rx8KBDhXmx/oB5Y3bzh1D52HJ+UDecd9DHuKhdhxAUAdGYnuYWY8O4LL9t+Id92decVen07zP8xYdv8c8xe0AqKeZZp6UwLqMjY11z2RB+cSAAvafqqqs0+l0xxH1Kl5sE2wz1jveTp1Ox0ZHR21kZKS7vcD/8wGFkUw7Dc47fL0nbtvwOqsxjtsT6xTZYuoet5Ny+pHmOkT9oemzXKayNRV/mU4OcHKaUoA6kdgUMJm+tjnR0BQZIOgTHCAw0waC31eGa/ScMtZR2bPRohQ7Om1ogI6Ojlq73e46ifhOYTRS8KA8z4MNbgU2wvA6fjNtZtZ1bN0Y8X34HiAws54Agd9z+HNYD7yHxhcbsqrt2BlEJyMKECD8uh9AiM4Tz6j4HkzPm41h5hUGUtjZ8nqi8YTpnA4/JIzbjo1tNn4wPRtOyhhDfrDM9wuvh8utywuurPDVPXg4oKdzvvh/XoHi9cFT6zHQ0A/d7FzyvdIzmEbNrvGKFTTQvb5+n4NSWJb3l8jowzRmNm4GnvWAy3Wn0xnn4KHsIo89f/yPB9px3kiXWe9ZCBFQJ/iqHeQvOyesxzyNP4e0KudJOcne9xVN+GYUz0MdPOg8ZxnhwJCnKxn0HAhCcL+PnAzluLLDyDqS6UGdgG3h+tHBM8282gmdVSyLA2ZYjxkzZli73ZY6DH9zP3P+8jiL3/zbn3eZ4bM2nCbu784HrH+n0zEzkwEeXAHAvMa+gnxSkx1+kCHKKetKDnyh7Lus+3jngQD89iBB3YpL1EFYJ+6HWH8vVwURVRur9nKwHCn6IhuH8+cxsKS3orR1+Ti/WOajMj2/On0R2XeJRGLzRQYI+gQb51FwwO/XBQj4OXT21QDnRrSZjRsIUNljGW6UeEBAHcCnfkd1igataB9wk4EFjS83Npm3PgPMvENnBnngvFJBjX4GOzco2VhGo4ONJzb28MNGHw/k7FB43ZEXThPLkF8v8RhlmGlmQ0o5ulxnzifiIdaRn8N7UeDB29gdW3agkH6WD585RueSHStl8PozzAfuA1gm64hSXZGfnI7pUO2H17gu6nn8xro6XM6x37Cce1lYDy6P5YDbFQ1/7LuMSB5LhjmXy+VFfFOzxeisKdpVnuyw+of5x3zEPJCGkjNf4pXihWq3OoeF8+VAAfcbloM6ulSdWD9FsqXKZHmN9JLir+qfigf9QMk960M11qvg8sjISFd2VIAK+4VqE77ODjCnKQUQo/b259UYiAF1DhxH4wrbM2qiBFeDlMY//Obf3FZ16VXQQMmHGj+itEgDtyfTFAUIVN6RTlFlcDrVJolEYvNHBgj6BBqUjihIgAPeRAIEZr2HefHAiAMtD6JcBs/AYNlYljuYyjDA2VpVzzpjIgIuEcQIONPoeaAB4GnxGaw31gWvsXPCfEA+c10iRwbrig6CBzx4BYEKEODZA1gelsvOFM44suGHbc3GPNIeGZNYN04foZSeZTNKz0Y1txMb1CVgP0HnzGzdzLi3lafz5yKecN6REVeXFsvhNNhnOZ2iz2lX+TENqm8gOOiEq1ycfx5EUNtt2JBVejDqX7znXfFJ8VM5GcoBwA/rDeYrO7mKV9xmakabaS/Jrhpj6uQwgjL+le7n+9F/dACZR0xnE7BsK8eUnc1I13LgoM6pKfVP5XgrfjBKY4P/jvRLKUCl+IoTBapsbjfUe6o+kSw0GSuiYLgHNXy1AK6a43EIy2jikGKw2PsyribgsbDkbKu6Ii0leW46/nBZpfRqPGhSLpfVNLgY1RHr34/eSSSmI6aDDE8HGppiWgUIli1bZsuXL7ennnrK2u227b///va1r33NDjrooPCZhx56yP7u7/7O7r33XnvyySftm9/8pi1dujRMf+GFF9qXvvQlO/vss+3SSy/tm0ZfxqyMPQVlGDPYWETFzpFeTKf+My3oQHukXdHLqxFwNt7zVsEBrCfXLzJ4kHYz6y65ROfDzyJwOtwZ4b2RuO3A8/Tl437P64/vg0b+ssONz1VV717Quvq7g4CGkG818P9oHOHMCuallmg7/SMjIz3t6TT7oU04Y8l0e31Uu2AbsoGu6hrJs3JsSgEFBi7r90+0jQTzVzNH3IbIWwwO+HWUcZZfpon5h9fYoVRGH+bNToPZ+L3XkUHuaX31jeI70+PfvFQZDWrngcuvp8Ol8X7Pzx5ghxidfdy+gcEul1vsc8xH/jiUjuKAILYXOxRK7rlfYp9hXYt8w/6P8oP3UddE9fVZYk+jArbK6cC25d8ItTxe9WW+pxx13hKiHA8F5juf24JbFrhM9akLcCL/UE5YDpinzFvWR1zXSA+ovug0YACZ+w/yB7cOKLr8t9JTvC0j2qKGHyUbHNjmYBi2oY93a9assU6nY6tXr7Y1a9b0HM7refMYHMm3p8XfqANcn+EWMmwTDmZFZUQygHmVaG0aAFCIAhVN03JguS6PpvdKaSJceeWVdvHFF9uqVats0aJFdumll9phhx3Wdz6JRGLDY1oFCPbcc0+7/PLLbY899rA33njDvvnNb9qSJUvs17/+tW2//fbymdWrV9see+xhJ598sn3+858v5n/PPffY1Vdfbfvss8+EaXTnzJV8FLWPjLYmUM+qslS5/tvT+17HkmFj1nuStm9FwMEHZ9U5eKGcv8igjQxRNIr9AMWRkZGu4eJvNuCDFfGkeqfTnQ3coz40NNRT/8jAMrNufm7E4eFHJcMJ0+M+SwwU4KFdyBvf48xOLAcw2Hl2x8udXT6widvYyyu1BxuzXndsbyyL82fHmvNj+WEZx/bDdlVBLjamOU/kr8sCLkd1vinH0uvCJ46jY41GN5eJxqJyQLAN1GGXdU4PtwHWAdMxUKZYlrzvY5nunKAO8fr6CgIMwLDDgAarCq6qd71jnSJnkNsZ0+OsIQaWzHoPi/O0HLRzBwb7Pjua2DewTdC5VY4PyqgHRxG+HYZ54vlx+0b9iVEarzhAitdQt3EQiAORXAbKFtPC+o4DBCw7zHfuNywjZr2H2fHz3p9V27JOQp2AZ/REbYA0Rn0Zaee6ogOOfPf+XjrjA8cKv47b9lqtdYf+chBNBRe4Hhis4EAO6gI/82P16tU2PDxsr732WveQQsXfprKMtGL74tiBzyOvnXesT1lGo3FRyUcp+I26n2WjLogQ0VFKb6a3jjXNB+mK+k1TXHfddbZ06VK78sor7dBDD7Vvfetbdtxxx9nDDz9su+22W195JRKJDY9pFSD4+Mc/3vP/kksuse985zv2wAMP2DHHHCOfOfDAA+3AAw80M7PzzjsvzPu1116z0047za655hr76le/OmEa2SBhZYpOmGMyAQJGlFc0kDpw3zY6vT57p2hQ0XdlZPKAx05O07phHk4nOolYvhsIWCecacN2wMFfGT+Khmg2Gh3l6D4aSuobgyEOnvVHvrlDjM6C18EdNzTS3FBiJ5+DI6rd0WBmIxefYxq9TOQFflTAAmevkU7kPxq7bMBiOQooA+hkuEy47LOzjW3sDjDyXNVP0YH5KH4ibcpJiQIE2N7KEHQ+KR3Fzhtut+E+z2WwM4H9EQ1wlhVemcG0VlXVIwuKx/if26kuMIP1xVejYRo2+NH5YdmJnD+nCVcbeJlYnlo5gG2O8uYrQzjgEaFurOH7GNTjvsU8QWfVr6vAFgdFGKo9UafwDDUHCJQzF+kBNQZ5Xf0e6jyVP/OLZVTxN3qe+5Sqr+KT0rmeB64y4QCcty+egaHeUsR9Gz8sn/zBdsTggf/udDo2PDzcXT3gwVpcDcZ9uamdgN8YuEHdrrYRMY/V9Tq9grxR+URBB8yH7/WTJ+poTs/0Nq23opvza4pLLrnE/vzP/9z+4i/+wszMLr30UvvP//xPu+qqq+zCCy/sK69EYqrQrxy/laFPc5kG6HQ6dvXVV9u8efNs3333nXR+n/3sZ+2P/uiP7Nhjj510Xkrp4/+SMq0TzsneL6Vt+my/Tr1KV3qm5FSVDD3OV9G5sTt/XduXBn+8HhkW6ncdPf5dmulwNEnTpMx+aJvo/Ymm7QdTmW8dX5rcX1+01TmeXl7TvtlvHiq/iaIfeprmpfLjvhgZ6FNFy4ZA02D2+qxPnY7za1Ohq5qi3yC/wsaWgTqnsDRrP9HyVJ+ZqH0xXbGp9fMNQWOn07F7773XlixZ0nN9yZIldvfdd6/38hOJxOQxrVYQmJl973vfs4997GO2evVqW7Bgga1YscK22267SeW5fPly+8UvfmH33HNP42eGh4dteHi4+//ll1/u/i4Z6nWDxfo2jlV+arbCzMbNVrADytHsuhUEZuOjz02c+FKEG9PjSgF8xmcrcMYDZ1T8ntm6gxDr4G9L8D2UyBN/KwTOoPiySnydU6fT6dlagGcQMHx1AS65xVls/DhPcQYBt1T4jCXPfPKSzJKBXQpGRCsISrPlqs68SgBnPHA2jGdfed86tjNuReCtGTjLhHtgfSsLvq8dy8RZYMynFOji+kQOI/dLnN3mFQQ4y4ZywvlGKwj8eZQlnE2sqqr7ijM1Q+h1GRwc7Nnu4zzz/JFelGt8VSnOwiEtPLPP/R9lCc8tQdn0fPHj8sKvFnXafaYTV//4th/8oH5DPYrtyVsMeHUEbp9xWRwYGOjKnW8xcP76iiNejYDtrVYXNFnNplYQcFpcUeG88TybrCBAXelpUMbwvrcFH2Sn+pfnp1Y84QF+pZVS3h68goD7O85286obfwbrjSuCnB7Wx7ytAl/95x/mB58f4/xGOlFWx8beXIXnZ4VgP/MPyq+PY6h7cTUdn6vDsqC2GPgH64Wyx/qdwWd6YN3xDAzmqVqZwv05sreUjYdth9eaBAgi3d+kvCiv6Fs934TGUtl47ZVXXrFXXnmle29oaMiGhoZ60j///PO2du1a23HHHXuu77jjjvbMM88Uy08kEtMDGy1A8K//+q/26U9/uvv/Bz/4gR122GF21FFH2f3332/PP/+8XXPNNXbKKafYz372M9thhx0mVM5TTz1lZ599tv3oRz+yWbNmNX7uwgsvtAsuuGBCZTKUsp3K/Ep5+nuT33jjjUmVmUgkEolEIpF462LRokU9/88//3xbtmyZTKsmk6ZqhUoi0RTtdtvmz58/bYJT8+fPt3a7vbHJqEWrmqy3OkG8+uqr9uyzz3b/77zzzjZ79uxx6d71rnfZpz71KfviF79Ym+fb3/52W7p0ac9bDG666SY76aSTevZv+0zNjBkzbHh4WB6OxSsIXnrpJVu4cKGtXLnS5s2b17SaiT7xyiuv2K677mpPPfWUbbnllhubnM0WyecNg+TzhkHyecMg+bz+kTzeMEg+94exsTF78sknbbfdduuxmdUKgk6nY29729vs3//93+2kk07qXj/77LPt/vvvtzvuuGOD0Z1ImFn3bSrTAe12u68J642FjbaCYO7cuTZ37tzadFVV9Tjq/eKYY46xBx98sOfaJz/5SXvPe95jf/3Xfy2DA2Za6ZmZzZs3LweTDYAtt9wy+bwBkHzeMEg+bxgknzcMks/rH8njDYPkc3NstdVWjdL5a8pXrFjREyBYsWKFnXDCCeuJukQixqxZszYJp3w6YdqcQfD666/b1772NfvIRz5iCxYssBdeeMGuvPJK++1vf2snn3xyN92f/dmf2c4779w9BbXT6djDDz/c/f3000/b/fffb1tssYW9853vtLlz59rixYt7ypozZ45tu+22464nEolEIpFIJBKJieOcc86xP/3TP7UDDjjADj74YLv66qtt5cqVdsYZZ2xs0hKJRANMmwDBzJkz7X/+53/s2muvteeff9623XZbO/DAA+3OO+/s2fO0cuXKnoNs/vd//9d+7/d+r/v/G9/4hn3jG9+wI444wm6//fYNWYVEIpFIJBKJROItjVNPPdVeeOEF+8pXvmKrVq2yxYsX2y233GILFy7c2KQlEokGmDYBglmzZtkNN9xQm46d/re//e19H/o3kcDB0NCQnX/++XLbQWLqkHzeMEg+bxgknzcMks8bBsnn9Y/k8YZB8nn948wzz7QzzzxzY5ORSCQmgI12SGEikUgkEolEIpFIJBKJ6YPxL51NJBKJRCKRSCQSiUQi8ZZDBggSiUQikUgkEolEIpFIZIAgkUgkEolEIpFIJBKJRAYIEolEIpFIJBKJRCKRSFgGCBrjyiuvtN13391mzZpl+++/v915550bm6RNFsuWLbNWq9XzmT9/fvd+VVW2bNky22mnnWz27Nl25JFH2kMPPbQRKd408JOf/MQ+/OEP20477WStVstuuummnvtN+Do8PGyf+9znbLvttrM5c+bYRz7yEfvtb3+7AWsx/VHH50984hPj5Pv3f//3e9Ikn8u48MIL7cADD7S5c+faDjvsYCeeeKL96le/6kmT8jx5NOFzyvPkcdVVV9k+++xjW265pW255ZZ28MEH2w9+8IPu/ZTlqUEdn1OWE4lEohkyQNAA1113nS1dutT+5m/+xu677z477LDD7LjjjrOVK1dubNI2WSxatMhWrVrV/Tz44IPde1//+tftkksuscsvv9zuuecemz9/vv3BH/yBvfrqqxuR4umP119/3fbdd1+7/PLL5f0mfF26dKndeOONtnz5crvrrrvstddes+OPP97Wrl27oaox7VHHZzOzD37wgz3yfcstt/TcTz6Xcccdd9hnP/tZ++lPf2orVqyw0dFRW7Jkib3++uvdNCnPk0cTPpulPE8Wu+yyi1100UX285//3H7+85/b0UcfbSeccEI3CJCyPDWo47NZynIikUg0QpWoxfvf//7qjDPO6Ln2nve8pzrvvPM2EkWbNs4///xq3333lffGxsaq+fPnVxdddFH32po1a6p58+ZV//iP/7iBKNz0YWbVjTfe2P3fhK8vvfRSNTg4WC1fvryb5umnn65mzJhR/fCHP9xgtG9KYD5XVVWdfvrp1QknnBA+k3zuH88991xlZtUdd9xRVVXK8/oC87mqUp7XF7beeuvq29/+dsryeobzuapSlhOJRKIpcgVBDTqdjt177722ZMmSnutLliyxu+++eyNRtenj0UcftZ122sl23313+9jHPma/+c1vzMzs8ccft2eeeaaH30NDQ3bEEUckvyeBJny99957bWRkpCfNTjvtZIsXL07e94nbb7/ddthhB9tzzz3tL//yL+25557r3ks+94+XX37ZzMy22WYbM0t5Xl9gPjtSnqcOa9euteXLl9vrr79uBx98cMryegLz2ZGynEgkEvUY2NgETHc8//zztnbtWttxxx17ru+44472zDPPbCSqNm0cdNBB9s///M+255572rPPPmtf/epX7ZBDDrGHHnqoy1PF7yeffHJjkLtZoAlfn3nmGWu327b11luPS5Oy3hzHHXecnXzyybZw4UJ7/PHH7W//9m/t6KOPtnvvvdeGhoaSz32iqio755xz7AMf+IAtXrzYzFKe1wcUn81SnqcKDz74oB188MG2Zs0a22KLLezGG2+0vffeu+t4pixPDSI+m6UsJxKJRFNkgKAhWq1Wz/+qqsZdSzTDcccd1/393ve+1w4++GB7xzveYddee233wKDk9/rBRPiavO8Pp556avf34sWL7YADDrCFCxfa97//ffvoRz8aPpd81jjrrLPsgQcesLvuumvcvZTnqUPE55TnqcG73/1uu//+++2ll16y66+/3k4//XS74447uvdTlqcGEZ/33nvvlOVEIpFoiNxiUIPtttvOZs6cOS56/Nxzz42L+Ccmhjlz5th73/tee/TRR7tvM0h+Ty2a8HX+/PnW6XTsxRdfDNMk+seCBQts4cKF9uijj5pZ8rkffO5zn7Obb77ZbrvtNttll12611OepxYRnxVSnieGdrtt73znO+2AAw6wCy+80Pbdd1+77LLLUpanGBGfFVKWE4lEQiMDBDVot9u2//7724oVK3qur1ixwg455JCNRNXmheHhYXvkkUdswYIFtvvuu9v8+fN7+N3pdOyOO+5Ifk8CTfi6//772+DgYE+aVatW2S9/+cvk/STwwgsv2FNPPWULFiwws+RzE1RVZWeddZbdcMMN9uMf/9h23333nvspz1ODOj4rpDxPDaqqsuHh4ZTl9Qzns0LKciKRSATY4MciboJYvnx5NTg4WH3nO9+pHn744Wrp0qXVnDlzqieeeGJjk7ZJ4txzz61uv/326je/+U3105/+tDr++OOruXPndvl50UUXVfPmzatuuOGG6sEHH6z+5E/+pFqwYEH1yiuvbGTKpzdeffXV6r777qvuu+++ysyqSy65pLrvvvuqJ598sqqqZnw944wzql122aW69dZbq1/84hfV0UcfXe27777V6OjoxqrWtEOJz6+++mp17rnnVnfffXf1+OOPV7fddlt18MEHVzvvvHPyuQ985jOfqebNm1fdfvvt1apVq7qf1atXd9OkPE8edXxOeZ4afPGLX6x+8pOfVI8//nj1wAMPVF/60peqGTNmVD/60Y+qqkpZniqU+JyynEgkEs2RAYKGuOKKK6qFCxdW7Xa7et/73tfzGqhEfzj11FOrBQsWVIODg9VOO+1UffSjH60eeuih7v2xsbHq/PPPr+bPn18NDQ1Vhx9+ePXggw9uRIo3Ddx2222VmY37nH766VVVNePrG2+8UZ111lnVNttsU82ePbs6/vjjq5UrV26E2kxflPi8evXqasmSJdX2229fDQ4OVrvttlt1+umnj+Nh8rkMxV8zq7773e9206Q8Tx51fE55nhp86lOf6toP22+/fXXMMcd0gwNVlbI8VSjxOWU5kUgkmqNVVVW14dYrJBKJRCKRSCQSiUQikZiOyDMIEolEIpFIJBKJRCKRSGSAIJFIJBKJRCKRSCQSiUQGCBKJRCKRSCQSiUQikUhYBggSiUQikUgkEolEIpFIWAYIEolEIpFIJBKJRCKRSFgGCBKJRCKRSCQSiUQikUhYBggSiUQikUgkEolEIpFIWAYIEolEIlGDI4880pYuXbrJ5DvVeOKJJ6zVatn999+/sUlJJBKJRCKRWK8Y2NgEJBKJROKtiRtuuMEGBwc3WHm33367HXXUUfbiiy/aVltttcHKTSQSiUQikdhUkAGCRCKRSGxQjIyM2ODgoG2zzTYbm5REIpFIJBKJBCC3GCQSiUSiFmNjY/aFL3zBttlmG5s/f74tW7ase2/lypV2wgkn2BZbbGFbbrmlnXLKKfbss8927y9btsz2228/+6d/+ifbY489bGhoyKqq6tlicPvtt1ur1Rr3+cQnPtHN56qrrrJ3vOMd1m637d3vfrf9y7/8Sw+NrVbLvv3tb9tJJ51kb3vb2+xd73qX3XzzzWb25jaBo446yszMtt566568f/jDH9oHPvAB22qrrWzbbbe1448/3h577LGpZ2IikUgkEonENEcGCBKJRCJRi2uvvdbmzJljP/vZz+zrX/+6feUrX7EVK1ZYVVV24okn2u9+9zu74447bMWKFfbYY4/Zqaee2vP8r3/9a/u3f/s3u/766+Ve/kMOOcRWrVrV/fz4xz+2WbNm2eGHH25mZjfeeKOdffbZdu6559ovf/lL+/SnP22f/OQn7bbbbuvJ54ILLrBTTjnFHnjgAfvQhz5kp512mv3ud7+zXXfd1a6//nozM/vVr35lq1atsssuu8zMzF5//XU755xz7J577rH/+q//shkzZthJJ51kY2Nj64GTiUQikUgkEtMXraqqqo1NRCKRSCSmL4488khbu3at3Xnnnd1r73//++3oo4+2Y445xo477jh7/PHHbddddzUzs4cfftgWLVpk//3f/20HHnigLVu2zP7hH/7Bnn76adt+++178t1vv/3s0ksv7SnvhRdesIMOOsj+8A//0K644gozMzv00ENt0aJFdvXVV3fTnXLKKfb666/b97//fTN7cwXBl7/8Zfv7v/97M3vT8Z87d67dcsst9sEPfrDxGQT/93//ZzvssIM9+OCDtnjxYnviiSds9913t/vuu8/222+/ybAykUgkEolEYlojVxAkEolEohb77LNPz/8FCxbYc889Z4888ojtuuuu3eCAmdnee+9tW221lT3yyCPdawsXLuwJDkQYGRmxP/7jP7bddtutO8NvZvbII4/YoYce2pP20EMP7SmD6ZwzZ47NnTvXnnvuuWKZjz32mH384x+3PfbYw7bcckvbfffdzezNrROJRCKRSCQSbyXkIYWJRCKRqAW/baDVatnY2JhVVWWtVmtcer4+Z86cRuV85jOfsZUrV9o999xjAwO9QxSXo8qO6Czhwx/+sO266652zTXX2E477WRjY2O2ePFi63Q6jWhOJBKJRCKR2FyQKwgSiUQiMWHsvffetnLlSnvqqae61x5++GF7+eWXba+99uorr0suucSuu+46u/nmm23bbbftubfXXnvZXXfd1XPt7rvv7quMdrttZmZr167tXnvhhRfskUcesS9/+ct2zDHH2F577WUvvvhiX3QnEolEIpFIbC7IFQSJRCKRmDCOPfZY22effey0006zSy+91EZHR+3MM8+0I444wg444IDG+dx66632hS98wa644grbbrvt7JlnnjEzs9mzZ9u8efPsr/7qr+yUU06x973vfXbMMcfYf/zHf9gNN9xgt956a+MyFi5caK1Wy773ve/Zhz70IZs9e7ZtvfXWtu2229rVV19tCxYssJUrV9p5553XNx8SiUQikUgkNgfkCoJEIpFITBitVstuuukm23rrre3www+3Y4891vbYYw+77rrr+srnrrvusrVr19oZZ5xhCxYs6H7OPvtsMzM78cQT7bLLLrOLL77YFi1aZN/61rfsu9/9rh155JGNy9h5553tggsusPPOO8923HFHO+uss2zGjBm2fPlyu/fee23x4sX2+c9/3i6++OK+aE8kEolEIpHYXJBvMUgkEolEIpFIJBKJRCKRKwgSiUQikUgkEolEIpFIZIAgkUgkEolEIpFIJBKJhGWAIJFIJBKJRCKRSCQSiYRlgCCRSCQSiUQikUgkEomEZYAgkUgkEolEIpFIJBKJhGWAIJFIJBKJRCKRSCQSiYRlgCCRSCQSiUQikUgkEomEZYAgkUgkEolEIpFIJBKJhGWAIJFIJBKJRCKRSCQSiYRlgCCRSCQSiUQikUgkEomEZYAgkUgkEolEIpFIJBKJhGWAIJFIJBKJRCKRSCQSiYSZ/T+zetxrd2/tCAAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "reader = ZEISSDataReader()\n", - "filename = '../../../data/valnut_tomo-A.txrm'\n", - "reader.set_up(file_name=filename)\n", - "data3D = reader.read()\n", - "\n", - "# reorder data to match default order for Astra/Tigre operator\n", - "data3D.reorder('astra')\n", - "\n", - "# Get Image and Acquisition geometries\n", - "ag3D = data3D.geometry\n", - "ig3D = ag3D.get_ImageGeometry()\n", - "\n", - "# Extract vertical slice\n", - "data2D = data3D.get_slice(vertical='centre')\n", - "\n", - "# Select every 10 angles\n", - "sliced_data = Slicer(roi={'angle':(0,1601,10)})(data2D)\n", - "\n", - "# Reduce background regions\n", - "binned_data = Binner(roi={'horizontal':(120,-120,2)})(sliced_data)\n", - "\n", - "# Create absorption data \n", - "data = TransmissionAbsorptionConverter()(binned_data) \n", - "\n", - "# Remove circular artifacts\n", - "data -= np.mean(data.as_array()[80:100,0:30])\n", - "\n", - "# Get Image and Acquisition geometries for one slice\n", - "ag2D = data.geometry\n", - "ag2D.set_angles(ag2D.angles, initial_angle=0.2, angle_unit='radian')\n", - "ig2D = ag2D.get_ImageGeometry()\n", - "\n", - "A = ProjectionOperator(ig2D, ag2D, device = \"gpu\")\n", - "\n", - "show2D(data)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Define number of subsets\n", - "n_subsets = 10\n", - "\n", - "partitioned_data=data.partition(n_subsets, 'staggered')\n", - "show2D(partitioned_data)\n", - "\n", - "\n", - "# Initialize the lists containing the F_i's and A_i's\n", - "f_subsets = []\n", - "\n", - "\n", - "# Define F_i's \n", - "for i in range(n_subsets):\n", - " # Define F_i and put into list\n", - " fi = 0.5*L2NormSquared(b = partitioned_data[i])\n", - " f_subsets.append(fi)\n", - " \n", - " \n", - "ageom_subset = partitioned_data.geometry\n", - "A = ProjectionOperator(ig2D, ageom_subset)\n", - "\n", - "#F = L2NormSquared.fromBlockDataContainer(partitioned_data, constant=0.5)\n", - "\n", - "# Define F and K\n", - "F = BlockFunction(*f_subsets)\n", - "K = A\n", - "\n", - "# Define G (by default the positivity constraint is on)\n", - "alpha = 0.025\n", - "G = alpha * FGP_TV()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n" - ] - } - ], - "source": [ - "print(ageom_subset)\n", - "print(A)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "ename": "TypeError", - "evalue": "object of type 'BlockFunction' has no len()", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[5], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39m# Setup and run SPDHG for 50 iterations\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m spdhg \u001b[39m=\u001b[39m SPDHG(f \u001b[39m=\u001b[39;49m F, g \u001b[39m=\u001b[39;49m G, operator \u001b[39m=\u001b[39;49m K, max_iteration \u001b[39m=\u001b[39;49m \u001b[39m50\u001b[39;49m,\n\u001b[1;32m 3\u001b[0m update_objective_interval \u001b[39m=\u001b[39;49m \u001b[39m10\u001b[39;49m, sampler\u001b[39m=\u001b[39;49mSampler\u001b[39m.\u001b[39;49msequential(n_subsets))\n\u001b[1;32m 4\u001b[0m spdhg\u001b[39m.\u001b[39mrun()\n\u001b[1;32m 6\u001b[0m spdhg_recon \u001b[39m=\u001b[39m spdhg\u001b[39m.\u001b[39msolution \n", - "File \u001b[0;32m/app/cil/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py:107\u001b[0m, in \u001b[0;36mSPDHG.__init__\u001b[0;34m(self, f, g, operator, tau, sigma, initial, prob, gamma, sampler, **kwargs)\u001b[0m\n\u001b[1;32m 102\u001b[0m \u001b[39msuper\u001b[39m(SPDHG, \u001b[39mself\u001b[39m)\u001b[39m.\u001b[39m\u001b[39m__init__\u001b[39m(\u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[1;32m 106\u001b[0m \u001b[39mif\u001b[39;00m f \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m operator \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39mand\u001b[39;00m g \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m:\n\u001b[0;32m--> 107\u001b[0m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mset_up(f\u001b[39m=\u001b[39;49mf, g\u001b[39m=\u001b[39;49mg, operator\u001b[39m=\u001b[39;49moperator, tau\u001b[39m=\u001b[39;49mtau, sigma\u001b[39m=\u001b[39;49msigma, \n\u001b[1;32m 108\u001b[0m initial\u001b[39m=\u001b[39;49minitial, prob\u001b[39m=\u001b[39;49mprob, gamma\u001b[39m=\u001b[39;49mgamma,sampler\u001b[39m=\u001b[39;49msampler, norms\u001b[39m=\u001b[39;49mkwargs\u001b[39m.\u001b[39;49mget(\u001b[39m'\u001b[39;49m\u001b[39mnorms\u001b[39;49m\u001b[39m'\u001b[39;49m, \u001b[39mNone\u001b[39;49;00m))\n", - "File \u001b[0;32m/app/cil/Wrappers/Python/cil/optimisation/algorithms/SPDHG_sampling.py:147\u001b[0m, in \u001b[0;36mSPDHG.set_up\u001b[0;34m(self, f, g, operator, tau, sigma, initial, prob, gamma, sampler, norms)\u001b[0m\n\u001b[1;32m 145\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msigma \u001b[39m=\u001b[39m sigma\n\u001b[1;32m 146\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mprob \u001b[39m=\u001b[39m prob\n\u001b[0;32m--> 147\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mndual_subsets \u001b[39m=\u001b[39m \u001b[39mlen\u001b[39;49m(\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mf)\n\u001b[1;32m 148\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mgamma \u001b[39m=\u001b[39m gamma\n\u001b[1;32m 149\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mrho \u001b[39m=\u001b[39m \u001b[39m.99\u001b[39m\n", - "\u001b[0;31mTypeError\u001b[0m: object of type 'BlockFunction' has no len()" - ] - } - ], - "source": [ - "# Setup and run SPDHG for 50 iterations\n", - "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampler.sequential(n_subsets))\n", - "spdhg.run()\n", - "\n", - "spdhg_recon = spdhg.solution " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 50 0.000 6.90194e+03\n", - " 10 50 0.071 1.68032e+02\n", - " 20 50 0.114 4.89967e+01\n", - " 30 50 0.096 4.18854e+01\n", - " 40 50 0.096 3.86103e+01\n", - " 50 50 0.092 3.70240e+01\n", - "-------------------------------------------------------\n", - " 50 50 0.092 3.70240e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - } - ], - "source": [ - "# Setup and run SPDHG for 50 iterations\n", - "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampler.randomWithReplacement(n_subsets))\n", - "spdhg.run()\n", - "\n", - "spdhg_recon = spdhg.solution " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 50 0.000 6.90194e+03\n", - "[8 7 5 4 3 2 6 0 9 1]\n", - " 10 50 2.593 1.57735e+02\n", - "[2 0 9 6 3 5 1 4 8 7]\n", - " 20 50 2.916 5.82732e+01\n", - "[3 4 1 9 5 6 2 8 7 0]\n", - " 30 50 3.032 4.02467e+01\n", - "[4 9 6 2 5 3 7 1 0 8]\n", - " 40 50 2.937 3.73084e+01\n", - "[0 7 2 6 8 3 5 9 4 1]\n", - " 50 50 2.880 3.50773e+01\n", - "-------------------------------------------------------\n", - " 50 50 2.880 3.50773e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - } - ], - "source": [ - "# Setup and run SPDHG for 50 iterations\n", - "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10 , sampler=Sampler.randomWithoutReplacement(n_subsets))\n", - "spdhg.run()\n", - "\n", - "spdhg_recon = spdhg.solution " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Iter Max Iter Time/Iter Objective\n", - " [s] \n", - " 0 50 0.000 6.90194e+03\n", - " 10 50 2.494 1.56371e+02\n", - " 20 50 3.314 5.73612e+01\n", - " 30 50 3.081 4.46291e+01\n", - " 40 50 2.944 4.00863e+01\n", - " 50 50 2.862 3.69452e+01\n", - "-------------------------------------------------------\n", - " 50 50 2.862 3.69452e+01\n", - "Stop criterion has been reached.\n", - "\n" - ] - } - ], - "source": [ - "spdhg = SPDHG(f = F, g = G, operator = K, max_iteration = 50,\n", - " update_objective_interval = 10, sampler=Sampler.hermanMeyer(n_subsets))\n", - "spdhg.run()\n", - "\n", - "spdhg_recon = spdhg.solution " - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "cil", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.10.12" - }, - "orig_nbformat": 4 - }, - "nbformat": 4, - "nbformat_minor": 2 -} From 25806fcf8b910ba80f9c536839c05d958ccd1016 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 14 Aug 2023 15:40:25 +0000 Subject: [PATCH 010/115] Added staggered and custom order and started with writing documentation --- Wrappers/Python/cil/framework/sampler.py | 296 +++++++++++++++++++++++ 1 file changed, 296 insertions(+) create mode 100644 Wrappers/Python/cil/framework/sampler.py diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py new file mode 100644 index 0000000000..09472ab721 --- /dev/null +++ b/Wrappers/Python/cil/framework/sampler.py @@ -0,0 +1,296 @@ +# -*- coding: utf-8 -*- +# This work is part of the Core Imaging Library (CIL) developed by CCPi +# (Collaborative Computational Project in Tomographic Imaging), with +# substantial contributions by UKRI-STFC and University of Manchester. + +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at + +# http://www.apache.org/licenses/LICENSE-2.0 + +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import numpy as np +import math +import time + +class Sampler(): + + r""" + A class to select from a list of integers {0, 1, …, S-1}, with each integer representing the index of a subset + The function next() outputs a single next index from the {0,1,…,S-1} subset list. Different orders possible incl with and without replacement. To be run again and again, depending on how many iterations/epochs the users asks for. + + Calls are organised into epochs: The single index outputs can be organised into length-S lists. Each length-S list is called an epoch. The user can in principle ask for an infinite number of epochs to be run. Denote by E the number of epochs. + Each epoch always has a list of length S. It may contain the same subset index s multiple times or not at all. + + Parameters + ---------- + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + sampling_type:str + The sampling type used. + + order: list of integers + The list of integers the method selects from using next. + + shuffle= bool, default=False + If True, after each epoch (num_subsets calls of next), the sampling order is shuffled randomly. + + prob: list of floats of length num_subsets that sum to 1. + For random sampling with replacement, this is the probability for each integer to be called by next. + + seed:int, default=None + Random seed for the methods that use a random number generator. + + + + Example + ------- + + >>> sampler=Sampler.sequential(10) + >>> sampler.show_epochs(5) + >>> for _ in range(11): + print(sampler.next()) + + Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + 1 + + Example + ------- + >>> sampler=Sampler.randomWithReplacement(11) + >>> for _ in range(12): + >>> print(next(sampler)) + >>> sampler.show_epochs(5) + + 10 + 5 + 10 + 1 + 6 + 7 + 10 + 0 + 0 + 2 + 5 + 3 + Epoch 0: [10, 5, 10, 1, 6, 7, 10, 0, 0, 2, 5] + Epoch 1: [3, 10, 7, 7, 8, 7, 4, 7, 8, 4, 9] + Epoch 2: [0, 0, 0, 1, 3, 8, 6, 5, 7, 7, 0] + Epoch 3: [8, 8, 6, 4, 0, 2, 7, 2, 8, 3, 8] + Epoch 4: [10, 9, 3, 6, 6, 9, 5, 2, 8, 4, 0] + + + + """ + + @staticmethod + def sequential(num_subsets): + """ + Function that outputs a sampler that outputs sequentially. + + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + Example + ------- + + >>> sampler=Sampler.sequential(10) + >>> sampler.show_epochs(5) + >>> for _ in range(11): + print(sampler.next()) + + Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + 0 + 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 0 + 1 + """ + order=list(range(num_subsets)) + sampler=Sampler(num_subsets, sampling_type='sequential', order=order) + return sampler + + @staticmethod + def customOrder( customlist): + """ + Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. + + customlist: list of integers + The list that will be sampled from in order. + """ + num_subsets=len(customlist) + sampler=Sampler(num_subsets, sampling_type='custom_order', order=customlist) + return sampler + + @staticmethod + def hermanMeyer(num_subsets): + + def _herman_meyer_order(n): + # Assuming that the subsets are in geometrical order + n_variable = n + i = 2 + factors = [] + while i * i <= n_variable: + if n_variable % i: + i += 1 + else: + n_variable //= i + factors.append(i) + if n_variable > 1: + factors.append(n_variable) + n_factors = len(factors) + order = [0 for _ in range(n)] + value = 0 + for factor_n in range(n_factors): + n_rep_value = 0 + if factor_n == 0: + n_change_value = 1 + else: + n_change_value = math.prod(factors[:factor_n]) + for element in range(n): + mapping = value + n_rep_value += 1 + if n_rep_value >= n_change_value: + value = value + 1 + n_rep_value = 0 + if value == factors[factor_n]: + value = 0 + order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping + return order + + order=_herman_meyer_order(num_subsets) + sampler=Sampler(num_subsets, sampling_type='herman_meyer', order=order) + return sampler + + @staticmethod + def staggered(num_subsets, offset): + indices=list(range(num_subsets)) + order=[] + [order.extend(indices[i::offset]) for i in range(offset)] + # order=[indices[i::offset] for i in range(offset)] + print(order) + sampler=Sampler(num_subsets, sampling_type='staggered', order=order) + return sampler + + + + @staticmethod + def randomWithReplacement(num_subsets, prob=None, seed=None): + if prob==None: + prob = [1/num_subsets] *num_subsets + else: + prob=prob + if len(prob)!=num_subsets: + raise ValueError("Length of the list of probabilities should equal the number of subsets") + if sum(prob)!=1.: + raise ValueError("Probabilites should sum to 1.") + sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) + return sampler + + @staticmethod + def randomWithoutReplacement(num_subsets, seed=None): + order=list(range(num_subsets)) + sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) + return sampler + + + def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): + self.type=sampling_type + self.num_subsets=num_subsets + if seed !=None: + self.seed=seed + else: + self.seed=int(time.time()) + self.generator=np.random.RandomState(self.seed) + self.order=order + self.initial_order=order + if order!=None: + self.iterator=self._next_order + self.prob=prob + if prob!=None: + self.iterator=self._next_prob + self.shuffle=shuffle + self.last_subset=self.num_subsets-1 + + + + + def _next_order(self): + # print(self.last_subset) + if self.shuffle==True and self.last_subset==self.num_subsets-1: + self.order=self.generator.permutation(self.order) + #print(self.order) + self.last_subset= (self.last_subset+1)%self.num_subsets + return(self.order[self.last_subset]) + + def _next_prob(self): + return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) + + def next(self): + return (self.iterator()) + + def __next__(self): + return(self.next()) + + def show_epochs(self, num_epochs=2): + save_generator=self.generator + save_last_subset=self.last_subset + self.last_subset=self.num_subsets-1 + save_order=self.order + self.order=self.initial_order + self.generator=np.random.RandomState(self.seed) + for i in range(num_epochs): + print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) + self.generator=save_generator + self.order=save_order + self.last_subset=save_last_subset + + def get_epochs(self, num_epochs=2): + save_generator=self.generator + save_last_subset=self.last_subset + self.last_subset=self.num_subsets-1 + save_order=self.order + self.order=self.initial_order + self.generator=np.random.RandomState(self.seed) + output=[] + for i in range(num_epochs): + output.append( [self.next() for _ in range(self.num_subsets)]) + self.generator=save_generator + self.order=save_order + self.last_subset=save_last_subset + return(output) + From 75abbfe3149df26b792480f9eb2dccb5e368e554 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 14 Aug 2023 16:14:46 +0000 Subject: [PATCH 011/115] Work on documentation --- Wrappers/Python/cil/framework/sampler.py | 33 ++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 09472ab721..7befd5319a 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -264,9 +264,28 @@ def next(self): return (self.iterator()) def __next__(self): + """ Allows the user to call next(sampler), to get the same result as sampler.next()""" return(self.next()) def show_epochs(self, num_epochs=2): + """ + Function that takes an integer, num_epochs, and prints the first num_epochs epochs. Calling this function will not interrupt the random number generation, if applicable. + + num_epochs: int, default=2 + The number of epochs to print. + + Example + ------- + + >>> sampler=Sampler.randomWithoutReplacement(11) + >>> sampler.show_epochs(5) + Epoch 0: [9, 7, 2, 8, 0, 10, 1, 5, 3, 6, 4] + Epoch 1: [6, 2, 0, 10, 5, 1, 9, 8, 7, 4, 3] + Epoch 2: [5, 10, 0, 6, 1, 4, 3, 7, 2, 8, 9] + Epoch 3: [4, 8, 3, 7, 1, 10, 5, 6, 2, 9, 0] + Epoch 4: [0, 7, 2, 6, 9, 10, 8, 3, 1, 4, 5] + + """ save_generator=self.generator save_last_subset=self.last_subset self.last_subset=self.num_subsets-1 @@ -280,6 +299,20 @@ def show_epochs(self, num_epochs=2): self.last_subset=save_last_subset def get_epochs(self, num_epochs=2): + """ + Function that takes an integer, num_epochs, and returns the first num_epochs epochs in the form of a list of lists. Calling this function will not interrupt the random number generation, if applicable. + + num_epochs: int, default=2 + The number of epochs to return. + + Example + ------- + + >>> sampler=Sampler.randomWithReplacement(5) + >>> print(sampler.get_epochs()) + [[3, 2, 2, 4, 4], [0, 1, 2, 4, 4]] + + """ save_generator=self.generator save_last_subset=self.last_subset self.last_subset=self.num_subsets-1 From ebdf32978a7aed90845a76122b1ebd4fd81620c6 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 15 Aug 2023 08:34:31 +0000 Subject: [PATCH 012/115] Commenting and examples in the class --- Wrappers/Python/cil/framework/sampler.py | 165 ++++++++++++++++++++++- 1 file changed, 160 insertions(+), 5 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 7befd5319a..0c2dda2ad2 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -47,7 +47,7 @@ class Sampler(): For random sampling with replacement, this is the probability for each integer to be called by next. seed:int, default=None - Random seed for the methods that use a random number generator. + Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. @@ -151,6 +151,19 @@ def customOrder( customlist): customlist: list of integers The list that will be sampled from in order. + + Example + -------- + + >>> sampler=Sampler.customOrder([1,4,6,7,8,9,11]) + >>> sampler.show_epochs(5) + + Epoch 0: [1, 4, 6, 7, 8, 9, 11] + Epoch 1: [1, 4, 6, 7, 8, 9, 11] + Epoch 2: [1, 4, 6, 7, 8, 9, 11] + Epoch 3: [1, 4, 6, 7, 8, 9, 11] + Epoch 4: [1, 4, 6, 7, 8, 9, 11] + """ num_subsets=len(customlist) sampler=Sampler(num_subsets, sampling_type='custom_order', order=customlist) @@ -158,7 +171,27 @@ def customOrder( customlist): @staticmethod def hermanMeyer(num_subsets): + """ + Function that takes a number of subsets and returns a sampler which outputs a Herman Meyer order + + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + Reference + ---------- + Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. + Example + ------- + >>> sampler=Sampler.hermanMeyer(12) + >>> sampler.show_epochs(5) + + Epoch 0: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + Epoch 1: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + Epoch 2: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + Epoch 3: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + Epoch 4: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + """ def _herman_meyer_order(n): # Assuming that the subsets are in geometrical order n_variable = n @@ -198,11 +231,32 @@ def _herman_meyer_order(n): @staticmethod def staggered(num_subsets, offset): + + """ + Function that takes a number of subsets and returns a sampler which outputs in a staggered order. + + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + offset: int + The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. + + + Example + ------- + >>> sampler=Sampler.staggered(20,4) + >>> sampler.show_epochs(5) + + Epoch 0: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + Epoch 1: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + Epoch 2: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + Epoch 3: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + Epoch 4: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + """ + indices=list(range(num_subsets)) order=[] - [order.extend(indices[i::offset]) for i in range(offset)] - # order=[indices[i::offset] for i in range(offset)] - print(order) + [order.extend(indices[i::offset]) for i in range(offset)] sampler=Sampler(num_subsets, sampling_type='staggered', order=order) return sampler @@ -210,6 +264,40 @@ def staggered(num_subsets, offset): @staticmethod def randomWithReplacement(num_subsets, prob=None, seed=None): + """ + Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets with given probability and with replacement. + + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + prob: list of floats of length num_subsets that sum to 1. default=None + This is the probability for each integer to be called by next. If None, then the integers will be sampled uniformly. + + seed:int, default=None + Random seed for the random number generator. If set to None, the seed will be set using the current time. + + + Example + ------- + + + >>> sampler=Sampler.randomWithReplacement(5) + >>> print(sampler.get_epochs()) + [[3, 2, 2, 4, 4], [0, 1, 2, 4, 4]] + + Example + ------- + + >>> sampler=Sampler.randomWithReplacement(4, [0.7,0.1,0.1,0.1]) + >>> sampler.show_epochs(5) + + Epoch 0: [1, 0, 0, 0] + Epoch 1: [0, 0, 0, 0] + Epoch 2: [0, 0, 2, 2] + Epoch 3: [0, 0, 3, 0] + Epoch 4: [3, 2, 0, 0] + """ + if prob==None: prob = [1/num_subsets] *num_subsets else: @@ -223,12 +311,58 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): @staticmethod def randomWithoutReplacement(num_subsets, seed=None): + + """ + Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets uniformly randomly without replacement. + Each epoch is a different perturbation and in each epoch each integer is outputted exactly once. + + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + seed:int, default=None + Random seed for the random number generator. If set to None, the seed will be set using the current time. + + + Example + ------- + >>> sampler=Sampler.randomWithoutReplacement(11) + >>> sampler.show_epochs(5) + Epoch 0: [10, 4, 3, 0, 2, 9, 6, 8, 7, 5, 1] + Epoch 1: [6, 0, 2, 4, 5, 7, 3, 10, 9, 8, 1] + Epoch 2: [1, 2, 7, 4, 9, 5, 6, 3, 0, 8, 10] + Epoch 3: [3, 10, 2, 9, 5, 6, 1, 7, 0, 8, 4] + Epoch 4: [6, 10, 1, 4, 0, 3, 9, 8, 2, 5, 7] + """ + order=list(range(num_subsets)) sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) return sampler def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): + """ + This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. + + Parameters + ---------- + num_subsets: int + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + + sampling_type:str + The sampling type used. + + order: list of integers + The list of integers the method selects from using next. + + shuffle= bool, default=False + If True, after each epoch (num_subsets calls of next), the sampling order is shuffled randomly. + + prob: list of floats of length num_subsets that sum to 1. + For random sampling with replacement, this is the probability for each integer to be called by next. + + seed:int, default=None + Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. + """ self.type=sampling_type self.num_subsets=num_subsets if seed !=None: @@ -250,6 +384,14 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N def _next_order(self): + """ + The user should call sampler.next() or next(sampler) rather than use this function. + + A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + + This function us used by samplers that output a permutation of an list in each epoch. + + """ # print(self.last_subset) if self.shuffle==True and self.last_subset==self.num_subsets-1: self.order=self.generator.permutation(self.order) @@ -258,13 +400,26 @@ def _next_order(self): return(self.order[self.last_subset]) def _next_prob(self): + """ + The user should call sampler.next() or next(sampler) rather than use this function. + + A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + + This function us used by samplers that select from a list of integers {0, 1, …, S-1}, with S=num_subsets, randomly with replacement. + + """ return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) def next(self): + """ A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. """ + return (self.iterator()) def __next__(self): - """ Allows the user to call next(sampler), to get the same result as sampler.next()""" + """ + A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + + Allows the user to call next(sampler), to get the same result as sampler.next()""" return(self.next()) def show_epochs(self, num_epochs=2): From ba35fb85ec6ae26467db08b76c170c0e9d2787ac Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 15 Aug 2023 09:55:10 +0000 Subject: [PATCH 013/115] Debugging sampler --- Wrappers/Python/cil/framework/sampler.py | 4 +-- .../cil/optimisation/algorithms/SPDHG.py | 25 ++++++++----------- 2 files changed, 12 insertions(+), 17 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 0c2dda2ad2..a2b60cfeba 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -304,8 +304,8 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): prob=prob if len(prob)!=num_subsets: raise ValueError("Length of the list of probabilities should equal the number of subsets") - if sum(prob)!=1.: - raise ValueError("Probabilites should sum to 1.") + if sum(prob)-1.>=1e-5: + raise ValueError("Probabilities should sum to 1. Your probabilities sum to {}".format(sum(prob))) sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) return sampler diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 058002f139..312bd1f82c 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -50,7 +50,7 @@ class SPDHG(Algorithm): List of probabilities. If None each subset will have probability = 1/number of subsets gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: instnace of the Sampler class + sampler: instance of the Sampler class Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets **kwargs: norms : list of floats @@ -77,11 +77,7 @@ class SPDHG(Algorithm): Notation for primal and dual step-sizes are reversed with comparison to PDHG.py - Note - ---- - - this code implements serial sampling only, as presented in [2] - (to be extended to more general case of [1] as future work) + References ---------- @@ -126,11 +122,11 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets + gamma : float parameter controlling the trade-off between the primal and dual step sizes - + sampler: instance of the Sampler class + Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. **kwargs: norms : list of floats precalculated list of norms of the operators @@ -154,13 +150,12 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ self.prob = [1/self.ndual_subsets] * self.ndual_subsets self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) else: - if self.prob==None: - if self.sampler.prob!=None: - self.prob=self.sampler.prob - else: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets + if self.sampler.prob!=None: + self.prob=self.sampler.prob else: - warnings.warn('You supplied both probabilites and a sampler. The sampler will be used for sampling and the probabilites for calculationg step sizes, if not explicitly set.') + self.prob = [1/self.ndual_subsets] * self.ndual_subsets + if self.prob!=None: + warnings.warn('You supplied both probabilities and a sampler. The given probabilities will be ignored.') From beac6faa9b543ef9693192226603d51acfdb99bc Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 17 Aug 2023 12:22:45 +0000 Subject: [PATCH 014/115] Changes after dev meeting --- Wrappers/Python/cil/framework/sampler.py | 123 +++++++++++------------ 1 file changed, 60 insertions(+), 63 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index a2b60cfeba..5fd9f956d3 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -55,8 +55,8 @@ class Sampler(): ------- >>> sampler=Sampler.sequential(10) - >>> sampler.show_epochs(5) - >>> for _ in range(11): + >>> sampler.show_samples(5) + >>> for _ in range(55): print(sampler.next()) Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] @@ -82,25 +82,22 @@ class Sampler(): >>> sampler=Sampler.randomWithReplacement(11) >>> for _ in range(12): >>> print(next(sampler)) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(54) - 10 - 5 - 10 - 1 - 6 - 7 - 10 - 0 0 2 - 5 3 - Epoch 0: [10, 5, 10, 1, 6, 7, 10, 0, 0, 2, 5] - Epoch 1: [3, 10, 7, 7, 8, 7, 4, 7, 8, 4, 9] - Epoch 2: [0, 0, 0, 1, 3, 8, 6, 5, 7, 7, 0] - Epoch 3: [8, 8, 6, 4, 0, 2, 7, 2, 8, 3, 8] - Epoch 4: [10, 9, 3, 6, 6, 9, 5, 2, 8, 4, 0] + 3 + 2 + 0 + 3 + 3 + 1 + 2 + 1 + 1 + The first 54 samples: [0, 2, 3, 3, 2, 0, 3, 3, 1, 2, 1, 1, 2, 3, 3, 1, 3, 2, 4, 0, 0, 0, 1, 1, 3, 0, 4, 3, 3, 3, 0, 0, 0, 2, 4, 0, 1, 2, 3, 4, 0, 4, 4, 1, 4, 1, 4, 3, 0, 2, 3, 0, 1, 4] + @@ -118,7 +115,7 @@ def sequential(num_subsets): ------- >>> sampler=Sampler.sequential(10) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(49) >>> for _ in range(11): print(sampler.next()) @@ -126,7 +123,7 @@ def sequential(num_subsets): Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8] 0 1 2 @@ -156,13 +153,10 @@ def customOrder( customlist): -------- >>> sampler=Sampler.customOrder([1,4,6,7,8,9,11]) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(11) Epoch 0: [1, 4, 6, 7, 8, 9, 11] - Epoch 1: [1, 4, 6, 7, 8, 9, 11] - Epoch 2: [1, 4, 6, 7, 8, 9, 11] - Epoch 3: [1, 4, 6, 7, 8, 9, 11] - Epoch 4: [1, 4, 6, 7, 8, 9, 11] + Epoch 1: [1, 4, 6, 7] """ num_subsets=len(customlist) @@ -175,7 +169,7 @@ def hermanMeyer(num_subsets): Function that takes a number of subsets and returns a sampler which outputs a Herman Meyer order num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. For Herman-Meyer sampling this number should not be prime. Reference ---------- @@ -184,7 +178,7 @@ def hermanMeyer(num_subsets): Example ------- >>> sampler=Sampler.hermanMeyer(12) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(60) Epoch 0: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] Epoch 1: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] @@ -206,6 +200,8 @@ def _herman_meyer_order(n): if n_variable > 1: factors.append(n_variable) n_factors = len(factors) + if n_factors==0: + raise ValueError('Herman Meyer sampling defaults to sequential ordering if the number of subsets is prime. Please use an alternative sampling method or change the number of subsets. ') order = [0 for _ in range(n)] value = 0 for factor_n in range(n_factors): @@ -240,12 +236,12 @@ def staggered(num_subsets, offset): offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. - + The offset should be less than the num_subsets Example ------- >>> sampler=Sampler.staggered(20,4) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(100) Epoch 0: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] Epoch 1: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] @@ -253,7 +249,8 @@ def staggered(num_subsets, offset): Epoch 3: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] Epoch 4: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] """ - + if offset>=num_subsets: + raise(ValueError('The offset should be less than the number of subsets')) indices=list(range(num_subsets)) order=[] [order.extend(indices[i::offset]) for i in range(offset)] @@ -282,35 +279,26 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): >>> sampler=Sampler.randomWithReplacement(5) - >>> print(sampler.get_epochs()) - [[3, 2, 2, 4, 4], [0, 1, 2, 4, 4]] + >>> print(sampler.get_samples(10)) + + The first 10 samples: [2, 1, 2, 3, 2, 1, 2, 2, 1, 2] Example ------- >>> sampler=Sampler.randomWithReplacement(4, [0.7,0.1,0.1,0.1]) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(21) - Epoch 0: [1, 0, 0, 0] - Epoch 1: [0, 0, 0, 0] - Epoch 2: [0, 0, 2, 2] - Epoch 3: [0, 0, 3, 0] - Epoch 4: [3, 2, 0, 0] + The first 21 samples: [3, 2, 0, 2, 0, 0, 0, 0, 0, 3, 0, 1, 0, 0, 2, 0, 0, 0, 1, 2, 0] """ if prob==None: prob = [1/num_subsets] *num_subsets - else: - prob=prob - if len(prob)!=num_subsets: - raise ValueError("Length of the list of probabilities should equal the number of subsets") - if sum(prob)-1.>=1e-5: - raise ValueError("Probabilities should sum to 1. Your probabilities sum to {}".format(sum(prob))) sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) return sampler @staticmethod - def randomWithoutReplacement(num_subsets, seed=None): + def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): """ Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets uniformly randomly without replacement. @@ -322,11 +310,12 @@ def randomWithoutReplacement(num_subsets, seed=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + shuffle:boolean, default=True + If True, there is a random shuffle between each epoch, if false the same random order as the first epoch is repeated for all future epochs. Example ------- >>> sampler=Sampler.randomWithoutReplacement(11) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(55) Epoch 0: [10, 4, 3, 0, 2, 9, 6, 8, 7, 5, 1] Epoch 1: [6, 0, 2, 4, 5, 7, 3, 10, 9, 8, 1] Epoch 2: [1, 2, 7, 4, 9, 5, 6, 3, 0, 8, 10] @@ -335,7 +324,7 @@ def randomWithoutReplacement(num_subsets, seed=None): """ order=list(range(num_subsets)) - sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=True, seed=seed) + sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=shuffle, seed=seed) return sampler @@ -422,23 +411,23 @@ def __next__(self): Allows the user to call next(sampler), to get the same result as sampler.next()""" return(self.next()) - def show_epochs(self, num_epochs=2): + def show_samples(self, num_samples=20): """ - Function that takes an integer, num_epochs, and prints the first num_epochs epochs. Calling this function will not interrupt the random number generation, if applicable. + Function that takes an integer, num_samples, and prints the first num_samples, organised into epochs where appropriate. Calling this function will not interrupt the random number generation, if applicable. - num_epochs: int, default=2 - The number of epochs to print. + num_samples: int, default=20 + The number of samples to print. Example ------- >>> sampler=Sampler.randomWithoutReplacement(11) - >>> sampler.show_epochs(5) + >>> sampler.show_samples(50) Epoch 0: [9, 7, 2, 8, 0, 10, 1, 5, 3, 6, 4] Epoch 1: [6, 2, 0, 10, 5, 1, 9, 8, 7, 4, 3] Epoch 2: [5, 10, 0, 6, 1, 4, 3, 7, 2, 8, 9] Epoch 3: [4, 8, 3, 7, 1, 10, 5, 6, 2, 9, 0] - Epoch 4: [0, 7, 2, 6, 9, 10, 8, 3, 1, 4, 5] + Epoch 4: [0, 7, 2, 6, 9, 10] """ save_generator=self.generator @@ -447,25 +436,29 @@ def show_epochs(self, num_epochs=2): save_order=self.order self.order=self.initial_order self.generator=np.random.RandomState(self.seed) - for i in range(num_epochs): - print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) + if self.prob==None: + for i in range(num_samples//self.num_subsets): + print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) + print('Epoch {}: '.format(num_samples//self.num_subsets), [self.next() for _ in range(num_samples%self.num_subsets)]) + else: + print('The first {} samples: '.format(num_samples), [self.next() for _ in range(num_samples)]) self.generator=save_generator self.order=save_order self.last_subset=save_last_subset - def get_epochs(self, num_epochs=2): + def get_samples(self, num_samples=20): """ - Function that takes an integer, num_epochs, and returns the first num_epochs epochs in the form of a list of lists. Calling this function will not interrupt the random number generation, if applicable. + Function that takes an integer, num_samples, and returns the first num_samples, organised into epochs where appropriate, as a list of lists. Calling this function will not interrupt the random number generation, if applicable. - num_epochs: int, default=2 - The number of epochs to return. + num_samples: int, default=20 + The number of samples to return. Example ------- >>> sampler=Sampler.randomWithReplacement(5) - >>> print(sampler.get_epochs()) - [[3, 2, 2, 4, 4], [0, 1, 2, 4, 4]] + >>> print(sampler.get_samples()) + [[2, 4, 2, 4, 1, 3, 2, 2, 1, 2, 4, 4, 2, 3, 2, 1, 0, 4, 2, 3]] """ save_generator=self.generator @@ -475,8 +468,12 @@ def get_epochs(self, num_epochs=2): self.order=self.initial_order self.generator=np.random.RandomState(self.seed) output=[] - for i in range(num_epochs): - output.append( [self.next() for _ in range(self.num_subsets)]) + if self.prob==None: + for i in range(num_samples//self.num_subsets): + output.append( [self.next() for _ in range(self.num_subsets)]) + output.append([self.next() for _ in range(num_samples%self.num_subsets)]) + else: + output.append( [self.next() for _ in range(num_samples)]) self.generator=save_generator self.order=save_order self.last_subset=save_last_subset From 1202e53d8c77fd86c5d0fd90a9247371b49eb3cf Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 18 Aug 2023 12:16:02 +0000 Subject: [PATCH 015/115] Checking probabilities in init --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 312bd1f82c..35aab1872f 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -150,12 +150,13 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ self.prob = [1/self.ndual_subsets] * self.ndual_subsets self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) else: + if self.prob!=None: + warnings.warn('You supplied both probabilities and a sampler. The given probabilities will be ignored.') if self.sampler.prob!=None: self.prob=self.sampler.prob else: self.prob = [1/self.ndual_subsets] * self.ndual_subsets - if self.prob!=None: - warnings.warn('You supplied both probabilities and a sampler. The given probabilities will be ignored.') + From 079935b97b4eb936fbc4d670856adf1758b76441 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 23 Aug 2023 10:33:28 +0000 Subject: [PATCH 016/115] initial testing --- Wrappers/Python/test/test_algorithms.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index a7622b7f62..726bd5726a 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -755,7 +755,8 @@ class TestSPDHG(unittest.TestCase): @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + t1=time.time() + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(32,32)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -798,13 +799,13 @@ def test_SPDHG_vs_PDHG_implicit(self): sigma_tmp = 1. tau = sigma_tmp / operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) sigma = tau_tmp / operator.direct(sigma_tmp * operator.domain_geometry().allocate(1.)) - + t2=time.time() # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, max_iteration = 1000, update_objective_interval = 500) pdhg.run(verbose=0) - + t3=time.time() subsets = 10 size_of_subsets = int(len(angles)/subsets) # take angles and create uniform subsets in uniform+sequential setting @@ -831,10 +832,12 @@ def test_SPDHG_vs_PDHG_implicit(self): G = alpha * TotalVariation(50, 1e-4, lower=0) prob = [1/len(A)]*len(A) + t4=time.time() spdhg = SPDHG(f=F,g=G,operator=A, max_iteration = 1000, update_objective_interval=200, prob = prob) spdhg.run(1000, verbose=0) + t5=time.time() qm = (mae(spdhg.get_output(), pdhg.get_output()), mse(spdhg.get_output(), pdhg.get_output()), psnr(spdhg.get_output(), pdhg.get_output()) From 43e3dc40f8fca9484abc7f4510282674f8c3c6cc Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 24 Aug 2023 12:06:01 +0000 Subject: [PATCH 017/115] Sped up PDHG and SPDHG testing --- Wrappers/Python/test/test_algorithms.py | 65 ++++++++++++++----------- 1 file changed, 37 insertions(+), 28 deletions(-) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 726bd5726a..7fa1fe0ff1 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -756,7 +756,7 @@ class TestSPDHG(unittest.TestCase): @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): t1=time.time() - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(32,32)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -802,11 +802,11 @@ def test_SPDHG_vs_PDHG_implicit(self): t2=time.time() # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval = 500) + max_iteration = 70, + update_objective_interval = 1000) pdhg.run(verbose=0) t3=time.time() - subsets = 10 + subsets = 5 size_of_subsets = int(len(angles)/subsets) # take angles and create uniform subsets in uniform+sequential setting list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] @@ -834,8 +834,8 @@ def test_SPDHG_vs_PDHG_implicit(self): prob = [1/len(A)]*len(A) t4=time.time() spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob) + max_iteration = 320, + update_objective_interval=1000, prob = prob) spdhg.run(1000, verbose=0) t5=time.time() qm = (mae(spdhg.get_output(), pdhg.get_output()), @@ -852,7 +852,7 @@ def test_SPDHG_vs_PDHG_implicit(self): @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_PDHG_explicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -883,7 +883,7 @@ def test_SPDHG_vs_PDHG_explicit(self): raise ValueError('Unsupported Noise ', noise) #%% 'explicit' SPDHG, scalar step-sizes - subsets = 10 + subsets = 5 size_of_subsets = int(len(angles)/subsets) # create Gradient operator op1 = GradientOperator(ig) @@ -912,9 +912,11 @@ def test_SPDHG_vs_PDHG_explicit(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob) + max_iteration = 220, + update_objective_interval=1000, prob = prob) + t1=time.time() spdhg.run(1000, verbose=0) + t2=time.time() #%% 'explicit' PDHG, scalar step-sizes op1 = GradientOperator(ig) @@ -931,10 +933,11 @@ def test_SPDHG_vs_PDHG_explicit(self): f = BlockFunction(f1, f2) # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma) - pdhg.max_iteration = 1000 - pdhg.update_objective_interval = 200 + pdhg.max_iteration = 180 + pdhg.update_objective_interval = 1000 + t3=time.time() pdhg.run(1000, verbose=0) - + t4=time.time() #%% show diff between PDHG and SPDHG # plt.imshow(spdhg.get_output().as_array() -pdhg.get_output().as_array()) # plt.colorbar() @@ -953,7 +956,7 @@ def test_SPDHG_vs_PDHG_explicit(self): @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_SPDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128), dtype=numpy.float32) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16), dtype=numpy.float32) ig = data.geometry ig.voxel_size_x = 0.1 @@ -989,7 +992,7 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): raise ValueError('Unsupported Noise ', noise) #%% 'explicit' SPDHG, scalar step-sizes - subsets = 10 + subsets = 5 size_of_subsets = int(len(angles)/subsets) # create GradientOperator operator op1 = GradientOperator(ig) @@ -1021,16 +1024,19 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob.copy(), use_axpby=True) + max_iteration = 330, + update_objective_interval=1000, prob = prob.copy(), use_axpby=True) ) + t1=time.time() algos[0].run(1000, verbose=0) - + t2=time.time() algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob.copy(), use_axpby=False) + max_iteration = 330, + update_objective_interval=1000, prob = prob.copy(), use_axpby=False) ) + t3=time.time() algos[1].run(1000, verbose=0) + t4=time.time() # np.testing.assert_array_almost_equal(algos[0].get_output().as_array(), algos[1].get_output().as_array()) @@ -1040,12 +1046,12 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): ) logging.info ("Quality measures {}".format(qm)) assert qm[0] < 0.005 - assert qm[1] < 3.e-05 + assert qm[1] < 5.e-05 @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_PDHG_vs_PDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 @@ -1094,18 +1100,21 @@ def test_PDHG_vs_PDHG_explicit_axpby(self): # Setup and run the PDHG algorithm algos = [] + algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval=200, use_axpby=True) + max_iteration = 300, + update_objective_interval=1000, use_axpby=True) ) + t1=time.time() algos[0].run(1000, verbose=0) - + t2=time.time() algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval=200, use_axpby=False) + max_iteration = 300, + update_objective_interval=1000, use_axpby=False) ) + t3=time.time() algos[1].run(1000, verbose=0) - + t4=time.time() qm = (mae(algos[0].get_output(), algos[1].get_output()), mse(algos[0].get_output(), algos[1].get_output()), psnr(algos[0].get_output(), algos[1].get_output()) From 004ab2f5ad321bb49847416e8d660ccba2b168e2 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 24 Aug 2023 12:29:37 +0000 Subject: [PATCH 018/115] Removed timing statements --- Wrappers/Python/test/test_algorithms.py | 42 ++++++++++++------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 7fa1fe0ff1..8f95799c00 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -755,7 +755,7 @@ class TestSPDHG(unittest.TestCase): @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): - t1=time.time() + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) ig = data.geometry @@ -799,13 +799,13 @@ def test_SPDHG_vs_PDHG_implicit(self): sigma_tmp = 1. tau = sigma_tmp / operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) sigma = tau_tmp / operator.direct(sigma_tmp * operator.domain_geometry().allocate(1.)) - t2=time.time() + # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, max_iteration = 70, update_objective_interval = 1000) pdhg.run(verbose=0) - t3=time.time() + subsets = 5 size_of_subsets = int(len(angles)/subsets) # take angles and create uniform subsets in uniform+sequential setting @@ -832,12 +832,12 @@ def test_SPDHG_vs_PDHG_implicit(self): G = alpha * TotalVariation(50, 1e-4, lower=0) prob = [1/len(A)]*len(A) - t4=time.time() + spdhg = SPDHG(f=F,g=G,operator=A, max_iteration = 320, update_objective_interval=1000, prob = prob) spdhg.run(1000, verbose=0) - t5=time.time() + qm = (mae(spdhg.get_output(), pdhg.get_output()), mse(spdhg.get_output(), pdhg.get_output()), psnr(spdhg.get_output(), pdhg.get_output()) @@ -913,10 +913,10 @@ def test_SPDHG_vs_PDHG_explicit(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] spdhg = SPDHG(f=F,g=G,operator=A, max_iteration = 220, - update_objective_interval=1000, prob = prob) - t1=time.time() + update_objective_interval=220, prob = prob) + spdhg.run(1000, verbose=0) - t2=time.time() + #%% 'explicit' PDHG, scalar step-sizes op1 = GradientOperator(ig) @@ -934,10 +934,10 @@ def test_SPDHG_vs_PDHG_explicit(self): # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma) pdhg.max_iteration = 180 - pdhg.update_objective_interval = 1000 - t3=time.time() + pdhg.update_objective_interval =180 + pdhg.run(1000, verbose=0) - t4=time.time() + #%% show diff between PDHG and SPDHG # plt.imshow(spdhg.get_output().as_array() -pdhg.get_output().as_array()) # plt.colorbar() @@ -1025,18 +1025,18 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): algos = [] algos.append( SPDHG(f=F,g=G,operator=A, max_iteration = 330, - update_objective_interval=1000, prob = prob.copy(), use_axpby=True) + update_objective_interval=330, prob = prob.copy(), use_axpby=True) ) - t1=time.time() + algos[0].run(1000, verbose=0) - t2=time.time() + algos.append( SPDHG(f=F,g=G,operator=A, max_iteration = 330, - update_objective_interval=1000, prob = prob.copy(), use_axpby=False) + update_objective_interval=330, prob = prob.copy(), use_axpby=False) ) - t3=time.time() + algos[1].run(1000, verbose=0) - t4=time.time() + # np.testing.assert_array_almost_equal(algos[0].get_output().as_array(), algos[1].get_output().as_array()) @@ -1105,16 +1105,16 @@ def test_PDHG_vs_PDHG_explicit_axpby(self): max_iteration = 300, update_objective_interval=1000, use_axpby=True) ) - t1=time.time() + algos[0].run(1000, verbose=0) - t2=time.time() + algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, max_iteration = 300, update_objective_interval=1000, use_axpby=False) ) - t3=time.time() + algos[1].run(1000, verbose=0) - t4=time.time() + qm = (mae(algos[0].get_output(), algos[1].get_output()), mse(algos[0].get_output(), algos[1].get_output()), psnr(algos[0].get_output(), algos[1].get_output()) From 7b857e0cf1f6753b45cfede2e7a755d2cf850f4d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 13 Sep 2023 16:27:24 +0000 Subject: [PATCH 019/115] Got rid of epochs - still need to fix the shuffle --- Wrappers/Python/cil/framework/sampler.py | 173 +++++++++-------------- docs/docs_environment.yml | 2 +- 2 files changed, 71 insertions(+), 104 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 5fd9f956d3..57e85894fb 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -24,11 +24,9 @@ class Sampler(): r""" A class to select from a list of integers {0, 1, …, S-1}, with each integer representing the index of a subset - The function next() outputs a single next index from the {0,1,…,S-1} subset list. Different orders possible incl with and without replacement. To be run again and again, depending on how many iterations/epochs the users asks for. + The function next() outputs a single next index from the {0,1,…,S-1} subset list. Different orders possible incl with and without replacement. To be run again and again, depending on how many iterations. + - Calls are organised into epochs: The single index outputs can be organised into length-S lists. Each length-S list is called an epoch. The user can in principle ask for an infinite number of epochs to be run. Denote by E the number of epochs. - Each epoch always has a list of length S. It may contain the same subset index s multiple times or not at all. - Parameters ---------- num_subsets: int @@ -41,7 +39,7 @@ class Sampler(): The list of integers the method selects from using next. shuffle= bool, default=False - If True, after each epoch (num_subsets calls of next), the sampling order is shuffled randomly. + If True, after each num_subsets calls of next the sampling order is shuffled randomly. prob: list of floats of length num_subsets that sum to 1. For random sampling with replacement, this is the probability for each integer to be called by next. @@ -55,15 +53,11 @@ class Sampler(): ------- >>> sampler=Sampler.sequential(10) - >>> sampler.show_samples(5) - >>> for _ in range(55): + >>> print(sampler.get_samples(5)) + >>> for _ in range(11): print(sampler.next()) - Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + [0 1 2 3 4] 0 1 2 @@ -75,29 +69,27 @@ class Sampler(): 8 9 0 - 1 Example ------- - >>> sampler=Sampler.randomWithReplacement(11) + >>> sampler=Sampler.randomWithReplacement(5) >>> for _ in range(12): >>> print(next(sampler)) - >>> sampler.show_samples(54) + >>> print(sampler.get_samples()) + 3 + 4 + 0 0 2 3 3 2 - 0 - 3 - 3 - 1 2 1 1 - The first 54 samples: [0, 2, 3, 3, 2, 0, 3, 3, 1, 2, 1, 1, 2, 3, 3, 1, 3, 2, 4, 0, 0, 0, 1, 1, 3, 0, 4, 3, 3, 3, 0, 0, 0, 2, 4, 0, 1, 2, 3, 4, 0, 4, 4, 1, 4, 1, 4, 3, 0, 2, 3, 0, 1, 4] - + 4 + [3 4 0 0 2 3 3 2 2 1 1 4 4 3 0 2 4 4 2 4] @@ -115,15 +107,11 @@ def sequential(num_subsets): ------- >>> sampler=Sampler.sequential(10) - >>> sampler.show_samples(49) + >>> print(sampler.get_samples(5)) >>> for _ in range(11): print(sampler.next()) - Epoch 0: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 3: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] - Epoch 4: [0, 1, 2, 3, 4, 5, 6, 7, 8] + [0 1 2 3 4] 0 1 2 @@ -135,7 +123,6 @@ def sequential(num_subsets): 8 9 0 - 1 """ order=list(range(num_subsets)) sampler=Sampler(num_subsets, sampling_type='sequential', order=order) @@ -153,10 +140,22 @@ def customOrder( customlist): -------- >>> sampler=Sampler.customOrder([1,4,6,7,8,9,11]) - >>> sampler.show_samples(11) + >>> print(sampler.get_samples(11)) + >>> for _ in range(9): + >>> print(sampler.next()) + >>> print(sampler.get_samples(5)) - Epoch 0: [1, 4, 6, 7, 8, 9, 11] - Epoch 1: [1, 4, 6, 7] + [ 1 4 6 7 8 9 11 1 4 6 7] + 1 + 4 + 6 + 7 + 8 + 9 + 11 + 1 + 4 + [1 4 6 7 8] """ num_subsets=len(customlist) @@ -178,13 +177,10 @@ def hermanMeyer(num_subsets): Example ------- >>> sampler=Sampler.hermanMeyer(12) - >>> sampler.show_samples(60) + >>> print(sampler.get_samples(16)) - Epoch 0: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] - Epoch 1: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] - Epoch 2: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] - Epoch 3: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] - Epoch 4: [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] + """ def _herman_meyer_order(n): # Assuming that the subsets are in geometrical order @@ -240,14 +236,29 @@ def staggered(num_subsets, offset): Example ------- - >>> sampler=Sampler.staggered(20,4) - >>> sampler.show_samples(100) + >>> sampler=Sampler.staggered(21,4) + >>> print(sampler.get_samples(5)) + >>> for _ in range(15): + >>> print(sampler.next()) + >>> print(sampler.get_samples(5)) - Epoch 0: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] - Epoch 1: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] - Epoch 2: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] - Epoch 3: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] - Epoch 4: [0, 4, 8, 12, 16, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + [ 0 4 8 12 16] + 0 + 4 + 8 + 12 + 16 + 20 + 1 + 5 + 9 + 13 + 17 + 2 + 6 + 10 + 14 + [ 0 4 8 12 16] """ if offset>=num_subsets: raise(ValueError('The offset should be less than the number of subsets')) @@ -281,15 +292,15 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): >>> sampler=Sampler.randomWithReplacement(5) >>> print(sampler.get_samples(10)) - The first 10 samples: [2, 1, 2, 3, 2, 1, 2, 2, 1, 2] + [3 4 0 0 2 3 3 2 2 1] Example ------- >>> sampler=Sampler.randomWithReplacement(4, [0.7,0.1,0.1,0.1]) - >>> sampler.show_samples(21) + >>> print(sampler.get_samples(10)) - The first 21 samples: [3, 2, 0, 2, 0, 0, 0, 0, 0, 3, 0, 1, 0, 0, 2, 0, 0, 0, 1, 2, 0] + [0 1 3 0 0 3 0 0 0 0] """ if prob==None: @@ -302,7 +313,7 @@ def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): """ Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets uniformly randomly without replacement. - Each epoch is a different perturbation and in each epoch each integer is outputted exactly once. + num_subsets: int The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. @@ -311,18 +322,14 @@ def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): Random seed for the random number generator. If set to None, the seed will be set using the current time. shuffle:boolean, default=True - If True, there is a random shuffle between each epoch, if false the same random order as the first epoch is repeated for all future epochs. + If True, there is a random shuffle after all the integers have been seen once, if false the same random order each time the data is sampled is used. Example ------- >>> sampler=Sampler.randomWithoutReplacement(11) - >>> sampler.show_samples(55) - Epoch 0: [10, 4, 3, 0, 2, 9, 6, 8, 7, 5, 1] - Epoch 1: [6, 0, 2, 4, 5, 7, 3, 10, 9, 8, 1] - Epoch 2: [1, 2, 7, 4, 9, 5, 6, 3, 0, 8, 10] - Epoch 3: [3, 10, 2, 9, 5, 6, 1, 7, 0, 8, 4] - Epoch 4: [6, 10, 1, 4, 0, 3, 9, 8, 2, 5, 7] + >>> print(sampler.get_samples(12)) + [ 1 7 6 3 2 8 9 5 4 10 0 4] """ - + order=list(range(num_subsets)) sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=shuffle, seed=seed) return sampler @@ -344,7 +351,7 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N The list of integers the method selects from using next. shuffle= bool, default=False - If True, after each epoch (num_subsets calls of next), the sampling order is shuffled randomly. + If True, after each num_subsets calls of next, the sampling order is shuffled randomly. prob: list of floats of length num_subsets that sum to 1. For random sampling with replacement, this is the probability for each integer to be called by next. @@ -378,7 +385,7 @@ def _next_order(self): A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. - This function us used by samplers that output a permutation of an list in each epoch. + This function is used by samplers that sample without replacement. """ # print(self.last_subset) @@ -411,44 +418,10 @@ def __next__(self): Allows the user to call next(sampler), to get the same result as sampler.next()""" return(self.next()) - def show_samples(self, num_samples=20): - """ - Function that takes an integer, num_samples, and prints the first num_samples, organised into epochs where appropriate. Calling this function will not interrupt the random number generation, if applicable. - - num_samples: int, default=20 - The number of samples to print. - - Example - ------- - - >>> sampler=Sampler.randomWithoutReplacement(11) - >>> sampler.show_samples(50) - Epoch 0: [9, 7, 2, 8, 0, 10, 1, 5, 3, 6, 4] - Epoch 1: [6, 2, 0, 10, 5, 1, 9, 8, 7, 4, 3] - Epoch 2: [5, 10, 0, 6, 1, 4, 3, 7, 2, 8, 9] - Epoch 3: [4, 8, 3, 7, 1, 10, 5, 6, 2, 9, 0] - Epoch 4: [0, 7, 2, 6, 9, 10] - - """ - save_generator=self.generator - save_last_subset=self.last_subset - self.last_subset=self.num_subsets-1 - save_order=self.order - self.order=self.initial_order - self.generator=np.random.RandomState(self.seed) - if self.prob==None: - for i in range(num_samples//self.num_subsets): - print('Epoch {}: '.format(i), [self.next() for _ in range(self.num_subsets)]) - print('Epoch {}: '.format(num_samples//self.num_subsets), [self.next() for _ in range(num_samples%self.num_subsets)]) - else: - print('The first {} samples: '.format(num_samples), [self.next() for _ in range(num_samples)]) - self.generator=save_generator - self.order=save_order - self.last_subset=save_last_subset - + def get_samples(self, num_samples=20): """ - Function that takes an integer, num_samples, and returns the first num_samples, organised into epochs where appropriate, as a list of lists. Calling this function will not interrupt the random number generation, if applicable. + Function that takes an integer, num_samples, and returns the first num_samples as a numpy array. num_samples: int, default=20 The number of samples to return. @@ -458,7 +431,7 @@ def get_samples(self, num_samples=20): >>> sampler=Sampler.randomWithReplacement(5) >>> print(sampler.get_samples()) - [[2, 4, 2, 4, 1, 3, 2, 2, 1, 2, 4, 4, 2, 3, 2, 1, 0, 4, 2, 3]] + [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ save_generator=self.generator @@ -467,15 +440,9 @@ def get_samples(self, num_samples=20): save_order=self.order self.order=self.initial_order self.generator=np.random.RandomState(self.seed) - output=[] - if self.prob==None: - for i in range(num_samples//self.num_subsets): - output.append( [self.next() for _ in range(self.num_subsets)]) - output.append([self.next() for _ in range(num_samples%self.num_subsets)]) - else: - output.append( [self.next() for _ in range(num_samples)]) + output=[self.next() for _ in range(num_samples)] self.generator=save_generator self.order=save_order self.last_subset=save_last_subset - return(output) + return(np.array(output)) diff --git a/docs/docs_environment.yml b/docs/docs_environment.yml index 07adaa7426..20621fcd22 100644 --- a/docs/docs_environment.yml +++ b/docs/docs_environment.yml @@ -17,7 +17,7 @@ # Authors: # CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt -name: docs +name: cil_testing channels: - conda-forge - intel From 1f7d54633d864043db9ac9252147f424f8c63899 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 14 Sep 2023 10:02:43 +0000 Subject: [PATCH 020/115] Fixed random without replacement shuffle=False --- Wrappers/Python/cil/framework/sampler.py | 193 ++++++++++++----------- 1 file changed, 97 insertions(+), 96 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 57e85894fb..3881bbdee8 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- -# This work is part of the Core Imaging Library (CIL) developed by CCPi -# (Collaborative Computational Project in Tomographic Imaging), with +# This work is part of the Core Imaging Library (CIL) developed by CCPi +# (Collaborative Computational Project in Tomographic Imaging), with # substantial contributions by UKRI-STFC and University of Manchester. # Licensed under the Apache License, Version 2.0 (the "License"); @@ -17,27 +17,28 @@ import numpy as np -import math -import time +import math +import time + class Sampler(): - + r""" A class to select from a list of integers {0, 1, …, S-1}, with each integer representing the index of a subset The function next() outputs a single next index from the {0,1,…,S-1} subset list. Different orders possible incl with and without replacement. To be run again and again, depending on how many iterations. - - + + Parameters ---------- num_subsets: int The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. - + sampling_type:str The sampling type used. order: list of integers The list of integers the method selects from using next. - + shuffle= bool, default=False If True, after each num_subsets calls of next the sampling order is shuffled randomly. @@ -46,7 +47,7 @@ class Sampler(): seed:int, default=None Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. - + Example @@ -76,7 +77,7 @@ class Sampler(): >>> for _ in range(12): >>> print(next(sampler)) >>> print(sampler.get_samples()) - + 3 4 0 @@ -94,7 +95,7 @@ class Sampler(): """ - + @staticmethod def sequential(num_subsets): """ @@ -124,12 +125,12 @@ def sequential(num_subsets): 9 0 """ - order=list(range(num_subsets)) - sampler=Sampler(num_subsets, sampling_type='sequential', order=order) - return sampler - + order = list(range(num_subsets)) + sampler = Sampler(num_subsets, sampling_type='sequential', order=order) + return sampler + @staticmethod - def customOrder( customlist): + def customOrder(customlist): """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. @@ -158,9 +159,10 @@ def customOrder( customlist): [1 4 6 7 8] """ - num_subsets=len(customlist) - sampler=Sampler(num_subsets, sampling_type='custom_order', order=customlist) - return sampler + num_subsets = len(customlist) + sampler = Sampler( + num_subsets, sampling_type='custom_order', order=customlist) + return sampler @staticmethod def hermanMeyer(num_subsets): @@ -173,12 +175,12 @@ def hermanMeyer(num_subsets): Reference ---------- Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. - + Example ------- >>> sampler=Sampler.hermanMeyer(12) >>> print(sampler.get_samples(16)) - + [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] """ @@ -196,9 +198,10 @@ def _herman_meyer_order(n): if n_variable > 1: factors.append(n_variable) n_factors = len(factors) - if n_factors==0: - raise ValueError('Herman Meyer sampling defaults to sequential ordering if the number of subsets is prime. Please use an alternative sampling method or change the number of subsets. ') - order = [0 for _ in range(n)] + if n_factors == 0: + raise ValueError( + 'Herman Meyer sampling defaults to sequential ordering if the number of subsets is prime. Please use an alternative sampling method or change the number of subsets. ') + order = [0 for _ in range(n)] value = 0 for factor_n in range(n_factors): n_rep_value = 0 @@ -214,16 +217,17 @@ def _herman_meyer_order(n): n_rep_value = 0 if value == factors[factor_n]: value = 0 - order[element] = order[element] + math.prod(factors[factor_n+1:]) * mapping + order[element] = order[element] + \ + math.prod(factors[factor_n+1:]) * mapping return order - order=_herman_meyer_order(num_subsets) - sampler=Sampler(num_subsets, sampling_type='herman_meyer', order=order) - return sampler + order = _herman_meyer_order(num_subsets) + sampler = Sampler( + num_subsets, sampling_type='herman_meyer', order=order) + return sampler @staticmethod def staggered(num_subsets, offset): - """ Function that takes a number of subsets and returns a sampler which outputs in a staggered order. @@ -233,7 +237,7 @@ def staggered(num_subsets, offset): offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. The offset should be less than the num_subsets - + Example ------- >>> sampler=Sampler.staggered(21,4) @@ -241,7 +245,7 @@ def staggered(num_subsets, offset): >>> for _ in range(15): >>> print(sampler.next()) >>> print(sampler.get_samples(5)) - + [ 0 4 8 12 16] 0 4 @@ -260,15 +264,13 @@ def staggered(num_subsets, offset): 14 [ 0 4 8 12 16] """ - if offset>=num_subsets: - raise(ValueError('The offset should be less than the number of subsets')) - indices=list(range(num_subsets)) - order=[] - [order.extend(indices[i::offset]) for i in range(offset)] - sampler=Sampler(num_subsets, sampling_type='staggered', order=order) - return sampler - - + if offset >= num_subsets: + raise (ValueError('The offset should be less than the number of subsets')) + indices = list(range(num_subsets)) + order = [] + [order.extend(indices[i::offset]) for i in range(offset)] + sampler = Sampler(num_subsets, sampling_type='staggered', order=order) + return sampler @staticmethod def randomWithReplacement(num_subsets, prob=None, seed=None): @@ -284,10 +286,10 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + Example ------- - + >>> sampler=Sampler.randomWithReplacement(5) >>> print(sampler.get_samples(10)) @@ -302,18 +304,18 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): [0 1 3 0 0 3 0 0 0 0] """ - - if prob==None: - prob = [1/num_subsets] *num_subsets - sampler=Sampler(num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) - return sampler - + + if prob == None: + prob = [1/num_subsets] * num_subsets + sampler = Sampler( + num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) + return sampler + @staticmethod def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): - """ Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets uniformly randomly without replacement. - + num_subsets: int The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. @@ -329,11 +331,11 @@ def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): >>> print(sampler.get_samples(12)) [ 1 7 6 3 2 8 9 5 4 10 0 4] """ - - order=list(range(num_subsets)) - sampler=Sampler(num_subsets, sampling_type='random_without_replacement', order=order, shuffle=shuffle, seed=seed) - return sampler + order = list(range(num_subsets)) + sampler = Sampler(num_subsets, sampling_type='random_without_replacement', + order=order, shuffle=shuffle, seed=seed) + return sampler def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): """ @@ -343,13 +345,13 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N ---------- num_subsets: int The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. - + sampling_type:str The sampling type used. order: list of integers The list of integers the method selects from using next. - + shuffle= bool, default=False If True, after each num_subsets calls of next, the sampling order is shuffled randomly. @@ -359,26 +361,27 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N seed:int, default=None Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. """ - self.type=sampling_type - self.num_subsets=num_subsets - if seed !=None: - self.seed=seed + self.type = sampling_type + self.num_subsets = num_subsets + if seed is not None: + self.seed = seed else: - self.seed=int(time.time()) - self.generator=np.random.RandomState(self.seed) - self.order=order - self.initial_order=order - if order!=None: - self.iterator=self._next_order - self.prob=prob - if prob!=None: - self.iterator=self._next_prob - self.shuffle=shuffle - self.last_subset=self.num_subsets-1 + self.seed = int(time.time()) + self.generator = np.random.RandomState(self.seed) + self.order = order + if order is not None: + self.iterator = self._next_order + self.shuffle = shuffle + if self.type == 'random_without_replacement' and self.shuffle == False: + self.order = self.generator.permutation(self.order) + print(self.order) + self.initial_order = self.order + self.prob = prob + if prob is not None: + self.iterator = self._next_prob + self.last_subset = self.num_subsets-1 - - def _next_order(self): """ The user should call sampler.next() or next(sampler) rather than use this function. @@ -386,15 +389,15 @@ def _next_order(self): A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. This function is used by samplers that sample without replacement. - + """ # print(self.last_subset) - if self.shuffle==True and self.last_subset==self.num_subsets-1: - self.order=self.generator.permutation(self.order) - #print(self.order) - self.last_subset= (self.last_subset+1)%self.num_subsets - return(self.order[self.last_subset]) - + if self.shuffle == True and self.last_subset == self.num_subsets-1: + self.order = self.generator.permutation(self.order) + # print(self.order) + self.last_subset = (self.last_subset+1) % self.num_subsets + return (self.order[self.last_subset]) + def _next_prob(self): """ The user should call sampler.next() or next(sampler) rather than use this function. @@ -402,7 +405,7 @@ def _next_prob(self): A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. This function us used by samplers that select from a list of integers {0, 1, …, S-1}, with S=num_subsets, randomly with replacement. - + """ return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) @@ -416,9 +419,8 @@ def __next__(self): A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. Allows the user to call next(sampler), to get the same result as sampler.next()""" - return(self.next()) + return (self.next()) - def get_samples(self, num_samples=20): """ Function that takes an integer, num_samples, and returns the first num_samples as a numpy array. @@ -434,15 +436,14 @@ def get_samples(self, num_samples=20): [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ - save_generator=self.generator - save_last_subset=self.last_subset - self.last_subset=self.num_subsets-1 - save_order=self.order - self.order=self.initial_order - self.generator=np.random.RandomState(self.seed) - output=[self.next() for _ in range(num_samples)] - self.generator=save_generator - self.order=save_order - self.last_subset=save_last_subset - return(np.array(output)) - + save_generator = self.generator + save_last_subset = self.last_subset + self.last_subset = self.num_subsets-1 + save_order = self.order + self.order = self.initial_order + self.generator = np.random.RandomState(self.seed) + output = [self.next() for _ in range(num_samples)] + self.generator = save_generator + self.order = save_order + self.last_subset = save_last_subset + return (np.array(output)) From 6993a959d5ad438d3f014a85b88f55dc22747d68 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 14 Sep 2023 15:27:42 +0000 Subject: [PATCH 021/115] Changes after meeting 12-09-2023. Remove epochs in sampler and deprecate prob in spdhg --- Wrappers/Python/cil/framework/sampler.py | 14 +- .../cil/optimisation/algorithms/SPDHG.py | 192 +++++++++++------- 2 files changed, 124 insertions(+), 82 deletions(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 3881bbdee8..3530ec3076 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -327,9 +327,15 @@ def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): If True, there is a random shuffle after all the integers have been seen once, if false the same random order each time the data is sampled is used. Example ------- - >>> sampler=Sampler.randomWithoutReplacement(11) - >>> print(sampler.get_samples(12)) - [ 1 7 6 3 2 8 9 5 4 10 0 4] + >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) + >>> print(sampler.get_samples(16)) + [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] + + Example + ------- + >>> sampler=Sampler.randomWithoutReplacement(7, seed=1, shuffle=False) + >>> print(sampler.get_samples(16)) + [6 2 1 0 4 3 5 6 2 1 0 4 3 5 6 2] """ order = list(range(num_subsets)) @@ -374,12 +380,10 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N self.shuffle = shuffle if self.type == 'random_without_replacement' and self.shuffle == False: self.order = self.generator.permutation(self.order) - print(self.order) self.initial_order = self.order self.prob = prob if prob is not None: self.iterator = self._next_prob - self.last_subset = self.num_subsets-1 def _next_order(self): diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 35aab1872f..f918597bf5 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -23,15 +23,17 @@ import warnings import logging from cil.framework import Sampler + + class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient Problem: - + .. math:: - + \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) - + Parameters ---------- f : BlockFunction @@ -64,49 +66,100 @@ class SPDHG(Algorithm): Note ---- - + Convergence is guaranteed provided that [2, eq. (12)]: - + .. math:: - + \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i - + Note ---- - + Notation for primal and dual step-sizes are reversed with comparison to PDHG.py - - + + References ---------- - + [1]"Stochastic primal-dual hybrid gradient algorithm with arbitrary sampling and imaging applications", Chambolle, Antonin, Matthias J. Ehrhardt, Peter Richtárik, and Carola-Bibiane Schonlieb, SIAM Journal on Optimization 28, no. 4 (2018): 2783-2808. - + [2]"Faster PET reconstruction with non-smooth priors by randomization and preconditioning", Matthias J Ehrhardt, Pawel Markiewicz and Carola-Bibiane Schönlieb, Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - + def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, prob=None, gamma=1.,sampler=None,**kwargs): + initial=None, gamma=1., sampler=None, **kwargs): super(SPDHG, self).__init__(**kwargs) - - + + self._prob_weights = kwargs.get('prob', None) + if self._prob_weights is not None: + warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)".\ + If you have passed both prob and a sampler then prob will be') if f is not None and operator is not None and g is not None: - self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - initial=initial, prob=prob, gamma=gamma,sampler=sampler, norms=kwargs.get('norms', None)) - + self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + initial=initial, gamma=gamma, sampler=sampler, norms=kwargs.get('norms', None)) + + @property + def norms(self): + return self._norms + + def set_norms(self, norms=None): + if norms is None: + # Compute norm of each sub-operator + norms = [self.operator.get_item(i, 0).norm() + for i in range(self.ndual_subsets)] + self._norms = norms + + @property + def sigma(self): + return self._sigma + + def set_sigma(self, sigma=None, norms=None): + self.set_norms(norms) + if sigma is None: + self._sigma = [self.gamma * self.rho / ni for ni in self._norms] + else: + self._sigma = sigma + + @property + def tau(self): + return self._tau - def set_up(self, f, g, operator, tau=None, sigma=None, \ - initial=None, prob=None, gamma=1.,sampler=None, norms=None): - + def set_tau(self, tau=None): + if tau is None: + self._tau = min([pi / (si * ni**2) for pi, ni, + si in zip(self._prob_weights, self._norms, self._sigma)]) + self._tau *= (self.rho / self.gamma) + else: + self._tau = tau + + def set_step_sizes(self): + ''' If you update either the norms or the prob_weights run this to reset the default sigma and tau step-sizes''' + self.set_sigma() + self.set_tau() + #TODO: Look at the PDHG one?? + + @property + def prob_weights(self): + return self._prob_weights + + def set_prob_weights(self, prob_weights=None): + if prob_weights is None: + self._prob_weights = [1/self.ndual_subsets] * self.ndual_subsets + else: + self._prob_weights = prob_weights + + def set_up(self, f, g, operator, tau=None, sigma=None, + initial=None, gamma=1., sampler=None, norms=None): '''set-up of the algorithm Parameters ---------- @@ -132,102 +185,85 @@ def set_up(self, f, g, operator, tau=None, sigma=None, \ precalculated list of norms of the operators ''' logging.info("{} setting up".format(self.__class__.__name__, )) - + # algorithmic parameters self.f = f self.g = g self.operator = operator - self.tau = tau - self.sigma = sigma - self.prob = prob - self.ndual_subsets = self.operator.shape[0] + self.sampler = sampler self.gamma = gamma + self.ndual_subsets = self.operator.shape[0] self.rho = .99 - self.sampler=sampler - if self.sampler==None: - if self.prob == None: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets - self.sampler=Sampler.randomWithReplacement(self.ndual_subsets, prob=self.prob) - else: - if self.prob!=None: - warnings.warn('You supplied both probabilities and a sampler. The given probabilities will be ignored.') - if self.sampler.prob!=None: - self.prob=self.sampler.prob - else: - self.prob = [1/self.ndual_subsets] * self.ndual_subsets - - - - - if self.sigma is None: - if norms is None: - # Compute norm of each sub-operator - norms = [operator.get_item(i,0).norm() for i in range(self.ndual_subsets)] - self.norms = norms - self.sigma = [self.gamma * self.rho / ni for ni in norms] - if self.tau is None: - self.tau = min( [ pi / ( si * ni**2 ) for pi, ni, si in zip(self.prob, norms, self.sigma)] ) - self.tau *= (self.rho / self.gamma) - - # initialize primal variable + # Remove this if statement once prob is deprecated + if self._prob_weights is None or sampler is not None: + self.set_prob_weights(sampler.prob) + if self.sampler is None: + self.sampler = Sampler.randomWithReplacement( + self.ndual_subsets, prob=self._prob_weights) + self.set_norms(norms) + self.set_sigma(sigma) + self.set_tau(tau) + + # initialize primal variable if initial is None: self.x = self.operator.domain_geometry().allocate(0) else: self.x = initial.copy() - + self.x_tmp = self.operator.domain_geometry().allocate(0) - + # initialize dual variable to 0 self.y_old = operator.range_geometry().allocate(0) - + # initialize variable z corresponding to back-projected dual variable self.z = operator.domain_geometry().allocate(0) - self.zbar= operator.domain_geometry().allocate(0) + self.zbar = operator.domain_geometry().allocate(0) # relaxation parameter self.theta = 1 self.configured = True logging.info("{} configured".format(self.__class__.__name__, )) - + def update(self): # Gradient descent for the primal variable # x_tmp = x - tau * zbar - self.x.sapyb(1., self.zbar, -self.tau, out=self.x_tmp) - - self.g.proximal(self.x_tmp, self.tau, out=self.x) - + self.x.sapyb(1., self.zbar, -self._tau, out=self.x_tmp) + + self.g.proximal(self.x_tmp, self._tau, out=self.x) + # Choose subset - i = int(self.sampler.next()) - + i = self.sampler.next() + # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x y_k = self.operator[i].direct(self.x) - y_k.sapyb(self.sigma[i], self.y_old[i], 1., out=y_k) - - y_k = self.f[i].proximal_conjugate(y_k, self.sigma[i]) - + y_k.sapyb(self._sigma[i], self.y_old[i], 1., out=y_k) + + y_k = self.f[i].proximal_conjugate(y_k, self._sigma[i]) + # Back-project # x_tmp = K[i]^*(y_k - y_old[i]) y_k.subtract(self.y_old[i], out=self.y_old[i]) - self.operator[i].adjoint(self.y_old[i], out = self.x_tmp) + self.operator[i].adjoint(self.y_old[i], out=self.x_tmp) # Update backprojected dual variable and extrapolate # zbar = z + (1 + theta/p[i]) x_tmp # z = z + x_tmp - self.z.add(self.x_tmp, out =self.z) + self.z.add(self.x_tmp, out=self.z) # zbar = z + (theta/p[i]) * x_tmp - self.z.sapyb(1., self.x_tmp, self.theta / self.prob[i], out = self.zbar) + self.z.sapyb(1., self.x_tmp, self.theta / + self._prob_weights[i], out=self.zbar) # save previous iteration self.save_previous_iteration(i, y_k) - + def update_objective(self): # p1 = self.f(self.operator.direct(self.x)) + self.g(self.x) p1 = 0. - for i,op in enumerate(self.operator.operators): + for i, op in enumerate(self.operator.operators): p1 += self.f[i](op.direct(self.x)) p1 += self.g(self.x) @@ -240,14 +276,16 @@ def update_objective(self): @property def objective(self): - '''alias of loss''' - return [x[0] for x in self.loss] + '''alias of loss''' + return [x[0] for x in self.loss] + @property def dual_objective(self): return [x[1] for x in self.loss] - + @property def primal_dual_gap(self): return [x[2] for x in self.loss] + def save_previous_iteration(self, index, y_current): self.y_old[index].fill(y_current) From bafc748b27a8813fddd8aa35cabf48faf4ce4803 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 19 Sep 2023 14:10:53 +0000 Subject: [PATCH 022/115] Sampler unit tests added --- Wrappers/Python/test/test_sampler.py | 194 +++++++++++++++++++++++++++ 1 file changed, 194 insertions(+) create mode 100644 Wrappers/Python/test/test_sampler.py diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py new file mode 100644 index 0000000000..cbabbc991a --- /dev/null +++ b/Wrappers/Python/test/test_sampler.py @@ -0,0 +1,194 @@ +# -*- coding: utf-8 -*- +# Copyright 2019 United Kingdom Research and Innovation +# Copyright 2019 The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: +# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt + +import unittest +from utils import initialise_tests +import os +import sys +from testclass import CCPiTestClass +import numpy as np +from cil.framework import Sampler +initialise_tests() + +sys.path.append(os.path.dirname(os.path.abspath(__file__))) + + +class TestSamplers(CCPiTestClass): + def test_init(self): + + sampler = Sampler.sequential(10) + self.assertEqual(sampler.num_subsets, 10) + self.assertEqual(sampler.type, 'sequential') + self.assertListEqual(sampler.order, list(range(10))) + self.assertListEqual(sampler.initial_order, list(range(10))) + self.assertEqual(sampler.shuffle, False) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 9) + + sampler = Sampler.randomWithoutReplacement(7, shuffle=True) + self.assertEqual(sampler.num_subsets, 7) + self.assertEqual(sampler.type, 'random_without_replacement') + self.assertListEqual(sampler.order, list(range(7))) + self.assertListEqual(sampler.initial_order, list(range(7))) + self.assertEqual(sampler.shuffle, True) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 6) + + sampler = Sampler.randomWithoutReplacement(8, shuffle=False, seed=1) + self.assertEqual(sampler.num_subsets, 8) + self.assertEqual(sampler.type, 'random_without_replacement') + self.assertEqual(sampler.shuffle, False) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 7) + self.assertEqual(sampler.seed, 1) + + sampler = Sampler.hermanMeyer(12) + self.assertEqual(sampler.num_subsets, 12) + self.assertEqual(sampler.type, 'herman_meyer') + self.assertEqual(sampler.shuffle, False) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 11) + self.assertListEqual( + sampler.order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) + self.assertListEqual(sampler.initial_order, [ + 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) + + sampler = Sampler.randomWithReplacement(5) + self.assertEqual(sampler.num_subsets, 5) + self.assertEqual(sampler.type, 'random_with_replacement') + self.assertEqual(sampler.order, None) + self.assertEqual(sampler.initial_order, None) + self.assertEqual(sampler.shuffle, False) + self.assertListEqual(sampler.prob, [1/5] * 5) + self.assertEqual(sampler.last_subset, 4) + + sampler = Sampler.randomWithReplacement(4, [0.7, 0.1, 0.1, 0.1]) + self.assertEqual(sampler.num_subsets, 4) + self.assertEqual(sampler.type, 'random_with_replacement') + self.assertEqual(sampler.order, None) + self.assertEqual(sampler.initial_order, None) + self.assertEqual(sampler.shuffle, False) + self.assertListEqual(sampler.prob, [0.7, 0.1, 0.1, 0.1]) + self.assertEqual(sampler.last_subset, 3) + + sampler = Sampler.staggered(21, 4) + self.assertEqual(sampler.num_subsets, 21) + self.assertEqual(sampler.type, 'staggered') + self.assertListEqual(sampler.order, [ + 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) + self.assertListEqual(sampler.initial_order, [ + 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) + self.assertEqual(sampler.shuffle, False) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 20) + + try: + Sampler.staggered(22, 25) + except ValueError: + self.assertTrue(True) + + sampler = Sampler.customOrder([1, 4, 6, 7, 8, 9, 11]) + self.assertEqual(sampler.num_subsets, 7) + self.assertEqual(sampler.type, 'custom_order') + self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) + self.assertListEqual(sampler.initial_order, [1, 4, 6, 7, 8, 9, 11]) + self.assertEqual(sampler.shuffle, False) + self.assertEqual(sampler.prob, None) + self.assertEqual(sampler.last_subset, 6) + + + + def test_sequential_iterator_and_get_samples(self): + + #Test the squential sampler + sampler = Sampler.sequential(10) + for i in range(25): + self.assertEqual(next(sampler), i % 10) + if i%5==0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(), np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) + + sampler = Sampler.sequential(10) + for i in range(25): + self.assertEqual(sampler.next(), i % 10) # Repeat the test for .next() + if i%5==0: + self.assertNumpyArrayEqual(sampler.get_samples(), np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) + + def test_random_without_replacement_iterator_and_get_samples(self): + #Test the random without replacement sampler + sampler = Sampler.randomWithoutReplacement(7, shuffle=True, seed=1) + order = [6, 2, 1, 0, 4, 3, 5, 1, 0, 4, 2, 5, + 6, 3, 3, 2, 1, 4, 0, 5, 6, 2, 6, 3, 4] + for i in range(25): + self.assertEqual(next(sampler), order[i]) + if i%4==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(6), np.array(order[:6])) + + #Repeat the test for shuffle=False + sampler = Sampler.randomWithoutReplacement(8, shuffle=False, seed=1) + order = [7, 2, 1, 6, 0, 4, 3, 5] + for i in range(25): + self.assertEqual(sampler.next(), order[i % 8]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(5), np.array(order[:5])) + + def test_herman_meyer_iterator_and_get_samples(self): + #Test the Herman Meyer sampler + sampler = Sampler.hermanMeyer(12) + order = [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11, 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + for i in range(25): + self.assertEqual(sampler.next(), order[i % 12]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + + def test_random_with_replacement_iterator_and_get_samples(self): + #Test the Random with replacement sampler + sampler = Sampler.randomWithReplacement(5, seed=5) + order=[1, 4, 1, 4, 2, 3, 3, 2, 1, 0, 0, 3, 2, 0, 4, 1, 2, 1, 3, 2, 2, 1, 1, 1, 1] + for i in range(25): + self.assertEqual(next(sampler), order[i]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + + sampler = Sampler.randomWithReplacement( + 4, [0.7, 0.1, 0.1, 0.1], seed=5) + order = [0, 2, 0, 3, 0, 0, 1, 0, 0, 0, 0, 1, + 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + for i in range(25): + self.assertEqual(sampler.next(), order[i]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + + def test_staggered_iterator_and_get_samples(self): + #Test the staggered sampler + sampler = Sampler.staggered(21, 4) + order = [0, 4, 8, 12, 16, 20, 1, 5, 9, 13, + 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + for i in range(25): + self.assertEqual(next(sampler), order[i % 21]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(10), np.array(order[:10])) + + def test_custom_order_iterator_and_get_samples(self): + #Test the custom order sampler + sampler = Sampler.customOrder([1, 4, 6, 7, 8, 9, 11]) + order = [1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11] + for i in range(25): + self.assertEqual(sampler.next(), order[i % 7]) + if i%5==0:# Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(10), np.array(order[:10])) \ No newline at end of file From d62aa2bf5d07567afa3f4ff314e8122d5eb7e38c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 19 Sep 2023 16:02:19 +0000 Subject: [PATCH 023/115] Some checks for setting step sizes --- .../cil/optimisation/algorithms/SPDHG.py | 44 ++++++++++++++++++- 1 file changed, 42 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index f918597bf5..53a68682a6 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -23,7 +23,7 @@ import warnings import logging from cil.framework import Sampler - +from numbers import Number class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -113,6 +113,8 @@ def norms(self): return self._norms def set_norms(self, norms=None): + #TODO: write some checks for setting norms + if norms is None: # Compute norm of each sub-operator norms = [self.operator.get_item(i, 0).norm() @@ -124,6 +126,16 @@ def sigma(self): return self._sigma def set_sigma(self, sigma=None, norms=None): + #TODO: check if this is correct for PSDHG + if sigma is not None: + if isinstance(sigma, Number): + if sigma <= 0: + raise ValueError("The step-sizes of PDHG are positive, passed sigma = {}".format(sigma)) + elif sigma.shape != self.operator.range_geometry().shape: + raise ValueError(" The shape of sigma = {0} is not the same as the shape of the range_geometry = {1}".format(sigma.shape, self.operator.range_geometry().shape)) + + + self.set_norms(norms) if sigma is None: self._sigma = [self.gamma * self.rho / ni for ni in self._norms] @@ -135,6 +147,16 @@ def tau(self): return self._tau def set_tau(self, tau=None): + #TODO: check if this is correct for SPDHG + if tau is not None: + if isinstance(tau, Number): + if tau <= 0: + raise ValueError("The step-sizes of PDHG must be positive, passed tau = {}".format(tau)) + elif tau.shape != self.operator.domain_geometry().shape: + raise ValueError(" The shape of tau = {0} is not the same as the shape of the domain_geometry = {1}".format(tau.shape, self.operator.domain_geometry().shape)) + + + if tau is None: self._tau = min([pi / (si * ni**2) for pi, ni, si in zip(self._prob_weights, self._norms, self._sigma)]) @@ -146,7 +168,25 @@ def set_step_sizes(self): ''' If you update either the norms or the prob_weights run this to reset the default sigma and tau step-sizes''' self.set_sigma() self.set_tau() - #TODO: Look at the PDHG one?? + + def check_convergence(self): + #TODO: check if this is correct for SPDHG + """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma + + Returns + ------- + Boolean + True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. + """ + if isinstance(self.tau, Number) and isinstance(self.sigma, Number): + if self.sigma * self.tau * self.operator.norm()**2 > 1: + warnings.warn("Convergence criterion of PDHG for scalar step-sizes is not satisfied.") + return False + return True + else: + warnings.warn("Convergence criterion can only be checked for scalar values of tau and sigma.") + return False + @property def prob_weights(self): From c81b71c28ac9210e7c21ff8b83e7063c3f3c3aed Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Sep 2023 15:02:10 +0000 Subject: [PATCH 024/115] Started looking at unit tests and debugging SPDHG setters and init --- .../cil/optimisation/algorithms/SPDHG.py | 197 ++-- Wrappers/Python/test/test_algorithms.py | 968 ++++++++++-------- 2 files changed, 658 insertions(+), 507 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 53a68682a6..4a30d9eac0 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -25,6 +25,7 @@ from cil.framework import Sampler from numbers import Number + class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -77,7 +78,7 @@ class SPDHG(Algorithm): ---- Notation for primal and dual step-sizes are reversed with comparison - to PDHG.py + to SPDHG.py @@ -100,6 +101,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, super(SPDHG, self).__init__(**kwargs) self._prob_weights = kwargs.get('prob', None) + if self._prob_weights is not None: warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)".\ If you have passed both prob and a sampler then prob will be') @@ -113,90 +115,175 @@ def norms(self): return self._norms def set_norms(self, norms=None): - #TODO: write some checks for setting norms + """Sets the operator norms for the step-size calculations for the SPDHG algorithm + Parameters + ---------- + norms : list of floats + precalculated list of norms of the operators""" if norms is None: # Compute norm of each sub-operator norms = [self.operator.get_item(i, 0).norm() for i in range(self.ndual_subsets)] + else: + for i in range(len(norms)): + if isinstance(norms[i], Number): + if norms[i] <= 0: + raise ValueError( + "The norms of the operators should be positive, passed norm= {}".format(norms[i])) + self._norms = norms @property - def sigma(self): - return self._sigma + def sampler(self): + return self._sampler + @property + def prob_weights(self): + return self._prob_weights + + def set_sampler(self, sampler=None): + """ Sets the sampler for the SPDHG algorithm. - def set_sigma(self, sigma=None, norms=None): - #TODO: check if this is correct for PSDHG - if sigma is not None: - if isinstance(sigma, Number): - if sigma <= 0: - raise ValueError("The step-sizes of PDHG are positive, passed sigma = {}".format(sigma)) - elif sigma.shape != self.operator.range_geometry().shape: - raise ValueError(" The shape of sigma = {0} is not the same as the shape of the range_geometry = {1}".format(sigma.shape, self.operator.range_geometry().shape)) + Parameters + ---------- + sampler: instance of the Sampler class + Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. + """ + if sampler is None: + if self._prob_weights is None: + self._prob_weights = [1/self.ndual_subsets] * self.ndual_subsets + self._sampler = Sampler.randomWithReplacement( + self.ndual_subsets, prob=self._prob_weights) + else: + if not isinstance(sampler, Sampler): + raise ValueError( + "The sampler should be an instance of the CIL Sampler class") + self._sampler = sampler + if sampler.prob is None: + self._prob_weights=[1/self.ndual_subsets] * self.ndual_subsets + else: + self._prob_weights=sampler.prob + + - self.set_norms(norms) - if sigma is None: - self._sigma = [self.gamma * self.rho / ni for ni in self._norms] + @property + def gamma(self): + return self._gamma + + def set_gamma(self, gamma=1.): + """ Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. + + Parameters + ---------- + gamma : float + parameter controlling the trade-off between the primal and dual step sizes + + """ + if isinstance(gamma, Number): + if gamma <= 0: + raise ValueError( + "The step-sizes of SPDHG are positive, gamma should also be positive") + + self._gamma = gamma else: + raise ValueError( + "We currently only support scalar values of gamma") + + @property + def sigma(self): + return self._sigma + + def set_sigma(self, sigma=None): + """ Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. + + Parameters + ---------- + sigma : list of positive float, optional, default=None + List of Step size parameters for Dual problem + + The user can set these or default values are calculated. Values passed by the user will be accepted as long as they are positive numbers, + or correct shape array like objects. + """ + if sigma is not None: + for i in range(len(sigma)): + if isinstance(sigma[i], Number): + if sigma[i] <= 0: + raise ValueError( + "The step-sizes of SPDHG are positive, passed sigma = {}".format(sigma[i])) + if len(sigma) != self.operator.range_geometry().shape[0]: + raise ValueError(" The shape of sigma = {0} is not the same as the shape of the range_geometry = {1}".format( + len(sigma), self.operator.range_geometry().shape[0])) self._sigma = sigma + elif sigma is None: + self._sigma = [self._gamma * self.rho / ni for ni in self._norms] + @property def tau(self): return self._tau def set_tau(self, tau=None): - #TODO: check if this is correct for SPDHG - if tau is not None: - if isinstance(tau, Number): - if tau <= 0: - raise ValueError("The step-sizes of PDHG must be positive, passed tau = {}".format(tau)) - elif tau.shape != self.operator.domain_geometry().shape: - raise ValueError(" The shape of tau = {0} is not the same as the shape of the domain_geometry = {1}".format(tau.shape, self.operator.domain_geometry().shape)) - + """ Sets tau step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. + Parameters + ---------- + tau : positive :obj:`float`, or `np.ndarray`, `DataContainer`, `BlockDataContainer`, optional, default=None + Step size for the primal problem. + The user can set either set these or instead the defaults are selected instead. Values passed by the user will be accepted as long as they are positive numbers, + or correct shape array like objects. + """ + if tau is not None: + if isinstance(tau, Number): + if tau <= 0: + raise ValueError( + "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) + elif tau.shape != self.operator.domain_geometry().shape: + raise ValueError(" The shape of tau = {0} is not the same as the shape of the domain_geometry = {1}".format( + tau.shape, self.operator.domain_geometry().shape)) + self._tau = tau if tau is None: self._tau = min([pi / (si * ni**2) for pi, ni, si in zip(self._prob_weights, self._norms, self._sigma)]) self._tau *= (self.rho / self.gamma) - else: - self._tau = tau - def set_step_sizes(self): - ''' If you update either the norms or the prob_weights run this to reset the default sigma and tau step-sizes''' + def reset_default_step_sizes(self): + """ Sets default sigma and tau step-sizes for the SPDHG algorithm. This should be re-run after changing the sampler, norms, gamma or prob_weights. + + Note + ---- + tau : positive float, optional, default=None + Step size parameter for Primal problem + + sigma : list of positive float, optional, default=None + List of Step size parameters for Dual problem + + """ self.set_sigma() self.set_tau() - + def check_convergence(self): - #TODO: check if this is correct for SPDHG + # TODO: check this with someone else """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma Returns ------- Boolean True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. - """ - if isinstance(self.tau, Number) and isinstance(self.sigma, Number): - if self.sigma * self.tau * self.operator.norm()**2 > 1: - warnings.warn("Convergence criterion of PDHG for scalar step-sizes is not satisfied.") + """ + for i in range(len(self._sigma)): + if isinstance(self.tau, Number) and isinstance(self._sigma[i], Number): + if self._sigma[i] * self._tau * self._norms[i]**2 > self._prob_weights[i]**2: + warnings.warn( + "Convergence criterion of SPDHG for scalar step-sizes is not satisfied.") + return False + return True + else: + warnings.warn( + "Convergence criterion currently can only be checked for scalar values of tau.") return False - return True - else: - warnings.warn("Convergence criterion can only be checked for scalar values of tau and sigma.") - return False - - - @property - def prob_weights(self): - return self._prob_weights - - def set_prob_weights(self, prob_weights=None): - if prob_weights is None: - self._prob_weights = [1/self.ndual_subsets] * self.ndual_subsets - else: - self._prob_weights = prob_weights def set_up(self, f, g, operator, tau=None, sigma=None, initial=None, gamma=1., sampler=None, norms=None): @@ -215,7 +302,6 @@ def set_up(self, f, g, operator, tau=None, sigma=None, List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - gamma : float parameter controlling the trade-off between the primal and dual step sizes sampler: instance of the Sampler class @@ -230,17 +316,12 @@ def set_up(self, f, g, operator, tau=None, sigma=None, self.f = f self.g = g self.operator = operator - self.sampler = sampler - self.gamma = gamma self.ndual_subsets = self.operator.shape[0] self.rho = .99 - # Remove this if statement once prob is deprecated - if self._prob_weights is None or sampler is not None: - self.set_prob_weights(sampler.prob) - if self.sampler is None: - self.sampler = Sampler.randomWithReplacement( - self.ndual_subsets, prob=self._prob_weights) + + self.set_sampler(sampler) + self.set_gamma(gamma) self.set_norms(norms) self.set_sigma(sigma) self.set_tau(tau) @@ -272,7 +353,7 @@ def update(self): self.g.proximal(self.x_tmp, self._tau, out=self.x) # Choose subset - i = self.sampler.next() + i = self._sampler.next() # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index a7622b7f62..64f8df43a4 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -29,13 +29,14 @@ from cil.framework import AcquisitionGeometry from cil.framework import BlockDataContainer from cil.framework import BlockGeometry +from cil.framework import Sampler from cil.optimisation.operators import IdentityOperator from cil.optimisation.operators import GradientOperator, BlockOperator, MatrixOperator from cil.optimisation.functions import LeastSquares, ZeroFunction, \ - L2NormSquared, OperatorCompositionFunction -from cil.optimisation.functions import MixedL21Norm, BlockFunction, L1Norm, KullbackLeibler + L2NormSquared, OperatorCompositionFunction +from cil.optimisation.functions import MixedL21Norm, BlockFunction, L1Norm, KullbackLeibler from cil.optimisation.functions import IndicatorBox from cil.optimisation.algorithms import Algorithm @@ -59,43 +60,45 @@ # Fast Gradient Projection algorithm for Total Variation(TV) from cil.optimisation.functions import TotalVariation +from cil.plugins.ccpi_regularisation.functions import FGP_TV import logging from testclass import CCPiTestClass -from utils import has_astra +from utils import has_astra initialise_tests() if has_astra: from cil.plugins.astra import ProjectionOperator + class TestAlgorithms(CCPiTestClass): - + def test_GD(self): - ig = ImageGeometry(12,13,14) + ig = ImageGeometry(12, 13, 14) initial = ig.allocate() # b = initial.copy() # fill with random numbers # b.fill(numpy.random.random(initial.shape)) b = ig.allocate('random') identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) rate = norm2sq.L / 3. - - alg = GD(initial=initial, - objective_function=norm2sq, - rate=rate, atol=1e-9, rtol=1e-6) + + alg = GD(initial=initial, + objective_function=norm2sq, + rate=rate, atol=1e-9, rtol=1e-6) alg.max_iteration = 1000 alg.run(verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = GD(initial=initial, - objective_function=norm2sq, - rate=rate, max_iteration=20, - update_objective_interval=2, - atol=1e-9, rtol=1e-6) + alg = GD(initial=initial, + objective_function=norm2sq, + rate=rate, max_iteration=20, + update_objective_interval=2, + atol=1e-9, rtol=1e-6) alg.max_iteration = 20 self.assertTrue(alg.max_iteration == 20) - self.assertTrue(alg.update_objective_interval==2) + self.assertTrue(alg.update_objective_interval == 2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) @@ -105,117 +108,118 @@ def test_update_interval_0(self): the update_objective interval is set to 0 and with verbose on / off ''' - ig = ImageGeometry(12,13,14) + ig = ImageGeometry(12, 13, 14) initial = ig.allocate() b = ig.allocate('random') identity = IdentityOperator(ig) norm2sq = LeastSquares(identity, b) - alg = GD(initial=initial, - objective_function=norm2sq, + alg = GD(initial=initial, + objective_function=norm2sq, max_iteration=20, update_objective_interval=0, atol=1e-9, rtol=1e-6) - self.assertTrue(alg.update_objective_interval==0) + self.assertTrue(alg.update_objective_interval == 0) alg.run(20, verbose=True) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) alg.run(20, verbose=False) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - def test_GDArmijo(self): - ig = ImageGeometry(12,13,14) + ig = ImageGeometry(12, 13, 14) initial = ig.allocate() # b = initial.copy() # fill with random numbers # b.fill(numpy.random.random(initial.shape)) b = ig.allocate('random') identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) rate = None - - alg = GD(initial=initial, - objective_function=norm2sq, rate=rate) + + alg = GD(initial=initial, + objective_function=norm2sq, rate=rate) alg.max_iteration = 100 alg.run(verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = GD(initial=initial, - objective_function=norm2sq, - max_iteration=20, - update_objective_interval=2) - #alg.max_iteration = 20 + alg = GD(initial=initial, + objective_function=norm2sq, + max_iteration=20, + update_objective_interval=2) + # alg.max_iteration = 20 self.assertTrue(alg.max_iteration == 20) - self.assertTrue(alg.update_objective_interval==2) + self.assertTrue(alg.update_objective_interval == 2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - def test_GDArmijo2(self): - f = Rosenbrock (alpha = 1., beta=100.) + f = Rosenbrock(alpha=1., beta=100.) vg = VectorGeometry(2) x = vg.allocate('random_int', seed=2) - # x = vg.allocate('random', seed=1) - x.fill(numpy.asarray([10.,-3.])) - + # x = vg.allocate('random', seed=1) + x.fill(numpy.asarray([10., -3.])) + max_iter = 10000 update_interval = 1000 - alg = GD(x, f, max_iteration=max_iter, update_objective_interval=update_interval, alpha=1e6) - + alg = GD(x, f, max_iteration=max_iter, + update_objective_interval=update_interval, alpha=1e6) + alg.run(verbose=0) - + # this with 10k iterations - numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [0.13463363, 0.01604593], decimal = 5) + numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [ + 0.13463363, 0.01604593], decimal=5) # this with 1m iterations # numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [1,1], decimal = 1) # numpy.testing.assert_array_almost_equal(alg.get_output().as_array(), [0.982744, 0.965725], decimal = 6) - def test_CGLS(self): - ig = ImageGeometry(10,2) + ig = ImageGeometry(10, 2) numpy.random.seed(2) initial = ig.allocate(1.) b = ig.allocate('random') identity = IdentityOperator(ig) - + alg = CGLS(initial=initial, operator=identity, data=b) - - np.testing.assert_array_equal(initial.as_array(), alg.solution.as_array()) - alg.max_iteration = 200 + np.testing.assert_array_equal( + initial.as_array(), alg.solution.as_array()) + + alg.max_iteration = 200 alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = CGLS(initial=initial, operator=identity, data=b, max_iteration=200, update_objective_interval=2) + alg = CGLS(initial=initial, operator=identity, data=b, + max_iteration=200, update_objective_interval=2) self.assertTrue(alg.max_iteration == 200) - self.assertTrue(alg.update_objective_interval==2) + self.assertTrue(alg.update_objective_interval == 2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - - + def test_FISTA(self): - ig = ImageGeometry(127,139,149) + ig = ImageGeometry(127, 139, 149) initial = ig.allocate() b = initial.copy() # fill with random numbers b.fill(numpy.random.random(initial.shape)) initial = ig.allocate(ImageGeometry.RANDOM) identity = IdentityOperator(ig) - + norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity) - opt = {'tol': 1e-4, 'memopt':False} - logging.info ("initial objective {}".format(norm2sq(initial))) - + opt = {'tol': 1e-4, 'memopt': False} + logging.info("initial objective {}".format(norm2sq(initial))) + alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction()) alg.max_iteration = 2 alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), max_iteration=2, update_objective_interval=2) - + alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), + max_iteration=2, update_objective_interval=2) + self.assertTrue(alg.max_iteration == 2) - self.assertTrue(alg.update_objective_interval==2) + self.assertTrue(alg.update_objective_interval == 2) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) @@ -227,11 +231,12 @@ def test_FISTA_update(self): n = 50 m = 500 - A = np.random.uniform(0,1, (m, n)).astype('float32') - b = (A.dot(np.random.randn(n)) + 0.1*np.random.randn(m)).astype('float32') + A = np.random.uniform(0, 1, (m, n)).astype('float32') + b = (A.dot(np.random.randn(n)) + 0.1 * + np.random.randn(m)).astype('float32') Aop = MatrixOperator(A) - bop = VectorData(b) + bop = VectorData(b) f = LeastSquares(Aop, b=bop, c=0.5) g = ZeroFunction() @@ -239,10 +244,10 @@ def test_FISTA_update(self): ig = Aop.domain initial = ig.allocate() - + # ista run 10 iteration tmp_initial = ig.allocate() - fista = FISTA(initial = tmp_initial, f = f, g = g, max_iteration=1) + fista = FISTA(initial=tmp_initial, f=f, g=g, max_iteration=1) fista.run() # fista update method @@ -254,97 +259,99 @@ def test_FISTA_update(self): for _ in range(1): - x = g.proximal(y_old - step_size * f.gradient(y_old), tau = step_size) + x = g.proximal(y_old - step_size * + f.gradient(y_old), tau=step_size) t = 0.5*(1 + numpy.sqrt(1 + 4*(t_old**2))) - y = x + ((t_old-1)/t)* ( x - x_old) + y = x + ((t_old-1)/t) * (x - x_old) x_old.fill(x) y_old.fill(y) t_old = t - - np.testing.assert_allclose(fista.solution.array, x.array, atol=1e-2) - + + np.testing.assert_allclose(fista.solution.array, x.array, atol=1e-2) + # check objective res1 = fista.objective[-1] res2 = f(x) + g(x) - self.assertTrue( res1==res2) + self.assertTrue(res1 == res2) tmp_initial = ig.allocate() - fista1 = FISTA(initial = tmp_initial, f = f, g = g, max_iteration=1) + fista1 = FISTA(initial=tmp_initial, f=f, g=g, max_iteration=1) self.assertTrue(fista1.is_provably_convergent()) - fista1 = FISTA(initial = tmp_initial, f = f, g = g, max_iteration=1, step_size=30.0) - self.assertFalse(fista1.is_provably_convergent()) + fista1 = FISTA(initial=tmp_initial, f=f, g=g, + max_iteration=1, step_size=30.0) + self.assertFalse(fista1.is_provably_convergent()) - def test_FISTA_Norm2Sq(self): - ig = ImageGeometry(127,139,149) + ig = ImageGeometry(127, 139, 149) b = ig.allocate(ImageGeometry.RANDOM) # fill with random numbers initial = ig.allocate(ImageGeometry.RANDOM) identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) - - opt = {'tol': 1e-4, 'memopt':False} - logging.info ("initial objective {}".format(norm2sq(initial))) + + opt = {'tol': 1e-4, 'memopt': False} + logging.info("initial objective {}".format(norm2sq(initial))) alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction()) alg.max_iteration = 2 alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) - alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), max_iteration=2, update_objective_interval=3) + alg = FISTA(initial=initial, f=norm2sq, g=ZeroFunction(), + max_iteration=2, update_objective_interval=3) self.assertTrue(alg.max_iteration == 2) - self.assertTrue(alg.update_objective_interval== 3) + self.assertTrue(alg.update_objective_interval == 3) alg.run(20, verbose=0) self.assertNumpyArrayAlmostEqual(alg.x.as_array(), b.as_array()) def test_FISTA_catch_Lipschitz(self): - ig = ImageGeometry(127,139,149) + ig = ImageGeometry(127, 139, 149) initial = ImageData(geometry=ig) initial = ig.allocate() b = initial.copy() - # fill with random numbers + # fill with random numbers b.fill(numpy.random.random(initial.shape)) initial = ig.allocate(ImageGeometry.RANDOM) identity = IdentityOperator(ig) - + norm2sq = LeastSquares(identity, b) logging.info('Lipschitz {}'.format(norm2sq.L)) # norm2sq.L = None - #norm2sq.L = 2 * norm2sq.c * identity.norm()**2 - #norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity) - opt = {'tol': 1e-4, 'memopt':False} - logging.info ("initial objective".format(norm2sq(initial))) + # norm2sq.L = 2 * norm2sq.c * identity.norm()**2 + # norm2sq = OperatorCompositionFunction(L2NormSquared(b=b), identity) + opt = {'tol': 1e-4, 'memopt': False} + logging.info("initial objective".format(norm2sq(initial))) with self.assertRaises(ValueError): - alg = FISTA(initial=initial, f=L1Norm(), g=ZeroFunction()) - + alg = FISTA(initial=initial, f=L1Norm(), g=ZeroFunction()) def test_PDHG_Denoising(self): - # adapted from demo PDHG_TV_Color_Denoising.py in CIL-Demos repository - data = dataexample.PEPPERS.get(size=(256,256)) + # adapted from demo PDHG_TV_Color_Denoising.py in CIL-Demos repository + data = dataexample.PEPPERS.get(size=(256, 256)) ig = data.geometry ag = ig which_noise = 0 - # Create noisy data. + # Create noisy data. noises = ['gaussian', 'poisson', 's&p'] dnoise = noises[which_noise] - + def setup(data, dnoise): if dnoise == 's&p': - n1 = applynoise.saltnpepper(data, salt_vs_pepper = 0.9, amount=0.2, seed=10) + n1 = applynoise.saltnpepper( + data, salt_vs_pepper=0.9, amount=0.2, seed=10) elif dnoise == 'poisson': scale = 5 - n1 = applynoise.poisson( data.as_array()/scale, seed = 10)*scale + n1 = applynoise.poisson(data.as_array()/scale, seed=10)*scale elif dnoise == 'gaussian': - n1 = applynoise.gaussian(data.as_array(), seed = 10) + n1 = applynoise.gaussian(data.as_array(), seed=10) else: raise ValueError('Unsupported Noise ', noise) noisy_data = ig.allocate() noisy_data.fill(n1) - + # Regularisation Parameter depending on the noise distribution if dnoise == 's&p': alpha = 0.8 @@ -362,10 +369,11 @@ def setup(data, dnoise): return noisy_data, alpha, g noisy_data, alpha, g = setup(data, dnoise) - operator = GradientOperator(ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + operator = GradientOperator( + ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + + f1 = alpha * MixedL21Norm() - f1 = alpha * MixedL21Norm() - # Compute operator Norm normK = operator.norm() @@ -374,22 +382,23 @@ def setup(data, dnoise): tau = 1/(sigma*normK**2) # Setup and run the PDHG algorithm - pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma) + pdhg1 = PDHG(f=f1, g=g, operator=operator, tau=tau, sigma=sigma) pdhg1.max_iteration = 2000 pdhg1.update_objective_interval = 200 pdhg1.run(1000, verbose=0) rmse = (pdhg1.get_output() - data).norm() / data.as_array().size - logging.info ("RMSE {}".format(rmse)) + logging.info("RMSE {}".format(rmse)) self.assertLess(rmse, 2e-4) which_noise = 1 noise = noises[which_noise] noisy_data, alpha, g = setup(data, noise) - operator = GradientOperator(ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + operator = GradientOperator( + ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + + f1 = alpha * MixedL21Norm() - f1 = alpha * MixedL21Norm() - # Compute operator Norm normK = operator.norm() @@ -398,23 +407,23 @@ def setup(data, dnoise): tau = 1/(sigma*normK**2) # Setup and run the PDHG algorithm - pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma, + pdhg1 = PDHG(f=f1, g=g, operator=operator, tau=tau, sigma=sigma, max_iteration=2000, update_objective_interval=200) - + pdhg1.run(1000, verbose=0) rmse = (pdhg1.get_output() - data).norm() / data.as_array().size logging.info("RMSE {}".format(rmse)) self.assertLess(rmse, 2e-4) - - + which_noise = 2 noise = noises[which_noise] noisy_data, alpha, g = setup(data, noise) - operator = GradientOperator(ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + operator = GradientOperator( + ig, correlation=GradientOperator.CORRELATION_SPACE, backend='numpy') + + f1 = alpha * MixedL21Norm() - f1 = alpha * MixedL21Norm() - # Compute operator Norm normK = operator.norm() @@ -423,7 +432,7 @@ def setup(data, dnoise): tau = 1/(sigma*normK**2) # Setup and run the PDHG algorithm - pdhg1 = PDHG(f=f1,g=g,operator=operator, tau=tau, sigma=sigma) + pdhg1 = PDHG(f=f1, g=g, operator=operator, tau=tau, sigma=sigma) pdhg1.max_iteration = 2000 pdhg1.update_objective_interval = 200 pdhg1.run(1000, verbose=0) @@ -432,169 +441,173 @@ def setup(data, dnoise): logging.info("RMSE {}".format(rmse)) self.assertLess(rmse, 2e-4) - def test_PDHG_step_sizes(self): - ig = ImageGeometry(3,3) + ig = ImageGeometry(3, 3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = 3*IdentityOperator(ig) - #check if sigma, tau are None + # check if sigma, tau are None pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10) self.assertAlmostEqual(pdhg.sigma, 1./operator.norm()) self.assertAlmostEqual(pdhg.tau, 1./operator.norm()) - #check if sigma is negative + # check if sigma is negative with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, sigma = -1) - - #check if tau is negative + pdhg = PDHG(f=f, g=g, operator=operator, + max_iteration=10, sigma=-1) + + # check if tau is negative with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, tau = -1) - - #check if tau is None + pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, tau=-1) + + # check if tau is None sigma = 3.0 - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, max_iteration=10) self.assertAlmostEqual(pdhg.sigma, sigma) - self.assertAlmostEqual(pdhg.tau, 1./(sigma * operator.norm()**2)) + self.assertAlmostEqual(pdhg.tau, 1./(sigma * operator.norm()**2)) - #check if sigma is None + # check if sigma is None tau = 3.0 - pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, max_iteration=10) self.assertAlmostEqual(pdhg.tau, tau) - self.assertAlmostEqual(pdhg.sigma, 1./(tau * operator.norm()**2)) + self.assertAlmostEqual(pdhg.sigma, 1./(tau * operator.norm()**2)) - #check if sigma/tau are not None + # check if sigma/tau are not None tau = 1.0 sigma = 1.0 - pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, sigma = sigma, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, + sigma=sigma, max_iteration=10) self.assertAlmostEqual(pdhg.tau, tau) - self.assertAlmostEqual(pdhg.sigma, sigma) + self.assertAlmostEqual(pdhg.sigma, sigma) - #check sigma/tau as arrays, sigma wrong shape - ig1 = ImageGeometry(2,2) + # check sigma/tau as arrays, sigma wrong shape + ig1 = ImageGeometry(2, 2) sigma = ig1.allocate() with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, max_iteration=10) + pdhg = PDHG(f=f, g=g, operator=operator, + sigma=sigma, max_iteration=10) - #check sigma/tau as arrays, tau wrong shape + # check sigma/tau as arrays, tau wrong shape tau = ig1.allocate() with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, max_iteration=10) - + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, max_iteration=10) + # check sigma not Number or object with correct shape with self.assertRaises(AttributeError): - pdhg = PDHG(f=f, g=g, operator=operator, sigma = "sigma", max_iteration=10) - + pdhg = PDHG(f=f, g=g, operator=operator, + sigma="sigma", max_iteration=10) + # check tau not Number or object with correct shape with self.assertRaises(AttributeError): - pdhg = PDHG(f=f, g=g, operator=operator, tau = "tau", max_iteration=10) - + pdhg = PDHG(f=f, g=g, operator=operator, + tau="tau", max_iteration=10) + # check warning message if condition is not satisfied sigma = 4 tau = 1/3 with warnings.catch_warnings(record=True) as wa: - pdhg = PDHG(f=f, g=g, operator=operator, tau = tau, sigma = sigma, max_iteration=10) - assert "Convergence criterion" in str(wa[0].message) - + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, + sigma=sigma, max_iteration=10) + assert "Convergence criterion" in str(wa[0].message) def test_PDHG_strongly_convex_gamma_g(self): - ig = ImageGeometry(3,3) + ig = ImageGeometry(3, 3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = IdentityOperator(ig) - # sigma, tau + # sigma, tau sigma = 1.0 - tau = 1.0 + tau = 1.0 - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, max_iteration=5, gamma_g=0.5) pdhg.run(1, verbose=0) - self.assertAlmostEquals(pdhg.theta, 1.0/ np.sqrt(1 + 2 * pdhg.gamma_g * tau)) + self.assertAlmostEquals( + pdhg.theta, 1.0 / np.sqrt(1 + 2 * pdhg.gamma_g * tau)) self.assertAlmostEquals(pdhg.tau, tau * pdhg.theta) self.assertAlmostEquals(pdhg.sigma, sigma / pdhg.theta) pdhg.run(4, verbose=0) self.assertNotEqual(pdhg.sigma, sigma) - self.assertNotEqual(pdhg.tau, tau) + self.assertNotEqual(pdhg.tau, tau) # check negative strongly convex constant with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, - max_iteration=5, gamma_g=-0.5) - + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + max_iteration=5, gamma_g=-0.5) # check strongly convex constant not a number with self.assertRaises(ValueError): - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, - max_iteration=5, gamma_g="-0.5") - + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + max_iteration=5, gamma_g="-0.5") def test_PDHG_strongly_convex_gamma_fcong(self): - ig = ImageGeometry(3,3) + ig = ImageGeometry(3, 3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = IdentityOperator(ig) - # sigma, tau + # sigma, tau sigma = 1.0 - tau = 1.0 + tau = 1.0 - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, max_iteration=5, gamma_fconj=0.5) pdhg.run(1, verbose=0) - self.assertEquals(pdhg.theta, 1.0/ np.sqrt(1 + 2 * pdhg.gamma_fconj * sigma)) + self.assertEquals(pdhg.theta, 1.0 / np.sqrt(1 + + 2 * pdhg.gamma_fconj * sigma)) self.assertEquals(pdhg.tau, tau / pdhg.theta) self.assertEquals(pdhg.sigma, sigma * pdhg.theta) pdhg.run(4, verbose=0) self.assertNotEqual(pdhg.sigma, sigma) - self.assertNotEqual(pdhg.tau, tau) + self.assertNotEqual(pdhg.tau, tau) # check negative strongly convex constant try: - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, - max_iteration=5, gamma_fconj=-0.5) + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + max_iteration=5, gamma_fconj=-0.5) except ValueError as ve: - logging.info(str(ve)) + logging.info(str(ve)) # check strongly convex constant not a number try: - pdhg = PDHG(f=f, g=g, operator=operator, sigma = sigma, tau=tau, - max_iteration=5, gamma_fconj="-0.5") + pdhg = PDHG(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + max_iteration=5, gamma_fconj="-0.5") except ValueError as ve: - logging.info(str(ve)) + logging.info(str(ve)) def test_PDHG_strongly_convex_both_fconj_and_g(self): - ig = ImageGeometry(3,3) + ig = ImageGeometry(3, 3) data = ig.allocate('random') f = L2NormSquared(b=data) g = L2NormSquared() operator = IdentityOperator(ig) - + try: - pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, - gamma_g = 0.5, gamma_fconj=0.5) + pdhg = PDHG(f=f, g=g, operator=operator, max_iteration=10, + gamma_g=0.5, gamma_fconj=0.5) pdhg.run(verbose=0) except ValueError as err: - logging.info(str(err)) + logging.info(str(err)) def test_FISTA_Denoising(self): # adapted from demo FISTA_Tikhonov_Poisson_Denoising.py in CIL-Demos repository data = dataexample.SHAPES.get() ig = data.geometry ag = ig - N=300 + N = 300 # Create Noisy data with Poisson noise scale = 5 - noisy_data = applynoise.poisson(data/scale,seed=10) * scale + noisy_data = applynoise.poisson(data/scale, seed=10) * scale # Regularisation Parameter alpha = 10 @@ -605,7 +618,7 @@ def test_FISTA_Denoising(self): reg = OperatorCompositionFunction(alpha * L2NormSquared(), operator) initial = ig.allocate() - fista = FISTA(initial=initial , f=reg, g=fid) + fista = FISTA(initial=initial, f=reg, g=fid) fista.max_iteration = 3000 fista.update_objective_interval = 500 fista.run(verbose=0) @@ -614,161 +627,210 @@ def test_FISTA_Denoising(self): self.assertLess(rmse, 4.2e-4) - - - - - - - - - - - - - - - - class TestSIRT(unittest.TestCase): - - def setUp(self): + def setUp(self): np.random.seed(10) # set up matrix, vectordata n, m = 50, 50 - A = np.random.uniform(0, 1,(m, n)).astype('float32') + A = np.random.uniform(0, 1, (m, n)).astype('float32') b = A.dot(np.random.randn(n)) self.Aop = MatrixOperator(A) - self.bop = VectorData(b) + self.bop = VectorData(b) self.ig = self.Aop.domain self.initial = self.ig.allocate() - + # set up with linear operator - self.ig2 = ImageGeometry(3,4,5) + self.ig2 = ImageGeometry(3, 4, 5) self.initial2 = self.ig2.allocate(0.) - self.b2 = self.ig2.allocate('random') - self.A2 = IdentityOperator(self.ig2) - + self.b2 = self.ig2.allocate('random') + self.A2 = IdentityOperator(self.ig2) def tearDown(self): - pass + pass - - def test_update(self): + def test_update(self): # sirt run 5 iterations tmp_initial = self.ig.allocate() - sirt = SIRT(initial = tmp_initial, operator=self.Aop, data=self.bop, max_iteration=5) + sirt = SIRT(initial=tmp_initial, operator=self.Aop, + data=self.bop, max_iteration=5) sirt.run() x = tmp_initial.copy() x_old = tmp_initial.copy() - for _ in range(5): - x = x_old + sirt.D*(sirt.operator.adjoint(sirt.M*(sirt.data - sirt.operator.direct(x_old)))) + for _ in range(5): + x = x_old + sirt.D * \ + (sirt.operator.adjoint(sirt.M*(sirt.data - sirt.operator.direct(x_old)))) x_old.fill(x) - np.testing.assert_allclose(sirt.solution.array, x.array, atol=1e-2) - + np.testing.assert_allclose(sirt.solution.array, x.array, atol=1e-2) def test_update_constraints(self): - alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20) - alg.run(verbose=0) - np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) - - alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20, upper=0.3) + alg = SIRT(initial=self.initial2, operator=self.A2, + data=self.b2, max_iteration=20) alg.run(verbose=0) - np.testing.assert_almost_equal(alg.solution.max(), 0.3) - - alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20, lower=0.7) + np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) + + alg = SIRT(initial=self.initial2, operator=self.A2, + data=self.b2, max_iteration=20, upper=0.3) alg.run(verbose=0) - np.testing.assert_almost_equal(alg.solution.min(), 0.7) - - alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20, constraint=IndicatorBox(lower=0.1, upper=0.3)) + np.testing.assert_almost_equal(alg.solution.max(), 0.3) + + alg = SIRT(initial=self.initial2, operator=self.A2, + data=self.b2, max_iteration=20, lower=0.7) alg.run(verbose=0) - np.testing.assert_almost_equal(alg.solution.max(), 0.3) - np.testing.assert_almost_equal(alg.solution.min(), 0.1) + np.testing.assert_almost_equal(alg.solution.min(), 0.7) + alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2, + max_iteration=20, constraint=IndicatorBox(lower=0.1, upper=0.3)) + alg.run(verbose=0) + np.testing.assert_almost_equal(alg.solution.max(), 0.3) + np.testing.assert_almost_equal(alg.solution.min(), 0.1) def test_SIRT_relaxation_parameter(self): tmp_initial = self.ig.allocate() - alg = SIRT(initial = tmp_initial, operator=self.Aop, data=self.bop, max_iteration=5) - + alg = SIRT(initial=tmp_initial, operator=self.Aop, + data=self.bop, max_iteration=5) + with self.assertRaises(ValueError): alg.set_relaxation_parameter(0) with self.assertRaises(ValueError): alg.set_relaxation_parameter(2) - - alg = SIRT(initial=self.initial2, operator=self.A2, data=self.b2,max_iteration=20) + alg = SIRT(initial=self.initial2, operator=self.A2, + data=self.b2, max_iteration=20) alg.set_relaxation_parameter(0.5) self.assertEqual(alg.relaxation_parameter, 0.5) alg.run(verbose=0) - np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) - - np.testing.assert_almost_equal(0.5 *alg.D.array, alg._Dscaled.array) + np.testing.assert_array_almost_equal(alg.x.array, self.b2.array) + np.testing.assert_almost_equal(0.5 * alg.D.array, alg._Dscaled.array) def test_SIRT_nan_inf_values(self): Aop_nan_inf = self.Aop - Aop_nan_inf.A[0:10,:] = 0. - Aop_nan_inf.A[:,10:20] = 0. + Aop_nan_inf.A[0:10, :] = 0. + Aop_nan_inf.A[:, 10:20] = 0. tmp_initial = self.ig.allocate() - sirt = SIRT(initial = tmp_initial, operator=Aop_nan_inf, data=self.bop, max_iteration=5) - - self.assertFalse(np.any(sirt.M == inf)) - self.assertFalse(np.any(sirt.D == inf)) + sirt = SIRT(initial=tmp_initial, operator=Aop_nan_inf, + data=self.bop, max_iteration=5) + self.assertFalse(np.any(sirt.M == inf)) + self.assertFalse(np.any(sirt.D == inf)) def test_SIRT_remove_nan_or_inf_with_BlockDataContainer(self): np.random.seed(10) # set up matrix, vectordata n, m = 50, 50 - A = np.random.uniform(0, 1,(m, n)).astype('float32') + A = np.random.uniform(0, 1, (m, n)).astype('float32') b = A.dot(np.random.randn(n)) - A[0:10,:] = 0. - A[:,10:20] = 0. - Aop = BlockOperator( MatrixOperator(A*1), MatrixOperator(A*2) ) - bop = BlockDataContainer( VectorData(b*1), VectorData(b*2) ) - + A[0:10, :] = 0. + A[:, 10:20] = 0. + Aop = BlockOperator(MatrixOperator(A*1), MatrixOperator(A*2)) + bop = BlockDataContainer(VectorData(b*1), VectorData(b*2)) + ig = BlockGeometry(self.ig.copy(), self.ig.copy()) tmp_initial = ig.allocate() - sirt = SIRT(initial = tmp_initial, operator=Aop, data=bop, max_iteration=5) + sirt = SIRT(initial=tmp_initial, operator=Aop, + data=bop, max_iteration=5) for el in sirt.M.containers: self.assertFalse(np.any(el == inf)) - + self.assertFalse(np.any(sirt.D == inf)) -class TestSPDHG(unittest.TestCase): +class TestSPDHG(CCPiTestClass): - @unittest.skipUnless(has_astra, "cil-astra not available") - def test_SPDHG_vs_PDHG_implicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + def test_SPDHG_defaults_and_setters(self): + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(20, 20)) + + subsets = 10 ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 - + detectors = ig.shape[0] angles = np.linspace(0, np.pi, 90) - ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) # Select device dev = 'cpu' - + Aop = ProjectionOperator(ig, ag, dev) + + sin = Aop.direct(data) + partitioned_data = sin.partition(subsets, 'sequential') + A = BlockOperator( + *[IdentityOperator(partitioned_data[i].geometry) for i in range(subsets)]) + + # block function + F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) + for i in range(subsets)]) + alpha = 0.025 + G = alpha * FGP_TV() + spdhg = SPDHG(f=F, g=G, operator=A) + self.assertEqual(spdhg.gamma, 1.) + self.assertEqual(spdhg.rho, .99) + self.assertListEqual(spdhg.norms, [A.get_item(i, 0).norm() + for i in range(subsets)]) + self.assertListEqual(spdhg.prob_weights, [1/subsets] * subsets) + self.assertTrue(isinstance(spdhg.sampler, Sampler)) + self.assertListEqual(spdhg.sigma, [spdhg.gamma * spdhg.rho / ni for ni in spdhg.norms]) + self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(spdhg.rho / spdhg.gamma)) + self.assertNumpyArrayEqual(spdhg.x.array, A.domain_geometry().allocate(0).array) + self.assertEqual(spdhg.max_iteration, 0) + self.assertEqual(spdhg.update_objective_interval, 1) + + spdhg.set_norms([1]*subsets) + spdhg.set_sampler(Sampler.randomWithReplacement(10, list(range(1,11)/55))) + spdhg.set_gamma(10) + spdhg.reset_default_step_sizes(self) + + #TODO: Test these changes + spdhg.set_sigma([1]*subsets) + spdhg.set_tau(100) + #TODO: Test again + + def test_spdhg_non_default_init(self): + #TODO:: Test again + pass + + def test_spdhg_check_convergence(self): + #TODO:checkconvergence + pass + + + @unittest.skipUnless(has_astra, "cil-astra not available") + def test_SPDHG_vs_PDHG_implicit(self): + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128, 128)) + + ig = data.geometry + ig.voxel_size_x = 0.1 + ig.voxel_size_y = 0.1 + + detectors = ig.shape[0] + angles = np.linspace(0, np.pi, 90) + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) + # Select device + dev = 'cpu' + + Aop = ProjectionOperator(ig, ag, dev) + sin = Aop.direct(data) # Create noisy data. Apply Gaussian noise noises = ['gaussian', 'poisson'] @@ -778,91 +840,98 @@ def test_SPDHG_vs_PDHG_implicit(self): np.random.seed(10) scale = 20 eta = 0 - noisy_data.fill(np.random.poisson(scale * (eta + sin.as_array()))/scale) + noisy_data.fill(np.random.poisson( + scale * (eta + sin.as_array()))/scale) elif noise == 'gaussian': np.random.seed(10) - n1 = np.random.normal(0, 0.1, size = ag.shape) - noisy_data.fill(n1 + sin.as_array()) + n1 = np.random.normal(0, 0.1, size=ag.shape) + noisy_data.fill(n1 + sin.as_array()) else: raise ValueError('Unsupported Noise ', noise) - + # Create BlockOperator - operator = Aop - f = KullbackLeibler(b=noisy_data) + operator = Aop + f = KullbackLeibler(b=noisy_data) alpha = 0.005 - g = alpha * TotalVariation(50, 1e-4, lower=0) + g = alpha * TotalVariation(50, 1e-4, lower=0) normK = operator.norm() - - #% 'implicit' PDHG, preconditioned step-sizes + + # % 'implicit' PDHG, preconditioned step-sizes tau_tmp = 1. sigma_tmp = 1. - tau = sigma_tmp / operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) - sigma = tau_tmp / operator.direct(sigma_tmp * operator.domain_geometry().allocate(1.)) - + tau = sigma_tmp / \ + operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) + sigma = tau_tmp / \ + operator.direct( + sigma_tmp * operator.domain_geometry().allocate(1.)) + # Setup and run the PDHG algorithm - pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval = 500) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=1000, + update_objective_interval=500) pdhg.run(verbose=0) - + subsets = 10 size_of_subsets = int(len(angles)/subsets) # take angles and create uniform subsets in uniform+sequential setting - list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] + list_angles = [angles[i:i+size_of_subsets] + for i in range(0, len(angles), size_of_subsets)] # create acquisitioin geometries for each the interval of splitting angles - list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i],angle_unit='radian').set_panel(detectors, 0.1) - for i in range(len(list_angles))] + list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i], angle_unit='radian').set_panel(detectors, 0.1) + for i in range(len(list_angles))] # create with operators as many as the subsets - A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) for i in range(subsets)]) - ## number of subsets - #(sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) + A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) + for i in range(subsets)]) + # number of subsets + # (sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) # - ## acquisisiton data + # acquisisiton data AD_list = [] for sub_num in range(subsets): for i in range(0, len(angles), size_of_subsets): - arr = noisy_data.as_array()[i:i+size_of_subsets,:] - AD_list.append(AcquisitionData(arr, geometry=list_geoms[sub_num])) + arr = noisy_data.as_array()[i:i+size_of_subsets, :] + AD_list.append(AcquisitionData( + arr, geometry=list_geoms[sub_num])) g = BlockDataContainer(*AD_list) - ## block function - F = BlockFunction(*[KullbackLeibler(b=g[i]) for i in range(subsets)]) - G = alpha * TotalVariation(50, 1e-4, lower=0) - + # block function + F = BlockFunction(*[KullbackLeibler(b=g[i]) for i in range(subsets)]) + G = alpha * TotalVariation(50, 1e-4, lower=0) + prob = [1/len(A)]*len(A) - spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob) + spdhg = SPDHG(f=F, g=G, operator=A, + max_iteration=1000, + update_objective_interval=200, prob=prob) spdhg.run(1000, verbose=0) qm = (mae(spdhg.get_output(), pdhg.get_output()), - mse(spdhg.get_output(), pdhg.get_output()), - psnr(spdhg.get_output(), pdhg.get_output()) - ) - logging.info ("Quality measures {}".format(qm)) - - np.testing.assert_almost_equal( mae(spdhg.get_output(), pdhg.get_output()), - 0.000335, decimal=3) - np.testing.assert_almost_equal( mse(spdhg.get_output(), pdhg.get_output()), - 5.51141e-06, decimal=3) - + mse(spdhg.get_output(), pdhg.get_output()), + psnr(spdhg.get_output(), pdhg.get_output()) + ) + logging.info("Quality measures {}".format(qm)) + + np.testing.assert_almost_equal(mae(spdhg.get_output(), pdhg.get_output()), + 0.000335, decimal=3) + np.testing.assert_almost_equal(mse(spdhg.get_output(), pdhg.get_output()), + 5.51141e-06, decimal=3) @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_PDHG_explicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128, 128)) ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 - + detectors = ig.shape[0] angles = np.linspace(0, np.pi, 180) - ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) # Select device dev = 'cpu' Aop = ProjectionOperator(ig, ag, dev) - + sin = Aop.direct(data) # Create noisy data. Apply Gaussian noise noises = ['gaussian', 'poisson'] @@ -875,94 +944,99 @@ def test_SPDHG_vs_PDHG_explicit(self): # eta = 0 # noisy_data = AcquisitionData(np.random.poisson( scale * (eta + sin.as_array()))/scale, ag) elif noise == 'gaussian': - noisy_data = noise.gaussian(sin, var=0.1, seed=10) + noisy_data = noise.gaussian(sin, var=0.1, seed=10) else: raise ValueError('Unsupported Noise ', noise) - - #%% 'explicit' SPDHG, scalar step-sizes + + # %% 'explicit' SPDHG, scalar step-sizes subsets = 10 size_of_subsets = int(len(angles)/subsets) # create Gradient operator op1 = GradientOperator(ig) # take angles and create uniform subsets in uniform+sequential setting - list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] + list_angles = [angles[i:i+size_of_subsets] + for i in range(0, len(angles), size_of_subsets)] # create acquisitioin geometries for each the interval of splitting angles - list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i],angle_unit='radian').set_panel(detectors, 0.1) - for i in range(len(list_angles))] + list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i], angle_unit='radian').set_panel(detectors, 0.1) + for i in range(len(list_angles))] # create with operators as many as the subsets - A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) for i in range(subsets)] + [op1]) - ## number of subsets - #(sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) + A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) + for i in range(subsets)] + [op1]) + # number of subsets + # (sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) # - ## acquisisiton data + # acquisisiton data AD_list = [] for sub_num in range(subsets): for i in range(0, len(angles), size_of_subsets): - arr = noisy_data.as_array()[i:i+size_of_subsets,:] - AD_list.append(AcquisitionData(arr, geometry=list_geoms[sub_num])) + arr = noisy_data.as_array()[i:i+size_of_subsets, :] + AD_list.append(AcquisitionData( + arr, geometry=list_geoms[sub_num])) g = BlockDataContainer(*AD_list) alpha = 0.5 - ## block function - F = BlockFunction(*[*[KullbackLeibler(b=g[i]) for i in range(subsets)] + [alpha * MixedL21Norm()]]) + # block function + F = BlockFunction(*[*[KullbackLeibler(b=g[i]) + for i in range(subsets)] + [alpha * MixedL21Norm()]]) G = IndicatorBox(lower=0) prob = [1/(2*subsets)]*(len(A)-1) + [1/2] - spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob) + spdhg = SPDHG(f=F, g=G, operator=A, + max_iteration=1000, + update_objective_interval=200, prob=prob) spdhg.run(1000, verbose=0) - #%% 'explicit' PDHG, scalar step-sizes + # %% 'explicit' PDHG, scalar step-sizes op1 = GradientOperator(ig) op2 = Aop # Create BlockOperator - operator = BlockOperator(op1, op2, shape=(2,1) ) - f2 = KullbackLeibler(b=noisy_data) - g = IndicatorBox(lower=0) + operator = BlockOperator(op1, op2, shape=(2, 1)) + f2 = KullbackLeibler(b=noisy_data) + g = IndicatorBox(lower=0) normK = operator.norm() sigma = 1/normK tau = 1/normK - - f1 = alpha * MixedL21Norm() - f = BlockFunction(f1, f2) + + f1 = alpha * MixedL21Norm() + f = BlockFunction(f1, f2) # Setup and run the PDHG algorithm - pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma) pdhg.max_iteration = 1000 pdhg.update_objective_interval = 200 pdhg.run(1000, verbose=0) - #%% show diff between PDHG and SPDHG + # %% show diff between PDHG and SPDHG # plt.imshow(spdhg.get_output().as_array() -pdhg.get_output().as_array()) # plt.colorbar() # plt.show() qm = (mae(spdhg.get_output(), pdhg.get_output()), - mse(spdhg.get_output(), pdhg.get_output()), - psnr(spdhg.get_output(), pdhg.get_output()) - ) + mse(spdhg.get_output(), pdhg.get_output()), + psnr(spdhg.get_output(), pdhg.get_output()) + ) logging.info("Quality measures {}".format(qm)) - np.testing.assert_almost_equal( mae(spdhg.get_output(), pdhg.get_output()), - 0.00150 , decimal=3) - np.testing.assert_almost_equal( mse(spdhg.get_output(), pdhg.get_output()), - 1.68590e-05, decimal=3) - + np.testing.assert_almost_equal(mae(spdhg.get_output(), pdhg.get_output()), + 0.00150, decimal=3) + np.testing.assert_almost_equal(mse(spdhg.get_output(), pdhg.get_output()), + 1.68590e-05, decimal=3) @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_SPDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128), dtype=numpy.float32) - + data = dataexample.SIMPLE_PHANTOM_2D.get( + size=(128, 128), dtype=numpy.float32) + ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 - + detectors = ig.shape[0] angles = np.linspace(0, np.pi, 180) - ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) dev = 'cpu' Aop = ProjectionOperator(ig, ag, dev) - + sin = Aop.direct(data) # Create noisy data. Apply Gaussian noise noises = ['gaussian', 'poisson'] @@ -972,91 +1046,95 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): scale = 5 eta = 0 noisy_data = AcquisitionData(np.asarray( - np.random.poisson( scale * (eta + sin.as_array()))/scale, - dtype=np.float32 - ), - geometry=ag + np.random.poisson(scale * (eta + sin.as_array()))/scale, + dtype=np.float32 + ), + geometry=ag ) elif noise == 'gaussian': np.random.seed(10) - n1 = np.asarray(np.random.normal(0, 0.1, size = ag.shape), dtype=np.float32) + n1 = np.asarray(np.random.normal( + 0, 0.1, size=ag.shape), dtype=np.float32) noisy_data = AcquisitionData(n1 + sin.as_array(), geometry=ag) - + else: raise ValueError('Unsupported Noise ', noise) - - #%% 'explicit' SPDHG, scalar step-sizes + + # %% 'explicit' SPDHG, scalar step-sizes subsets = 10 size_of_subsets = int(len(angles)/subsets) # create GradientOperator operator op1 = GradientOperator(ig) # take angles and create uniform subsets in uniform+sequential setting - list_angles = [angles[i:i+size_of_subsets] for i in range(0, len(angles), size_of_subsets)] + list_angles = [angles[i:i+size_of_subsets] + for i in range(0, len(angles), size_of_subsets)] # create acquisitioin geometries for each the interval of splitting angles - list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i],angle_unit='radian').set_panel(detectors, 0.1) - for i in range(len(list_angles))] + list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i], angle_unit='radian').set_panel(detectors, 0.1) + for i in range(len(list_angles))] # create with operators as many as the subsets - A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) for i in range(subsets)] + [op1]) - ## number of subsets - #(sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) + A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) + for i in range(subsets)] + [op1]) + # number of subsets + # (sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) # - ## acquisisiton data - ## acquisisiton data + # acquisisiton data + # acquisisiton data AD_list = [] for sub_num in range(subsets): for i in range(0, len(angles), size_of_subsets): - arr = noisy_data.as_array()[i:i+size_of_subsets,:] - AD_list.append(AcquisitionData(arr, geometry=list_geoms[sub_num])) + arr = noisy_data.as_array()[i:i+size_of_subsets, :] + AD_list.append(AcquisitionData( + arr, geometry=list_geoms[sub_num])) - g = BlockDataContainer(*AD_list) + g = BlockDataContainer(*AD_list) alpha = 0.5 - ## block function - F = BlockFunction(*[*[KullbackLeibler(b=g[i]) for i in range(subsets)] + [alpha * MixedL21Norm()]]) + # block function + F = BlockFunction(*[*[KullbackLeibler(b=g[i]) + for i in range(subsets)] + [alpha * MixedL21Norm()]]) G = IndicatorBox(lower=0) prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] - algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob.copy(), use_axpby=True) - ) + algos.append(SPDHG(f=F, g=G, operator=A, + max_iteration=1000, + update_objective_interval=200, prob=prob.copy(), use_axpby=True) + ) algos[0].run(1000, verbose=0) - algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 1000, - update_objective_interval=200, prob = prob.copy(), use_axpby=False) - ) + algos.append(SPDHG(f=F, g=G, operator=A, + max_iteration=1000, + update_objective_interval=200, prob=prob.copy(), use_axpby=False) + ) algos[1].run(1000, verbose=0) - # np.testing.assert_array_almost_equal(algos[0].get_output().as_array(), algos[1].get_output().as_array()) qm = (mae(algos[0].get_output(), algos[1].get_output()), - mse(algos[0].get_output(), algos[1].get_output()), - psnr(algos[0].get_output(), algos[1].get_output()) - ) - logging.info ("Quality measures {}".format(qm)) + mse(algos[0].get_output(), algos[1].get_output()), + psnr(algos[0].get_output(), algos[1].get_output()) + ) + logging.info("Quality measures {}".format(qm)) assert qm[0] < 0.005 assert qm[1] < 3.e-05 - @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_PDHG_vs_PDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128,128)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128, 128)) ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 - + detectors = ig.shape[0] angles = np.linspace(0, np.pi, 180) - ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles,angle_unit='radian').set_panel(detectors, 0.1) - + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) + dev = 'cpu' Aop = ProjectionOperator(ig, ag, dev) - + sin = Aop.direct(data) - + # Create noisy data. Apply Gaussian noise noises = ['gaussian', 'poisson'] noise = noises[1] @@ -1064,53 +1142,53 @@ def test_PDHG_vs_PDHG_explicit_axpby(self): np.random.seed(10) scale = 5 eta = 0 - noisy_data = AcquisitionData(numpy.asarray(np.random.poisson( scale * (eta + sin.as_array())),dtype=numpy.float32)/scale, geometry=ag) + noisy_data = AcquisitionData(numpy.asarray(np.random.poisson( + scale * (eta + sin.as_array())), dtype=numpy.float32)/scale, geometry=ag) elif noise == 'gaussian': np.random.seed(10) - n1 = np.random.normal(0, 0.1, size = ag.shape) - noisy_data = AcquisitionData(numpy.asarray(n1 + sin.as_array(), dtype=numpy.float32), geometry=ag) - + n1 = np.random.normal(0, 0.1, size=ag.shape) + noisy_data = AcquisitionData(numpy.asarray( + n1 + sin.as_array(), dtype=numpy.float32), geometry=ag) + else: raise ValueError('Unsupported Noise ', noise) - - + alpha = 0.5 op1 = GradientOperator(ig) op2 = Aop # Create BlockOperator - operator = BlockOperator(op1, op2, shape=(2,1) ) - f2 = KullbackLeibler(b=noisy_data) - g = IndicatorBox(lower=0) + operator = BlockOperator(op1, op2, shape=(2, 1)) + f2 = KullbackLeibler(b=noisy_data) + g = IndicatorBox(lower=0) normK = operator.norm() sigma = 1./normK tau = 1./normK - - f1 = alpha * MixedL21Norm() - f = BlockFunction(f1, f2) + + f1 = alpha * MixedL21Norm() + f = BlockFunction(f1, f2) # Setup and run the PDHG algorithm - + algos = [] - algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval=200, use_axpby=True) - ) + algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=1000, + update_objective_interval=200, use_axpby=True) + ) algos[0].run(1000, verbose=0) - algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 1000, - update_objective_interval=200, use_axpby=False) - ) + algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=1000, + update_objective_interval=200, use_axpby=False) + ) algos[1].run(1000, verbose=0) - + qm = (mae(algos[0].get_output(), algos[1].get_output()), - mse(algos[0].get_output(), algos[1].get_output()), - psnr(algos[0].get_output(), algos[1].get_output()) - ) - logging.info ("Quality measures {}".format(qm)) - np.testing.assert_array_less( qm[0], 0.005 ) - np.testing.assert_array_less( qm[1], 3e-05) - + mse(algos[0].get_output(), algos[1].get_output()), + psnr(algos[0].get_output(), algos[1].get_output()) + ) + logging.info("Quality measures {}".format(qm)) + np.testing.assert_array_less(qm[0], 0.005) + np.testing.assert_array_less(qm[1], 3e-05) class PrintAlgo(Algorithm): @@ -1119,11 +1197,9 @@ def __init__(self, **kwargs): # self.update_objective() self.configured = True - def update(self): self.x = - self.iteration time.sleep(0.01) - def update_objective(self): self.loss.append(self.iteration * self.iteration) @@ -1131,63 +1207,61 @@ def update_objective(self): class TestPrint(unittest.TestCase): def test_print(self): - def callback (iteration, objective, solution): + def callback(iteration, objective, solution): print("I am being called ", iteration) - algo = PrintAlgo(update_objective_interval = 10, max_iteration = 1000) + algo = PrintAlgo(update_objective_interval=10, max_iteration=1000) - algo.run(20, verbose=2, print_interval = 2) + algo.run(20, verbose=2, print_interval=2) # it 0 - # it 10 + # it 10 # it 20 # --- stop - algo.run(3, verbose=1, print_interval = 2) + algo.run(3, verbose=1, print_interval=2) # it 20 # --- stop - - algo.run(20, verbose=1, print_interval = 7) + + algo.run(20, verbose=1, print_interval=7) # it 20 # it 30 # -- stop - + algo.run(20, verbose=1, very_verbose=False) algo.run(20, verbose=2, print_interval=7, callback=callback) - + logging.info(algo._iteration) logging.info(algo.objective) - np.testing.assert_array_equal([-1, 10, 20, 30, 40, 50, 60, 70, 80], algo.iterations) - np.testing.assert_array_equal([1, 100, 400, 900, 1600, 2500, 3600, 4900, 6400], algo.objective) - + np.testing.assert_array_equal( + [-1, 10, 20, 30, 40, 50, 60, 70, 80], algo.iterations) + np.testing.assert_array_equal( + [1, 100, 400, 900, 1600, 2500, 3600, 4900, 6400], algo.objective) def test_print2(self): - algo = PrintAlgo(update_objective_interval = 4, max_iteration = 1000) + algo = PrintAlgo(update_objective_interval=4, max_iteration=1000) algo.run(10, verbose=2, print_interval=2) - logging.info (algo.iteration) + logging.info(algo.iteration) algo.run(10, verbose=2, print_interval=2) logging.info("{} {}".format(algo._iteration, algo.objective)) - algo = PrintAlgo(update_objective_interval = 4, max_iteration = 1000) + algo = PrintAlgo(update_objective_interval=4, max_iteration=1000) algo.run(20, verbose=2, print_interval=2) - class TestADMM(unittest.TestCase): def setUp(self): - ig = ImageGeometry(2,3,2) + ig = ImageGeometry(2, 3, 2) data = ig.allocate(1, dtype=np.float32) noisy_data = data+1 - + # TV regularisation parameter self.alpha = 1 - - - self.fidelities = [ 0.5 * L2NormSquared(b=noisy_data), L1Norm(b=noisy_data), - KullbackLeibler(b=noisy_data, backend="numpy")] + self.fidelities = [0.5 * L2NormSquared(b=noisy_data), L1Norm(b=noisy_data), + KullbackLeibler(b=noisy_data, backend="numpy")] F = self.alpha * MixedL21Norm() K = GradientOperator(ig) - + # Compute operator Norm normK = K.norm() @@ -1197,44 +1271,40 @@ def setUp(self): self.F = F self.K = K - def test_ADMM_L2(self): self.do_test_with_fidelity(self.fidelities[0]) - def test_ADMM_L1(self): self.do_test_with_fidelity(self.fidelities[1]) - def test_ADMM_KL(self): self.do_test_with_fidelity(self.fidelities[2]) - def do_test_with_fidelity(self, fidelity): alpha = self.alpha # F = BlockFunction(alpha * MixedL21Norm(),fidelity) - + G = fidelity K = self.K F = self.F admm = LADMM(f=G, g=F, operator=K, tau=self.tau, sigma=self.sigma, - max_iteration = 100, update_objective_interval = 10) + max_iteration=100, update_objective_interval=10) admm.run(1, verbose=0) admm_noaxpby = LADMM(f=G, g=F, operator=K, tau=self.tau, sigma=self.sigma, - max_iteration = 100, update_objective_interval = 10, use_axpby=False) + max_iteration=100, update_objective_interval=10, use_axpby=False) admm_noaxpby.run(1, verbose=0) - - np.testing.assert_array_almost_equal(admm.solution.as_array(), admm_noaxpby.solution.as_array()) + np.testing.assert_array_almost_equal( + admm.solution.as_array(), admm_noaxpby.solution.as_array()) def test_compare_with_PDHG(self): - # Load an image from the CIL gallery. - data = dataexample.SHAPES.get(size=(64,64)) - ig = data.geometry + # Load an image from the CIL gallery. + data = dataexample.SHAPES.get(size=(64, 64)) + ig = data.geometry # Add gaussian noise - noisy_data = applynoise.gaussian(data, seed = 10, var = 0.0005) + noisy_data = applynoise.gaussian(data, seed=10, var=0.0005) # TV regularisation parameter alpha = 0.1 @@ -1244,7 +1314,7 @@ def test_compare_with_PDHG(self): fidelity = KullbackLeibler(b=noisy_data, backend="numpy") # Setup and run the PDHG algorithm - F = BlockFunction(alpha * MixedL21Norm(),fidelity) + F = BlockFunction(alpha * MixedL21Norm(), fidelity) G = ZeroFunction() K = BlockOperator(GradientOperator(ig), IdentityOperator(ig)) @@ -1256,14 +1326,14 @@ def test_compare_with_PDHG(self): tau = 1./normK pdhg = PDHG(f=F, g=G, operator=K, tau=tau, sigma=sigma, - max_iteration = 500, update_objective_interval = 10) + max_iteration=500, update_objective_interval=10) pdhg.run(verbose=0) sigma = 1 tau = sigma/normK**2 admm = LADMM(f=G, g=F, operator=K, tau=tau, sigma=sigma, - max_iteration = 500, update_objective_interval = 10) + max_iteration=500, update_objective_interval=10) admm.run(verbose=0) - np.testing.assert_almost_equal(admm.solution.array, pdhg.solution.array, decimal=3) - + np.testing.assert_almost_equal( + admm.solution.array, pdhg.solution.array, decimal=3) From b28f2f1ecce5dcd2554db5d340964fb009b42513 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 22 Sep 2023 14:19:51 +0000 Subject: [PATCH 025/115] Notes after discussions with gemma --- .../cil/optimisation/algorithms/SPDHG.py | 38 +++++---- Wrappers/Python/test/test_algorithms.py | 77 +++++++++++++------ 2 files changed, 77 insertions(+), 38 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 4a30d9eac0..794e29ca6a 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -49,8 +49,7 @@ class SPDHG(Algorithm): List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets + gamma : float parameter controlling the trade-off between the primal and dual step sizes sampler: instance of the Sampler class @@ -58,6 +57,9 @@ class SPDHG(Algorithm): **kwargs: norms : list of floats precalculated list of norms of the operators + prob : list of floats, optional, default=None + List of probabilities. If None each subset will have probability = 1/number of subsets + rho #TODO: - maybe in the set sigma and tau? Example ------- @@ -96,7 +98,7 @@ class SPDHG(Algorithm): ''' def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, gamma=1., sampler=None, **kwargs): + initial=None, gamma=1., sampler=None, **kwargs): super(SPDHG, self).__init__(**kwargs) @@ -108,7 +110,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, if f is not None and operator is not None and g is not None: self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - initial=initial, gamma=gamma, sampler=sampler, norms=kwargs.get('norms', None)) + initial=initial, gamma=gamma, sampler=sampler, rho=kwargs.get('rho', .99),norms=kwargs.get('norms', None)) @property def norms(self): @@ -126,8 +128,8 @@ def set_norms(self, norms=None): norms = [self.operator.get_item(i, 0).norm() for i in range(self.ndual_subsets)] else: - for i in range(len(norms)): - if isinstance(norms[i], Number): + for i in range(len(norms)): # TODO: length should be self.ndual_subsets + if isinstance(norms[i], Number): #TODO: shouldn't be passing if it is not a number if norms[i] <= 0: raise ValueError( "The norms of the operators should be positive, passed norm= {}".format(norms[i])) @@ -141,7 +143,7 @@ def sampler(self): def prob_weights(self): return self._prob_weights - def set_sampler(self, sampler=None): + def set_sampler(self, sampler=None): #TODO: do want to keep this? THink about what should be reset based on this """ Sets the sampler for the SPDHG algorithm. Parameters @@ -249,7 +251,12 @@ def set_tau(self, tau=None): si in zip(self._prob_weights, self._norms, self._sigma)]) self._tau *= (self.rho / self.gamma) - def reset_default_step_sizes(self): + def set_step_sizes_from_ratio(gamma=1, rho=0.99): #TODO: + pass + def set_step_sizes_custom(sigma=None, tau=None): #TODO: + pass + + def set_step_sizes_default(self): #TODO: Pass gamma, sigma, rho, tau to one function? """ Sets default sigma and tau step-sizes for the SPDHG algorithm. This should be re-run after changing the sampler, norms, gamma or prob_weights. Note @@ -266,6 +273,7 @@ def reset_default_step_sizes(self): def check_convergence(self): # TODO: check this with someone else + #TODO: Don't think this is working just at the moment """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma Returns @@ -286,7 +294,7 @@ def check_convergence(self): return False def set_up(self, f, g, operator, tau=None, sigma=None, - initial=None, gamma=1., sampler=None, norms=None): + initial=None, gamma=1., sampler=None, norms=None, rho=.99): '''set-up of the algorithm Parameters ---------- @@ -308,7 +316,11 @@ def set_up(self, f, g, operator, tau=None, sigma=None, Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. **kwargs: norms : list of floats - precalculated list of norms of the operators + precalculated list of norms of the operators #TODO: call it precalculated norms and add to argument list + rho : list of floats #TODO: Add to sigma and tau + + + ''' logging.info("{} setting up".format(self.__class__.__name__, )) @@ -317,13 +329,13 @@ def set_up(self, f, g, operator, tau=None, sigma=None, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - self.rho = .99 + self.rho = rho self.set_sampler(sampler) self.set_gamma(gamma) - self.set_norms(norms) - self.set_sigma(sigma) + self.set_norms(norms) #passed or calculated by constructor + self.set_sigma(sigma) #might not want to do this until it is called (if computationally expensive) self.set_tau(tau) # initialize primal variable diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 64f8df43a4..ac5bdc75eb 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -751,11 +751,10 @@ def test_SIRT_remove_nan_or_inf_with_BlockDataContainer(self): class TestSPDHG(CCPiTestClass): - - def test_SPDHG_defaults_and_setters(self): + def setUp(self): data = dataexample.SIMPLE_PHANTOM_2D.get(size=(20, 20)) - subsets = 10 + self.subsets = 10 ig = data.geometry ig.voxel_size_x = 0.1 @@ -771,48 +770,76 @@ def test_SPDHG_defaults_and_setters(self): Aop = ProjectionOperator(ig, ag, dev) sin = Aop.direct(data) - partitioned_data = sin.partition(subsets, 'sequential') - A = BlockOperator( - *[IdentityOperator(partitioned_data[i].geometry) for i in range(subsets)]) + partitioned_data = sin.partition(self.subsets, 'sequential') + self.A = BlockOperator( + *[IdentityOperator(partitioned_data[i].geometry) for i in range(self.subsets)]) # block function - F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) - for i in range(subsets)]) + self.F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) + for i in range(self.subsets)]) alpha = 0.025 - G = alpha * FGP_TV() - spdhg = SPDHG(f=F, g=G, operator=A) + self.G = alpha * FGP_TV() + + def test_SPDHG_defaults_and_setters(self): + + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) self.assertEqual(spdhg.gamma, 1.) self.assertEqual(spdhg.rho, .99) - self.assertListEqual(spdhg.norms, [A.get_item(i, 0).norm() - for i in range(subsets)]) - self.assertListEqual(spdhg.prob_weights, [1/subsets] * subsets) + self.assertListEqual(spdhg.norms, [self.A.get_item(i, 0).norm() + for i in range(self.subsets)]) + self.assertListEqual(spdhg.prob_weights, [1/self.subsets] * self.subsets) self.assertTrue(isinstance(spdhg.sampler, Sampler)) self.assertListEqual(spdhg.sigma, [spdhg.gamma * spdhg.rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(spdhg.rho / spdhg.gamma)) - self.assertNumpyArrayEqual(spdhg.x.array, A.domain_geometry().allocate(0).array) + self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(0).array) self.assertEqual(spdhg.max_iteration, 0) self.assertEqual(spdhg.update_objective_interval, 1) - spdhg.set_norms([1]*subsets) - spdhg.set_sampler(Sampler.randomWithReplacement(10, list(range(1,11)/55))) + spdhg.set_norms([1]*self.subsets) + spdhg.set_sampler(Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.))) spdhg.set_gamma(10) - spdhg.reset_default_step_sizes(self) + spdhg.reset_default_step_sizes() - #TODO: Test these changes - spdhg.set_sigma([1]*subsets) + self.assertEqual(spdhg.gamma, 10) + self.assertEqual(spdhg.rho, .99) + self.assertListEqual(spdhg.norms, [1]*self.subsets) + self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) + self.assertTrue(isinstance(spdhg.sampler, Sampler)) + self.assertListEqual(spdhg.sigma, [spdhg.gamma * spdhg.rho / ni for ni in spdhg.norms]) + self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(spdhg.rho / spdhg.gamma)) + + + spdhg.set_sigma([1]*self.subsets) spdhg.set_tau(100) - #TODO: Test again + self.assertListEqual(spdhg.sigma, [1]*self.subsets) + self.assertEqual(spdhg.tau, 100) + def test_spdhg_non_default_init(self): - #TODO:: Test again - pass + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, gamma=10, rho=.45, norms=[1]*self.subsets, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), + sigma=[1]*self.subsets, tau=100, initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + self.assertEqual(spdhg.gamma, 10) + self.assertEqual(spdhg.rho, .45) + self.assertListEqual(spdhg.norms, [1]*self.subsets) + self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) + self.assertTrue(isinstance(spdhg.sampler, Sampler)) + self.assertListEqual(spdhg.sigma, [1]*self.subsets) + self.assertEqual(spdhg.tau, 100) + self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) + self.assertEqual(spdhg.max_iteration, 1000) + self.assertEqual(spdhg.update_objective_interval, 10) def test_spdhg_check_convergence(self): - #TODO:checkconvergence - pass - + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, gamma=10, rho=.45, norms=[1]*self.subsets, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), + sigma=[1]*self.subsets, tau=10, initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + + self.assertFalse(spdhg.check_convergence()) + spdhg.reset_default_step_sizes() + self.assertTrue(spdhg.check_convergence()) + @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): From 4a87f4891520b0a8ad388d1c6e5a29393321413c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 25 Sep 2023 13:47:43 +0000 Subject: [PATCH 026/115] Changes after discussion with gemma --- .../cil/optimisation/algorithms/SPDHG.py | 275 +++++++++--------- Wrappers/Python/test/test_algorithms.py | 82 ++++-- 2 files changed, 185 insertions(+), 172 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 794e29ca6a..52408fb6e8 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -54,13 +54,14 @@ class SPDHG(Algorithm): parameter controlling the trade-off between the primal and dual step sizes sampler: instance of the Sampler class Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets - **kwargs: - norms : list of floats + precalculated_norms : list of floats precalculated list of norms of the operators + **kwargs: + prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets - rho #TODO: - maybe in the set sigma and tau? - + List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ + norms : list of floats + precalculated list of norms of the operators. To be deprecated - replaced by precalculated_norms Example ------- @@ -97,179 +98,131 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, gamma=1., sampler=None, **kwargs): + def __init__(self, f=None, g=None, operator=None, + initial=None, precalculated_norms=None, sampler=None, **kwargs): super(SPDHG, self).__init__(**kwargs) - self._prob_weights = kwargs.get('prob', None) - - if self._prob_weights is not None: + self.prob_weights = kwargs.get('prob', None) + if kwargs.get('norms', None) is not None: + warnings.warn('norms is being deprecated, pass instead precalculated_norms=your_custom_norms') + if precalculated_norms is None: + precalculated_norms=kwargs.get('norms', None) + + if self.prob_weights is not None: warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)".\ If you have passed both prob and a sampler then prob will be') if f is not None and operator is not None and g is not None: - self.set_up(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - initial=initial, gamma=gamma, sampler=sampler, rho=kwargs.get('rho', .99),norms=kwargs.get('norms', None)) + self.set_up(f=f, g=g, operator=operator, + initial=initial, sampler=sampler,precalculated_norms=precalculated_norms) - @property - def norms(self): - return self._norms - def set_norms(self, norms=None): - """Sets the operator norms for the step-size calculations for the SPDHG algorithm - Parameters - ---------- - norms : list of floats - precalculated list of norms of the operators""" - if norms is None: - # Compute norm of each sub-operator - norms = [self.operator.get_item(i, 0).norm() - for i in range(self.ndual_subsets)] - else: - for i in range(len(norms)): # TODO: length should be self.ndual_subsets - if isinstance(norms[i], Number): #TODO: shouldn't be passing if it is not a number - if norms[i] <= 0: - raise ValueError( - "The norms of the operators should be positive, passed norm= {}".format(norms[i])) - - self._norms = norms - - @property - def sampler(self): - return self._sampler - @property - def prob_weights(self): - return self._prob_weights - def set_sampler(self, sampler=None): #TODO: do want to keep this? THink about what should be reset based on this - """ Sets the sampler for the SPDHG algorithm. - - Parameters - ---------- - sampler: instance of the Sampler class - Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. - """ - if sampler is None: - if self._prob_weights is None: - self._prob_weights = [1/self.ndual_subsets] * self.ndual_subsets - self._sampler = Sampler.randomWithReplacement( - self.ndual_subsets, prob=self._prob_weights) - else: - if not isinstance(sampler, Sampler): - raise ValueError( - "The sampler should be an instance of the CIL Sampler class") - self._sampler = sampler - if sampler.prob is None: - self._prob_weights=[1/self.ndual_subsets] * self.ndual_subsets - else: - self._prob_weights=sampler.prob + @property + def sigma(self): + return self._sigma - - - @property - def gamma(self): - return self._gamma - - def set_gamma(self, gamma=1.): + def tau(self): + return self._tau + + def set_step_sizes_from_ratio(self, gamma=1., rho=.99): """ Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. Parameters ---------- gamma : float parameter controlling the trade-off between the primal and dual step sizes - + rho : float + parameter controlling the size of the product :math: \sigma\tau :math: """ if isinstance(gamma, Number): if gamma <= 0: raise ValueError( "The step-sizes of SPDHG are positive, gamma should also be positive") - self._gamma = gamma + else: raise ValueError( "We currently only support scalar values of gamma") + if isinstance(rho, Number): + if rho <= 0: + raise ValueError( + "The step-sizes of SPDHG are positive, gamma should also be positive") - @property - def sigma(self): - return self._sigma + + else: + raise ValueError( + "We currently only support scalar values of gamma") + + self._sigma = [gamma * rho / ni for ni in self.norms] + + self._tau = min([pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)]) + self._tau *= (rho / gamma) + + + - def set_sigma(self, sigma=None): + def set_step_sizes_custom(self, sigma=None, tau=None): """ Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. Parameters ---------- sigma : list of positive float, optional, default=None List of Step size parameters for Dual problem + tau : positive float, optional, default=None + Step size parameter for Primal problem - The user can set these or default values are calculated. Values passed by the user will be accepted as long as they are positive numbers, - or correct shape array like objects. + The user can set these or default values are calculated, either sigma, tau, both or None can be passed. """ + gamma=1. + rho=.99 if sigma is not None: - for i in range(len(sigma)): - if isinstance(sigma[i], Number): - if sigma[i] <= 0: - raise ValueError( - "The step-sizes of SPDHG are positive, passed sigma = {}".format(sigma[i])) - if len(sigma) != self.operator.range_geometry().shape[0]: - raise ValueError(" The shape of sigma = {0} is not the same as the shape of the range_geometry = {1}".format( - len(sigma), self.operator.range_geometry().shape[0])) + if len(sigma==self.ndual_subsets): + if all(isinstance(x, Number) for x in sigma): + if all(x > 0 for x in sigma): + pass + else: + raise ValueError( + "The values of sigma should be positive") + else: + raise ValueError( + "The values of sigma should be a Number") + else: + raise ValueError( + "Please pass a list of floats to sigma with the same number of entries as number of operators") self._sigma = sigma - elif sigma is None: - self._sigma = [self._gamma * self.rho / ni for ni in self._norms] - - @property - def tau(self): - return self._tau - - def set_tau(self, tau=None): - """ Sets tau step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. - - Parameters - ---------- - tau : positive :obj:`float`, or `np.ndarray`, `DataContainer`, `BlockDataContainer`, optional, default=None - Step size for the primal problem. + elif tau is None: + self._sigma = [gamma * rho / ni for ni in self.norms] + else: + self._sigma= [gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] - The user can set either set these or instead the defaults are selected instead. Values passed by the user will be accepted as long as they are positive numbers, - or correct shape array like objects. - """ - if tau is not None: + if tau is None: + self._tau = min([pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)]) + self._tau *= (rho / gamma) + else: if isinstance(tau, Number): if tau <= 0: raise ValueError( "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) - elif tau.shape != self.operator.domain_geometry().shape: - raise ValueError(" The shape of tau = {0} is not the same as the shape of the domain_geometry = {1}".format( - tau.shape, self.operator.domain_geometry().shape)) - self._tau = tau - if tau is None: - self._tau = min([pi / (si * ni**2) for pi, ni, - si in zip(self._prob_weights, self._norms, self._sigma)]) - self._tau *= (self.rho / self.gamma) + else: + raise ValueError( + "The value of tau should be a Number") + self._tau=tau - def set_step_sizes_from_ratio(gamma=1, rho=0.99): #TODO: - pass - def set_step_sizes_custom(sigma=None, tau=None): #TODO: - pass + - def set_step_sizes_default(self): #TODO: Pass gamma, sigma, rho, tau to one function? - """ Sets default sigma and tau step-sizes for the SPDHG algorithm. This should be re-run after changing the sampler, norms, gamma or prob_weights. - Note - ---- - tau : positive float, optional, default=None - Step size parameter for Primal problem - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem + - """ - self.set_sigma() - self.set_tau() + def check_convergence(self): # TODO: check this with someone else @@ -283,7 +236,7 @@ def check_convergence(self): """ for i in range(len(self._sigma)): if isinstance(self.tau, Number) and isinstance(self._sigma[i], Number): - if self._sigma[i] * self._tau * self._norms[i]**2 > self._prob_weights[i]**2: + if self._sigma[i] * self._tau * self.norms[i]**2 > self.prob_weights[i]: warnings.warn( "Convergence criterion of SPDHG for scalar step-sizes is not satisfied.") return False @@ -293,8 +246,8 @@ def check_convergence(self): "Convergence criterion currently can only be checked for scalar values of tau.") return False - def set_up(self, f, g, operator, tau=None, sigma=None, - initial=None, gamma=1., sampler=None, norms=None, rho=.99): + def set_up(self, f, g, operator, + initial=None, sampler=None, precalculated_norms=None): '''set-up of the algorithm Parameters ---------- @@ -314,10 +267,11 @@ def set_up(self, f, g, operator, tau=None, sigma=None, parameter controlling the trade-off between the primal and dual step sizes sampler: instance of the Sampler class Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. - **kwargs: - norms : list of floats - precalculated list of norms of the operators #TODO: call it precalculated norms and add to argument list - rho : list of floats #TODO: Add to sigma and tau + precalculated_norms : list of floats + precalculated list of norms of the operators + + + @@ -329,14 +283,51 @@ def set_up(self, f, g, operator, tau=None, sigma=None, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - self.rho = rho + + + + if precalculated_norms is None: + # Compute norm of each sub-operator + self.norms = [self.operator.get_item(i, 0).norm() + for i in range(self.ndual_subsets)] + else: + if len(precalculated_norms==self.ndual_subsets): + if all(isinstance(x, Number) for x in precalculated_norms): + if all(x > 0 for x in precalculated_norms): + pass + else: + raise ValueError( + "The norms of the operators should be positive") + else: + raise ValueError( + "The norms of the operators should be a Number") + else: + raise ValueError( + "Please pass a list of floats to the precalculated norms with the same number of entries as number of operators") + self.norms=precalculated_norms + - - self.set_sampler(sampler) - self.set_gamma(gamma) - self.set_norms(norms) #passed or calculated by constructor - self.set_sigma(sigma) #might not want to do this until it is called (if computationally expensive) - self.set_tau(tau) + if sampler is None: + if self.prob_weights is None: + self.prob_weights = [1/self.ndual_subsets] * self.ndual_subsets + self.sampler = Sampler.randomWithReplacement( + self.ndual_subsets, prob=self.prob_weights) + else: + if not isinstance(sampler, Sampler): + raise ValueError( + "The sampler should be an instance of the CIL Sampler class") + self.sampler = sampler + if sampler.prob is None: + self.prob_weights=[1/self.ndual_subsets] * self.ndual_subsets + else: + self.prob_weights=sampler.prob + + + + + + self.set_step_sizes_custom() #might not want to do this until it is called (if computationally expensive) + # initialize primal variable if initial is None: @@ -365,7 +356,7 @@ def update(self): self.g.proximal(self.x_tmp, self._tau, out=self.x) # Choose subset - i = self._sampler.next() + i = self.sampler.next() # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x @@ -388,7 +379,7 @@ def update(self): # zbar = z + (theta/p[i]) * x_tmp self.z.sapyb(1., self.x_tmp, self.theta / - self._prob_weights[i], out=self.zbar) + self.prob_weights[i], out=self.zbar) # save previous iteration self.save_previous_iteration(i, y_k) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index ac5bdc75eb..5c8cf008f7 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -781,65 +781,87 @@ def setUp(self): self.G = alpha * FGP_TV() def test_SPDHG_defaults_and_setters(self): - + gamma=1. + rho=.99 spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) - self.assertEqual(spdhg.gamma, 1.) - self.assertEqual(spdhg.rho, .99) + self.assertListEqual(spdhg.norms, [self.A.get_item(i, 0).norm() for i in range(self.subsets)]) self.assertListEqual(spdhg.prob_weights, [1/self.subsets] * self.subsets) self.assertTrue(isinstance(spdhg.sampler, Sampler)) - self.assertListEqual(spdhg.sigma, [spdhg.gamma * spdhg.rho / ni for ni in spdhg.norms]) + self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(spdhg.rho / spdhg.gamma)) + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(0).array) self.assertEqual(spdhg.max_iteration, 0) self.assertEqual(spdhg.update_objective_interval, 1) - spdhg.set_norms([1]*self.subsets) - spdhg.set_sampler(Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.))) - spdhg.set_gamma(10) - spdhg.reset_default_step_sizes() - - self.assertEqual(spdhg.gamma, 10) - self.assertEqual(spdhg.rho, .99) - self.assertListEqual(spdhg.norms, [1]*self.subsets) - self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) - self.assertTrue(isinstance(spdhg.sampler, Sampler)) - self.assertListEqual(spdhg.sigma, [spdhg.gamma * spdhg.rho / ni for ni in spdhg.norms]) + + + gamma=3.7 + rho=5.6 + self.set_step_sizes_from_ratio(gamma,rho) + self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(spdhg.rho / spdhg.gamma)) + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - - spdhg.set_sigma([1]*self.subsets) - spdhg.set_tau(100) + + spdhg.set_step_sizes_custom() + self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) + self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) + + spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=100) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, 100) + spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=None) + self.assertListEqual(spdhg.sigma, [1]*self.subsets) + self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) + + spdhg.set_step_sizes_custom(sigma=None, tau=100) + self.assertListEqual(spdhg.sigma, [gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg.norms, spdhg.prob_weights)] ) + self.assertEqual(spdhg.tau, 100) + def test_spdhg_non_default_init(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, gamma=10, rho=.45, norms=[1]*self.subsets, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), - sigma=[1]*self.subsets, tau=100, initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) - self.assertEqual(spdhg.gamma, 10) - self.assertEqual(spdhg.rho, .45) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10, precalculated_norms=[5]*self.subsets ) + self.assertListEqual(spdhg.norms, [1]*self.subsets) self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) self.assertTrue(isinstance(spdhg.sampler, Sampler)) - self.assertListEqual(spdhg.sigma, [1]*self.subsets) - self.assertEqual(spdhg.tau, 100) self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) self.assertEqual(spdhg.max_iteration, 1000) self.assertEqual(spdhg.update_objective_interval, 10) def test_spdhg_check_convergence(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, gamma=10, rho=.45, norms=[1]*self.subsets, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), - sigma=[1]*self.subsets, tau=10, initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) - self.assertFalse(spdhg.check_convergence()) - spdhg.reset_default_step_sizes() self.assertTrue(spdhg.check_convergence()) + gamma=3.7 + rho=0.9 + self.set_step_sizes_from_ratio(gamma,rho) + self.assertTrue(spdhg.check_convergence()) + + gamma=3.7 + rho=100 + self.set_step_sizes_from_ratio(gamma,rho) + self.assertFalse(spdhg.check_convergence()) + + + + spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=100) + self.assertFalse(spdhg.check_convergence()) + + spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=None) + self.assertTrue(spdhg.check_convergence()) + + spdhg.set_step_sizes_custom(sigma=None, tau=100) + self.assertTrue(spdhg.check_convergence()) @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): From b35222f2d6da3081e5ecb9b63ce692d61d160b4d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 25 Sep 2023 14:51:29 +0000 Subject: [PATCH 027/115] Updated tests --- .../Python/cil/optimisation/algorithms/SPDHG.py | 4 ++-- Wrappers/Python/test/test_algorithms.py | 16 ++++++++-------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 52408fb6e8..1bf77834ea 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -182,7 +182,7 @@ def set_step_sizes_custom(self, sigma=None, tau=None): gamma=1. rho=.99 if sigma is not None: - if len(sigma==self.ndual_subsets): + if len(sigma)==self.ndual_subsets: if all(isinstance(x, Number) for x in sigma): if all(x > 0 for x in sigma): pass @@ -291,7 +291,7 @@ def set_up(self, f, g, operator, self.norms = [self.operator.get_item(i, 0).norm() for i in range(self.ndual_subsets)] else: - if len(precalculated_norms==self.ndual_subsets): + if len(precalculated_norms)==self.ndual_subsets: if all(isinstance(x, Number) for x in precalculated_norms): if all(x > 0 for x in precalculated_norms): pass diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 5c8cf008f7..c93eabce07 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -799,14 +799,16 @@ def test_SPDHG_defaults_and_setters(self): + gamma=3.7 rho=5.6 - self.set_step_sizes_from_ratio(gamma,rho) + spdhg.set_step_sizes_from_ratio(gamma,rho) self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - + gamma=1. + rho=.99 spdhg.set_step_sizes_custom() self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, @@ -818,7 +820,7 @@ def test_SPDHG_defaults_and_setters(self): spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=None) self.assertListEqual(spdhg.sigma, [1]*self.subsets) - self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, + self.assertEqual(spdhg.tau, min([(pi / (si * ni**2))*(rho / gamma) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) spdhg.set_step_sizes_custom(sigma=None, tau=100) @@ -828,7 +830,7 @@ def test_SPDHG_defaults_and_setters(self): def test_spdhg_non_default_init(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10, precalculated_norms=[5]*self.subsets ) + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10, precalculated_norms=[1]*self.subsets ) self.assertListEqual(spdhg.norms, [1]*self.subsets) self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) @@ -844,15 +846,13 @@ def test_spdhg_check_convergence(self): gamma=3.7 rho=0.9 - self.set_step_sizes_from_ratio(gamma,rho) + spdhg.set_step_sizes_from_ratio(gamma,rho) self.assertTrue(spdhg.check_convergence()) gamma=3.7 rho=100 - self.set_step_sizes_from_ratio(gamma,rho) + spdhg.set_step_sizes_from_ratio(gamma,rho) self.assertFalse(spdhg.check_convergence()) - - spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=100) self.assertFalse(spdhg.check_convergence()) From 6e552affbba6eddd25655b37533127676e474621 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 25 Sep 2023 14:53:46 +0000 Subject: [PATCH 028/115] Just a commenting change --- .../cil/optimisation/algorithms/SPDHG.py | 93 +++++++------------ 1 file changed, 32 insertions(+), 61 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 1bf77834ea..62ba0675ad 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -49,7 +49,7 @@ class SPDHG(Algorithm): List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - + gamma : float parameter controlling the trade-off between the primal and dual step sizes sampler: instance of the Sampler class @@ -57,7 +57,7 @@ class SPDHG(Algorithm): precalculated_norms : list of floats precalculated list of norms of the operators **kwargs: - + prob : list of floats, optional, default=None List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ norms : list of floats @@ -105,9 +105,10 @@ def __init__(self, f=None, g=None, operator=None, self.prob_weights = kwargs.get('prob', None) if kwargs.get('norms', None) is not None: - warnings.warn('norms is being deprecated, pass instead precalculated_norms=your_custom_norms') + warnings.warn( + 'norms is being deprecated, pass instead precalculated_norms=your_custom_norms') if precalculated_norms is None: - precalculated_norms=kwargs.get('norms', None) + precalculated_norms = kwargs.get('norms', None) if self.prob_weights is not None: warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)".\ @@ -115,21 +116,17 @@ def __init__(self, f=None, g=None, operator=None, if f is not None and operator is not None and g is not None: self.set_up(f=f, g=g, operator=operator, - initial=initial, sampler=sampler,precalculated_norms=precalculated_norms) - - - - + initial=initial, sampler=sampler, precalculated_norms=precalculated_norms) @property def sigma(self): return self._sigma - + @property def tau(self): return self._tau - - def set_step_sizes_from_ratio(self, gamma=1., rho=.99): + + def set_step_sizes_from_ratio(self, gamma=1., rho=.99): """ Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. Parameters @@ -144,7 +141,6 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): raise ValueError( "The step-sizes of SPDHG are positive, gamma should also be positive") - else: raise ValueError( "We currently only support scalar values of gamma") @@ -153,7 +149,6 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): raise ValueError( "The step-sizes of SPDHG are positive, gamma should also be positive") - else: raise ValueError( "We currently only support scalar values of gamma") @@ -161,13 +156,10 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): self._sigma = [gamma * rho / ni for ni in self.norms] self._tau = min([pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)]) + si in zip(self.prob_weights, self.norms, self._sigma)]) self._tau *= (rho / gamma) - - - - def set_step_sizes_custom(self, sigma=None, tau=None): + def set_step_sizes_custom(self, sigma=None, tau=None): """ Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. Parameters @@ -179,28 +171,29 @@ def set_step_sizes_custom(self, sigma=None, tau=None): The user can set these or default values are calculated, either sigma, tau, both or None can be passed. """ - gamma=1. - rho=.99 + gamma = 1. + rho = .99 if sigma is not None: - if len(sigma)==self.ndual_subsets: + if len(sigma) == self.ndual_subsets: if all(isinstance(x, Number) for x in sigma): if all(x > 0 for x in sigma): pass else: - raise ValueError( + raise ValueError( "The values of sigma should be positive") else: raise ValueError( - "The values of sigma should be a Number") + "The values of sigma should be a Number") else: raise ValueError( - "Please pass a list of floats to sigma with the same number of entries as number of operators") + "Please pass a list of floats to sigma with the same number of entries as number of operators") self._sigma = sigma elif tau is None: self._sigma = [gamma * rho / ni for ni in self.norms] else: - self._sigma= [gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] + self._sigma = [ + gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] if tau is None: self._tau = min([pi / (si * ni**2) for pi, ni, @@ -213,20 +206,11 @@ def set_step_sizes_custom(self, sigma=None, tau=None): "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) else: raise ValueError( - "The value of tau should be a Number") - self._tau=tau - - - - - - - - + "The value of tau should be a Number") + self._tau = tau def check_convergence(self): # TODO: check this with someone else - #TODO: Don't think this is working just at the moment """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma Returns @@ -246,7 +230,7 @@ def check_convergence(self): "Convergence criterion currently can only be checked for scalar values of tau.") return False - def set_up(self, f, g, operator, + def set_up(self, f, g, operator, initial=None, sampler=None, precalculated_norms=None): '''set-up of the algorithm Parameters @@ -269,12 +253,6 @@ def set_up(self, f, g, operator, Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. precalculated_norms : list of floats precalculated list of norms of the operators - - - - - - ''' logging.info("{} setting up".format(self.__class__.__name__, )) @@ -283,29 +261,26 @@ def set_up(self, f, g, operator, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - - if precalculated_norms is None: # Compute norm of each sub-operator self.norms = [self.operator.get_item(i, 0).norm() - for i in range(self.ndual_subsets)] + for i in range(self.ndual_subsets)] else: - if len(precalculated_norms)==self.ndual_subsets: + if len(precalculated_norms) == self.ndual_subsets: if all(isinstance(x, Number) for x in precalculated_norms): if all(x > 0 for x in precalculated_norms): pass else: - raise ValueError( + raise ValueError( "The norms of the operators should be positive") else: raise ValueError( - "The norms of the operators should be a Number") + "The norms of the operators should be a Number") else: raise ValueError( - "Please pass a list of floats to the precalculated norms with the same number of entries as number of operators") - self.norms=precalculated_norms - + "Please pass a list of floats to the precalculated norms with the same number of entries as number of operators") + self.norms = precalculated_norms if sampler is None: if self.prob_weights is None: @@ -318,16 +293,12 @@ def set_up(self, f, g, operator, "The sampler should be an instance of the CIL Sampler class") self.sampler = sampler if sampler.prob is None: - self.prob_weights=[1/self.ndual_subsets] * self.ndual_subsets + self.prob_weights = [1/self.ndual_subsets] * self.ndual_subsets else: - self.prob_weights=sampler.prob - - - + self.prob_weights = sampler.prob - - self.set_step_sizes_custom() #might not want to do this until it is called (if computationally expensive) - + # might not want to do this until it is called (if computationally expensive) + self.set_step_sizes_custom() # initialize primal variable if initial is None: From 6575af60892c28ccb4d378d9f6c4da45760aa738 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 28 Sep 2023 16:23:58 +0000 Subject: [PATCH 029/115] Initial changes and tests- currently failing tests --- .../optimisation/operators/BlockOperator.py | 52 +++++++++++------ Wrappers/Python/test/test_BlockOperator.py | 58 ++++++++++++++++++- 2 files changed, 92 insertions(+), 18 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 79d4851059..f1374516fe 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -19,6 +19,7 @@ import numpy import functools +from numbers import Number from cil.framework import ImageData, BlockDataContainer, DataContainer from cil.optimisation.operators import Operator, LinearOperator from cil.framework import BlockGeometry @@ -135,26 +136,43 @@ def get_item(self, row, col): index = row*self.shape[1]+col return self.operators[index] - def norm(self, **kwargs): - '''Returns the norm of the BlockOperator - - if the operator in the block do not have method norm defined, i.e. they are SIRF - AcquisitionModel's we use PowerMethod if applicable, otherwise we raise an Error + def norm(self): + '''Returns the square root of the sum of the norms of the individual operators in the BlockOperators + ''' + return numpy.sqrt(numpy.sum(numpy.array(self.norms())**2)) + + def norms(self, ): + '''Returns a list of the individual norms of the Operators in the BlockOperator ''' - norm = [] + norms= [] for op in self.operators: - if hasattr(op, 'norm'): - norm.append(op.norm(**kwargs) ** 2.) - else: - # use Power method - if op.is_linear(): - norm.append( - LinearOperator.PowerMethod(op, 20)[0] - ) - else: - raise TypeError('Operator {} does not have a norm method and is not linear'.format(op)) - return numpy.sqrt(sum(norm)) + try: + norms.append(op.norm()) + except: + raise TypeError('Operator {} does not have a norm method'.format(op)) + return norms + def set_norms(self, norms): + '''Uses the set_norm() function in Operator to set the norms of the operators in the BlockOperator from a list of custom values. + + + ''' + if len(norms)==len(self.operators): + if all(isinstance(i, Number) for i in norms): + if all( i>=0 for i in norms ): + pass + else: + raise ValueError("Each number in the list should be positive") + else: + raise ValueError("Each element in the list of norms should be a number") + else: + raise ValueError("The length of the list of norms should be equal to the number of operators in the BlockOperator") + + for i,value in enumerate(norms): + self.operators[i].set_norm(value) + + + def direct(self, x, out=None): '''Direct operation for the BlockOperator diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index 3e81ab4cad..5d59e20969 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -20,7 +20,7 @@ import unittest from utils import initialise_tests import logging -from cil.optimisation.operators import BlockOperator +from cil.optimisation.operators import BlockOperator, GradientOperator from cil.framework import BlockDataContainer from cil.optimisation.operators import IdentityOperator from cil.framework import ImageGeometry, ImageData @@ -30,6 +30,62 @@ initialise_tests() class TestBlockOperator(unittest.TestCase): + def test_norms(self): + numpy.random.seed(1) + N, M = 200, 300 + + ig = ImageGeometry(N, M) + G = GradientOperator(ig) + G.norm() + A=BlockOperator(G,G) + + + #calculates norm + self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) + self.assertAlmostEqual(A.norms()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) + + + #sets_norm + A.set_norms([2,3]) + #gets cached norm + self.assertAlmostEqual(A.norms()[0], 2, 2) + self.assertAlmostEqual(A.norms()[1], 3, 2) + self.assertEqual(A.norm(), numpy.sqrt(13)) + + + #Check that it changes the underlying operators + self.assertEqual(A.operators[0]._norm, 2) + self.assertEqual(A.operators[1]._norm, 3) + + #sets cache to None + A.set_norms([None, None]) + #recalculates norm + self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) + self.assertAlmostEqual(A.norms()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) + + #Check the warnings on set_norms + try: + A.set_norms([1]) + except ValueError: + pass + else: + self.assertTrue(False) + try: + A.set_norms(['Banana', 'Apple']) + except ValueError: + pass + else: + self.assertTrue(False) + try: + A.set_norms([-1,-3]) + except ValueError: + pass + else: + self.assertTrue(False) + + def test_BlockOperator(self): ig = [ ImageGeometry(10,20,30) , \ From 6b463bc718667ca4c4b88fed0ef9721d2a562cd5 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 2 Oct 2023 10:01:53 +0000 Subject: [PATCH 030/115] Sorted tests and checks on the set_norms function --- .../cil/optimisation/operators/BlockOperator.py | 10 +++++----- Wrappers/Python/test/test_BlockOperator.py | 11 +++++++---- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index f1374516fe..594d2140b6 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -158,18 +158,18 @@ def set_norms(self, norms): ''' if len(norms)==len(self.operators): - if all(isinstance(i, Number) for i in norms): - if all( i>=0 for i in norms ): + if all(isinstance(i, Number) or i is None for i in norms): + if all( k is None or k>=0 for k in norms ): pass else: raise ValueError("Each number in the list should be positive") else: - raise ValueError("Each element in the list of norms should be a number") + raise ValueError("Each element in the list of norms should be a number or None") else: raise ValueError("The length of the list of norms should be equal to the number of operators in the BlockOperator") - for i,value in enumerate(norms): - self.operators[i].set_norm(value) + for j,value in enumerate(norms): + self.operators[j].set_norm(value) diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index 5d59e20969..5e308aaf41 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -36,8 +36,9 @@ def test_norms(self): ig = ImageGeometry(N, M) G = GradientOperator(ig) + G2 = GradientOperator(ig) G.norm() - A=BlockOperator(G,G) + A=BlockOperator(G,G2) #calculates norm @@ -47,10 +48,9 @@ def test_norms(self): #sets_norm - A.set_norms([2,3]) + A.set_norms([2,3]) #FIXME: ISSUE HERE!!! #gets cached norm - self.assertAlmostEqual(A.norms()[0], 2, 2) - self.assertAlmostEqual(A.norms()[1], 3, 2) + self.assertListEqual(A.norms(), [2,3], 2) self.assertEqual(A.norm(), numpy.sqrt(13)) @@ -66,18 +66,21 @@ def test_norms(self): self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) #Check the warnings on set_norms + #Check the length of list that is passed try: A.set_norms([1]) except ValueError: pass else: self.assertTrue(False) + #Check that elements in the list are numbers or None try: A.set_norms(['Banana', 'Apple']) except ValueError: pass else: self.assertTrue(False) + #Check that numbers in the list are positive try: A.set_norms([-1,-3]) except ValueError: From 215bfa644819d2142e73da95db8d72c61d739b53 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 2 Oct 2023 10:04:13 +0000 Subject: [PATCH 031/115] Changed a comment --- Wrappers/Python/test/test_BlockOperator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index 5e308aaf41..909b49d4a4 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -48,7 +48,7 @@ def test_norms(self): #sets_norm - A.set_norms([2,3]) #FIXME: ISSUE HERE!!! + A.set_norms([2,3]) #gets cached norm self.assertListEqual(A.norms(), [2,3], 2) self.assertEqual(A.norm(), numpy.sqrt(13)) From 96e47304fb1fe9e3cd9e4a4eb7bfe3ab93732f96 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 5 Oct 2023 13:30:29 +0000 Subject: [PATCH 032/115] Changes based on Gemma's review --- .../optimisation/operators/BlockOperator.py | 17 +++----------- .../cil/optimisation/operators/Operator.py | 7 ++++++ Wrappers/Python/test/test_BlockOperator.py | 23 ++++++------------- Wrappers/Python/test/test_Operator.py | 7 ++++++ 4 files changed, 24 insertions(+), 30 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 594d2140b6..3ed59a719b 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -146,25 +146,14 @@ def norms(self, ): ''' norms= [] for op in self.operators: - try: - norms.append(op.norm()) - except: - raise TypeError('Operator {} does not have a norm method'.format(op)) + norms.append(op.norm()) return norms def set_norms(self, norms): '''Uses the set_norm() function in Operator to set the norms of the operators in the BlockOperator from a list of custom values. - - ''' - if len(norms)==len(self.operators): - if all(isinstance(i, Number) or i is None for i in norms): - if all( k is None or k>=0 for k in norms ): - pass - else: - raise ValueError("Each number in the list should be positive") - else: - raise ValueError("Each element in the list of norms should be a number or None") + if len(norms)==len(self): + pass else: raise ValueError("The length of the list of norms should be equal to the number of operators in the BlockOperator") diff --git a/Wrappers/Python/cil/optimisation/operators/Operator.py b/Wrappers/Python/cil/optimisation/operators/Operator.py index cc2eb44bb4..23f2cb6f46 100644 --- a/Wrappers/Python/cil/optimisation/operators/Operator.py +++ b/Wrappers/Python/cil/optimisation/operators/Operator.py @@ -71,6 +71,13 @@ def norm(self, **kwargs): def set_norm(self,norm=None): '''Sets the norm of the operator to a custom value. ''' + try: + if norm is not None and norm <=0: + raise ValueError("Norm must be a positive real value or None, got {}".format(norm)) + except TypeError: + raise TypeError("Norm must be a positive real value or None, got {} of type {}".format(norm, type(norm))) + + self._norm = norm def calculate_norm(self): diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index 909b49d4a4..bdcf297196 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -37,11 +37,13 @@ def test_norms(self): ig = ImageGeometry(N, M) G = GradientOperator(ig) G2 = GradientOperator(ig) - G.norm() + A=BlockOperator(G,G2) #calculates norm + self.assertAlmostEqual(G.norm(), numpy.sqrt(8), 2) + self.assertAlmostEqual(G2.norm(), numpy.sqrt(8), 2) self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) self.assertAlmostEqual(A.norms()[0], numpy.sqrt(8), 2) self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) @@ -67,26 +69,15 @@ def test_norms(self): #Check the warnings on set_norms #Check the length of list that is passed - try: + with self.assertRaises(ValueError): A.set_norms([1]) - except ValueError: - pass - else: - self.assertTrue(False) #Check that elements in the list are numbers or None - try: + with self.assertRaises(TypeError): A.set_norms(['Banana', 'Apple']) - except ValueError: - pass - else: - self.assertTrue(False) #Check that numbers in the list are positive - try: + with self.assertRaises(ValueError): A.set_norms([-1,-3]) - except ValueError: - pass - else: - self.assertTrue(False) + diff --git a/Wrappers/Python/test/test_Operator.py b/Wrappers/Python/test/test_Operator.py index 78d7e30c8c..012e4a58be 100644 --- a/Wrappers/Python/test/test_Operator.py +++ b/Wrappers/Python/test/test_Operator.py @@ -347,6 +347,13 @@ def test_Norm(self): #recalculates norm self.assertAlmostEqual(G.norm(), numpy.sqrt(8), 2) + + #Check that the provided element is a number or None + with self.assertRaises(TypeError): + G.set_norm['Banana'] + #Check that the provided norm is positive + with self.assertRaises(ValueError): + G.set_norm(-1) def test_ProjectionMap(self): # Check if direct is correct From 1ca3a2b599a218cddc4c85b332000a56f154349d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 9 Oct 2023 08:52:49 +0000 Subject: [PATCH 033/115] Comments from Edo fixed --- .../optimisation/operators/BlockOperator.py | 240 +++++++++--------- 1 file changed, 122 insertions(+), 118 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 3ed59a719b..2309dc1b37 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -29,7 +29,8 @@ has_sirf = True except ImportError as ie: has_sirf = False - + + class BlockOperator(Operator): r'''A Block matrix containing Operators @@ -37,21 +38,22 @@ class BlockOperator(Operator): following form: .. math:: - + \min Regulariser + Fidelity - + BlockOperators have a generic shape M x N, and when applied on an Nx1 BlockDataContainer, will yield and Mx1 BlockDataContainer. Notice: BlockDatacontainer are only allowed to have the shape of N x 1, with N rows and 1 column. - + User may specify the shape of the block, by default is a row vector Operators in a Block are required to have the same domain column-wise and the same range row-wise. ''' __array_priority__ = 1 + def __init__(self, *args, **kwargs): ''' Class creator @@ -64,7 +66,7 @@ def __init__(self, *args, **kwargs): :param: shape (:obj:`tuple`, optional): If shape is passed the Operators in vararg are considered input in a row-by-row fashion. Shape and number of Operators must match. - + Example: BlockOperator(op0,op1) results in a row block BlockOperator(op0,op1,shape=(1,2)) results in a column block @@ -72,95 +74,91 @@ def __init__(self, *args, **kwargs): self.operators = args shape = kwargs.get('shape', None) if shape is None: - shape = (len(args),1) + shape = (len(args), 1) self.shape = shape - n_elements = functools.reduce(lambda x,y: x*y, shape, 1) + n_elements = functools.reduce(lambda x, y: x*y, shape, 1) if len(args) != n_elements: raise ValueError( - 'Dimension and size do not match: expected {} got {}' - .format(n_elements,len(args))) + 'Dimension and size do not match: expected {} got {}' + .format(n_elements, len(args))) # TODO # until a decent way to check equality of Acquisition/Image geometries - # required to fullfil "Operators in a Block are required to have the same + # required to fullfil "Operators in a Block are required to have the same # domain column-wise and the same range row-wise." - # let us just not check if column/row-wise compatible, which is actually + # let us just not check if column/row-wise compatible, which is actually # the same achieved by the column_wise_compatible and row_wise_compatible methods. - + # # test if operators are compatible # if not self.column_wise_compatible(): # raise ValueError('Operators in each column must have the same domain') # if not self.row_wise_compatible(): # raise ValueError('Operators in each row must have the same range') - + def column_wise_compatible(self): '''Operators in a Block should have the same domain per column''' rows, cols = self.shape compatible = True for col in range(cols): column_compatible = True - for row in range(1,rows): - dg0 = self.get_item(row-1,col).domain_geometry() - dg1 = self.get_item(row,col).domain_geometry() - if hasattr(dg0,'handle') and hasattr(dg1,'handle'): + for row in range(1, rows): + dg0 = self.get_item(row-1, col).domain_geometry() + dg1 = self.get_item(row, col).domain_geometry() + if hasattr(dg0, 'handle') and hasattr(dg1, 'handle'): column_compatible = True and column_compatible else: column_compatible = dg0.__dict__ == dg1.__dict__ and column_compatible compatible = compatible and column_compatible return compatible - + def row_wise_compatible(self): '''Operators in a Block should have the same range per row''' rows, cols = self.shape compatible = True for row in range(rows): row_compatible = True - for col in range(1,cols): - dg0 = self.get_item(row,col-1).range_geometry() - dg1 = self.get_item(row,col).range_geometry() - if hasattr(dg0,'handle') and hasattr(dg1,'handle'): + for col in range(1, cols): + dg0 = self.get_item(row, col-1).range_geometry() + dg1 = self.get_item(row, col).range_geometry() + if hasattr(dg0, 'handle') and hasattr(dg1, 'handle'): row_compatible = True and column_compatible else: row_compatible = dg0.__dict__ == dg1.__dict__ and row_compatible - + compatible = compatible and row_compatible - + return compatible def get_item(self, row, col): '''returns the Operator at specified row and col''' if row > self.shape[0]: - raise ValueError('Requested row {} > max {}'.format(row, self.shape[0])) + raise ValueError( + 'Requested row {} > max {}'.format(row, self.shape[0])) if col > self.shape[1]: - raise ValueError('Requested col {} > max {}'.format(col, self.shape[1])) - + raise ValueError( + 'Requested col {} > max {}'.format(col, self.shape[1])) + index = row*self.shape[1]+col return self.operators[index] - + def norm(self): '''Returns the square root of the sum of the norms of the individual operators in the BlockOperators ''' - return numpy.sqrt(numpy.sum(numpy.array(self.norms())**2)) - - def norms(self, ): + return numpy.sqrt(numpy.sum(numpy.array(self.get_norms())**2)) + + def get_norms(self, ): '''Returns a list of the individual norms of the Operators in the BlockOperator ''' - norms= [] - for op in self.operators: - norms.append(op.norm()) - return norms - + return [op.norm() for op in self.operators] + def set_norms(self, norms): '''Uses the set_norm() function in Operator to set the norms of the operators in the BlockOperator from a list of custom values. ''' - if len(norms)==len(self): - pass - else: - raise ValueError("The length of the list of norms should be equal to the number of operators in the BlockOperator") - - for j,value in enumerate(norms): - self.operators[j].set_norm(value) - + if len(norms) != len(self): + raise ValueError( + "The length of the list of norms should be equal to the number of operators in the BlockOperator") + for j, value in enumerate(norms): + self.operators[j].set_norm(value) def direct(self, x, out=None): '''Direct operation for the BlockOperator @@ -168,41 +166,43 @@ def direct(self, x, out=None): BlockOperator work on BlockDataContainer, but they will work on DataContainers and inherited classes by simple wrapping the input in a BlockDataContainer of shape (1,1) ''' - - if not isinstance (x, BlockDataContainer): + + if not isinstance(x, BlockDataContainer): x_b = BlockDataContainer(x) else: x_b = x shape = self.get_output_shape(x_b.shape) res = [] - + if out is None: - + for row in range(self.shape[0]): for col in range(self.shape[1]): if col == 0: - prod = self.get_item(row,col).direct(x_b.get_item(col)) + prod = self.get_item(row, col).direct( + x_b.get_item(col)) else: - prod += self.get_item(row,col).direct(x_b.get_item(col)) + prod += self.get_item(row, + col).direct(x_b.get_item(col)) res.append(prod) return BlockDataContainer(*res, shape=shape) - + else: - + tmp = self.range_geometry().allocate() for row in range(self.shape[0]): for col in range(self.shape[1]): - if col == 0: - self.get_item(row,col).direct( - x_b.get_item(col), - out=out.get_item(row)) + if col == 0: + self.get_item(row, col).direct( + x_b.get_item(col), + out=out.get_item(row)) else: a = out.get_item(row) - self.get_item(row,col).direct( - x_b.get_item(col), - out=tmp.get_item(row)) + self.get_item(row, col).direct( + x_b.get_item(col), + out=tmp.get_item(row)) a += tmp.get_item(row) - + def adjoint(self, x, out=None): '''Adjoint operation for the BlockOperator @@ -217,7 +217,7 @@ def adjoint(self, x, out=None): ''' if not self.is_linear(): raise ValueError('Not all operators in Block are linear.') - if not isinstance (x, BlockDataContainer): + if not isinstance(x, BlockDataContainer): x_b = BlockDataContainer(x) else: x_b = x @@ -227,11 +227,13 @@ def adjoint(self, x, out=None): for col in range(self.shape[1]): for row in range(self.shape[0]): if row == 0: - prod = self.get_item(row, col).adjoint(x_b.get_item(row)) + prod = self.get_item(row, col).adjoint( + x_b.get_item(row)) else: - prod += self.get_item(row, col).adjoint(x_b.get_item(row)) + prod += self.get_item(row, + col).adjoint(x_b.get_item(row)) res.append(prod) - if self.shape[1]==1: + if self.shape[1] == 1: # the output is a single DataContainer, so we can take it out return res[0] else: @@ -242,74 +244,80 @@ def adjoint(self, x, out=None): for row in range(self.shape[0]): if row == 0: if issubclass(out.__class__, DataContainer) or \ - ( has_sirf and issubclass(out.__class__, SIRFDataContainer) ): + (has_sirf and issubclass(out.__class__, SIRFDataContainer)): self.get_item(row, col).adjoint( - x_b.get_item(row), - out=out) + x_b.get_item(row), + out=out) else: - op = self.get_item(row,col) + op = self.get_item(row, col) self.get_item(row, col).adjoint( - x_b.get_item(row), - out=out.get_item(col)) + x_b.get_item(row), + out=out.get_item(col)) else: if issubclass(out.__class__, DataContainer) or \ - ( has_sirf and issubclass(out.__class__, SIRFDataContainer) ): - out += self.get_item(row,col).adjoint( - x_b.get_item(row)) + (has_sirf and issubclass(out.__class__, SIRFDataContainer)): + out += self.get_item(row, col).adjoint( + x_b.get_item(row)) else: a = out.get_item(col) - a += self.get_item(row,col).adjoint( - x_b.get_item(row), - ) + a += self.get_item(row, col).adjoint( + x_b.get_item(row), + ) + def is_linear(self): '''returns whether all the elements of the BlockOperator are linear''' return functools.reduce(lambda x, y: x and y.is_linear(), self.operators, True) def get_output_shape(self, xshape, adjoint=False): '''returns the shape of the output BlockDataContainer - + A(N,M) direct u(M,1) -> N,1 A(N,M)^T adjoint u(N,1) -> M,1 ''' - rows , cols = self.shape + rows, cols = self.shape xrows, xcols = xshape if xcols != 1: - raise ValueError('BlockDataContainer cannot have more than 1 column') + raise ValueError( + 'BlockDataContainer cannot have more than 1 column') if adjoint: if rows != xrows: - raise ValueError('Incompatible shapes {} {}'.format(self.shape, xshape)) - return (cols,xcols) + raise ValueError( + 'Incompatible shapes {} {}'.format(self.shape, xshape)) + return (cols, xcols) if cols != xrows: - raise ValueError('Incompatible shapes {} {}'.format((rows,cols), xshape)) - return (rows,xcols) - + raise ValueError( + 'Incompatible shapes {} {}'.format((rows, cols), xshape)) + return (rows, xcols) + def __rmul__(self, scalar): '''Defines the left multiplication with a scalar :paramer scalar: (number or iterable containing numbers): Returns: a block operator with Scaled Operators inside''' - if isinstance (scalar, list) or isinstance(scalar, tuple) or \ + if isinstance(scalar, list) or isinstance(scalar, tuple) or \ isinstance(scalar, numpy.ndarray): if len(scalar) != len(self.operators): - raise ValueError('dimensions of scalars and operators do not match') + raise ValueError( + 'dimensions of scalars and operators do not match') scalars = scalar else: scalars = [scalar for _ in self.operators] # create a list of ScaledOperator-s - ops = [ v * op for v,op in zip(scalars, self.operators)] - #return BlockScaledOperator(self, scalars ,shape=self.shape) + ops = [v * op for v, op in zip(scalars, self.operators)] + # return BlockScaledOperator(self, scalars ,shape=self.shape) return type(self)(*ops, shape=self.shape) + @property def T(self): '''Return the transposed of self - + input in a row-by-row''' newshape = (self.shape[1], self.shape[0]) oplist = [] for col in range(newshape[1]): for row in range(newshape[0]): - oplist.append(self.get_item(col,row)) + oplist.append(self.get_item(col, row)) return type(self)(*oplist, shape=newshape) def domain_geometry(self): @@ -320,51 +328,50 @@ def domain_geometry(self): ''' if self.shape[1] == 1: # column BlockOperator - return self.get_item(0,0).domain_geometry() + return self.get_item(0, 0).domain_geometry() else: # get the geometries column wise # we need only the geometries from the first row # since it is compatible from __init__ tmp = [] for i in range(self.shape[1]): - tmp.append(self.get_item(0,i).domain_geometry()) - return BlockGeometry(*tmp) - - #shape = (self.shape[0], 1) - #return BlockGeometry(*[el.domain_geometry() for el in self.operators], + tmp.append(self.get_item(0, i).domain_geometry()) + return BlockGeometry(*tmp) + + # shape = (self.shape[0], 1) + # return BlockGeometry(*[el.domain_geometry() for el in self.operators], # shape=self.shape) def range_geometry(self): '''returns the range of the BlockOperator''' - + tmp = [] for i in range(self.shape[0]): - tmp.append(self.get_item(i,0).range_geometry()) - return BlockGeometry(*tmp) - - - #shape = (self.shape[1], 1) - #return BlockGeometry(*[el.range_geometry() for el in self.operators], + tmp.append(self.get_item(i, 0).range_geometry()) + return BlockGeometry(*tmp) + + # shape = (self.shape[1], 1) + # return BlockGeometry(*[el.range_geometry() for el in self.operators], # shape=shape) - + def sum_abs_row(self): - + res = [] for row in range(self.shape[0]): - for col in range(self.shape[1]): + for col in range(self.shape[1]): if col == 0: - prod = self.get_item(row,col).sum_abs_row() + prod = self.get_item(row, col).sum_abs_row() else: - prod += self.get_item(row,col).sum_abs_row() + prod += self.get_item(row, col).sum_abs_row() res.append(prod) - - if self.shape[1]==1: + + if self.shape[1] == 1: tmp = sum(res) return ImageData(tmp) else: - + return BlockDataContainer(*res) - + def sum_abs_col(self): res = [] @@ -379,9 +386,9 @@ def sum_abs_col(self): return BlockDataContainer(*res) def __len__(self): - - return len(self.operators) - + + return len(self.operators) + def __getitem__(self, index): '''returns the index-th operator in the block irrespectively of it's shape''' return self.operators[index] @@ -389,6 +396,3 @@ def __getitem__(self, index): def get_as_list(self): '''returns the list of operators''' return self.operators - - - From 9a04de4791acdc013efd1e165fac4002ed6ccdb1 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 9 Oct 2023 09:01:30 +0000 Subject: [PATCH 034/115] Added stuff to gitignore --- .../__pycache__/SPDHG_sampling.cpython-310.pyc | Bin 8022 -> 0 bytes .../__pycache__/sampling.cpython-310.pyc | Bin 2552 -> 0 bytes .../__pycache__/TotalVariation.cpython-310.pyc | Bin 7665 -> 0 bytes .../TotalVariationNew.cpython-310.pyc | Bin 9895 -> 0 bytes .../functions/__pycache__/utils.cpython-310.pyc | Bin 1846 -> 0 bytes 5 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc delete mode 100644 Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc delete mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariation.cpython-310.pyc delete mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc delete mode 100644 Wrappers/Python/cil/optimisation/functions/__pycache__/utils.cpython-310.pyc diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/SPDHG_sampling.cpython-310.pyc deleted file mode 100644 index 50238c405fe007f4ad1d74ed7ea628949025d970..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 8022 zcmcIp&5s*LcJJ!u_k4Op$+D#NmSt}sdS^&!)>z8}uf4V;+w#YF)}vixDQO!`c9CqV z*-ckBr5Tz7EFb~a#X$n(n8OT^i-N?bAeS6Be?m@u3j$=}Qvw(Pk_{Hx->YJCNNEIH z*$oF>U0wBFy^nhJK5D{+g_42ajeqzTH~#~}_&55P{$=p-Q#{dSG_K(?-{`SAW7Ic& zvu>$(rk+vnY(0y&<>z|&dY&2Y8g9nT-ZR{+V0W#0!8NyyO73f{WK>vEe9Lc#(u+I2 zO?>6IonGG;vPrYkKjMIXQ6G&k>dZCjrpxM9(JY#7`3s}P6qRB^`IVbMA_J46yTG7#X9!0B%nt+3l^% z@4Y+ti=ts{$6>SMM6uW8Thi+}KEFIb^WJVldM41#9tg~0^*iqq`y-XMy3LvV*T!{D~q;jJ+kzk|)e z@Y%?ttvSp4GTc#OgH|VWdD!A!91&V~&~{>>)@_5@V}#!N&TFeR!oHAB9LkjOkJIn5 zyd=1iXfmOM03)&E1^h!V5RT;OWHixJ>XrO-wzz9X;Qb3noOpi*e(DJgw8MmvIHq(~}r znS-A$(l%{ozVvOf+!B0 zrXVhqiu43;`c9-liTX#A^AHJN;EauF2Vy7YIN;t|!-<=ni2_!+1m&>D6&->mM*bMB zy!`U5JC1Be+P4Iu>_w05+M%+fXgYp#;N#4?6Jym#V>#0k7-?^IWk<=az0KIW%+3IB z5IJqJ!MBCrojC4C8?{;+9%Rs{Hp5=+w&O)>((!ATu70?7S@goF*6_ndtp|rHWbInm z3)|A^cXn&rUQe@zUeNZ%57y6L>Nr6l{2IAp`*vh2ORe^IOPYzzaO`}DH6^BMa2{?8 z*%krz&x?3_fb$!~0y4wYZhI~|amR`I_4QRQKCAL`7uG8`r@ZsTVNW^n8>1WQlwbF5 z{_67!we>yzGXDS{c)`1jhi;61wa)qLybqU6uEK$ddxv~Ifn5wc!wds| zca=L4R3;)ofFwNZ_4S)-30nCaNFjW{)J33F8uDHU7NK`|ai2GxNFAT+7jDuztwB7% z?43~Fsu23*H(5}1J`pV;Y3Gg%X$k}jo}CKGT4QVKICpeNhC!*2eCX50F- zA!Un#G5^GCcH-Y0NbeRjh@~$%a7@nH+g`(S;03pv9cb4R4ZZsI)we$4?}r14P{d&c zA0sUFyrDLU^^2=K2&?=Res2Bzg^QI9zW(aPAFZulJb$qY4bJKgyL0v(b*%W-m20pS z_{1od0~P$W27)kHi+W**01v%|GUAQhu~SM(635td;JR?%ByD@FheMgCMRx88AL@{| zJaNZs4xb?LZ~k#gr}H4(S@pYgZ7&=1?Nx?hC;peOi`Us>gwIu@+s zq(c7Js!HI^->S^e_|G?+DvQ-$#vI;@c<3FuXksH~Bjc{wHC@XyMy0=Df6kaOLMAz2 za&?3p7VqlFRPXa6qic=W$Q)Ut%qTm`jq;q|3-AH59!cqMQm}2p zvh5^?kZBM4iPaWyWiH7e-n3*MFtR`ml2k*IE+h#r=c!qshV&tq&?Gq>C>|gIw`~>1 zY+Ej4=6CPZoPNL7^!(bVaKs=U)wXt#=mlzwvZS6DDRZn%a)hX+T(O-VA^01)g2gC} zkBIyU>ttq;t+3L=`G> zjxc8D?i*nW$4e33TPKxf?pgJ(JoBnsYhcJPN1%@PuT=$;cMJClaT&AociCmsD0`(*2`e7|f}y@C((I^2;~0Y+-GajX z`}hQ^o5DRKeima2qg%Xd5uAdA^ckazw!4UD;k5CZVH(g@PGSEO#`60o4~+fi+_?i< z`BVUV-#>jo8aVaX?3w$<{`aP!pU3w!_V*w8=A;Yz1s6KB&#K*AnB7g+LWQ;HyaXGE zS+5QHX_hrHuZdsVN>lH{q-#>-=!g$5$e(Cq(5wL|M3S@F=sQ&v5MlDZ5eZ?gr? zl#eI4*~#x#{Se;&sRAOzBWeM0D$))A`j_DV1tVo|$Wc zi~U{VyxJsA)1QeBMZ9BpqBCgP#>lu?+GFseDmyta_t}B*m*!`rGf zi(Zl;O;^mste#Jp2L-6`PqAD+hbAe#?&C&*ii0=)7T@0x!868C*ZEbQNmO6Q&5+|q zZ=jO`KgJ~`AxCi8HSQZ-RtB%9$6TsJqGGCaBe7&BME`kW#SA=1a2#C)qWF^>pMOU~ zFQAzrN(4zY+jye0Xq0LeZdiM4&)lQ*%%XJdm{B%T(hu0zB%kIWGp5@2#U))drg@bGTxTgMv>xHUQF^xMX4T0GG5RMlN>f3mw56dt%|fPz`Yyt zrzd7$lzb(YFM|3)K$VF-zRJ)E8A+zHGD%ra{kXmr_!LF+C!+7;+JS1aq=3qvvhOI# zP%p^>tSwZgm{_=7NUWjPuP@;~0heEPTZFitleRIE*zg;H<}Z-s-n z@~nIXUnoGFKFa9V(AOo!kEusxM!f((sBVH23-^b*uE@}3m-0YK&h_BmV_k#1N?2q! z^_3LMhGFR&Cwa&1(ru)?2-w7OTvu)osyac>Mz|ofQH|dA!a+pd5BJ0H zxfM&><@afQYuCQ@$SF^9gT9L+@Xwf!PM|qsoirD%mCWYulk9}5vwvBzVCXCSt zde*+Oqysi*>=88EFQP5LhO(oqYrbaSP2)Mh0qdfMD#6ki#_^mq+7=ZQ;~i{+HTC=Y zA%2zlq$qHIN@@~nQ|iSuwT!g4`YE8*M(ZtI#-8Bv|8Q%h+PJp?m1O)dijo}Fgn?Vh zDU~N?|AHj7CuZ1BO!oqc++P1t^)G9U+F_$h*P^$@Z-Eg}ftWGN>6FPZu({ktDun&r*zVJWnng%8(xe3nzI7U|L+cMF32mn$Z5)q&F+o|I+v;XolxBbrrZK z>>VYTB!wO+*5WMk{{T*DY}p)^k6L|(|ECvF;-8q~6yr(aJtPPvUPUvYFAi+0{{@=i@grAnQW#2q)Tf86IU;i;J5~XL+;e)k*(S0mI*m!Dg@2ZeeO{9F zaNW97FYemSfy7m5{K(;xmw{qHh02!7Z1_FR(34zgaZ~?PEZD5%=}Y%FD~ocK=$CA} z7rFxmNVX`p3 zhH47mA74djNuDJTl`hbcCA(FrV8O^R^F5O-J~Zb|+$$A+UU<=5EHTs4&$6j5%__zE zY20O1r|+$*lZ%B&(%Ha`-JplO$PD_jO4KUU&^4J#$kaMhTAdt|r0}}d!y9Cw>Yi)9 NT!0@dAXO=|KLEk;NEHA8 diff --git a/Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc b/Wrappers/Python/cil/optimisation/algorithms/__pycache__/sampling.cpython-310.pyc deleted file mode 100644 index aebdc95d144e7b9b034882bb369e611ed685fd05..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 2552 zcmaJ?UvC>l5Z~SV>$9D^o1j7xZ{%!<(?1pJqGa1l&kW4&$*^k~{t1NG?EgH4m(##IWVOft4Mt*wmBn`8) zG}ADYWjzYgY$_|wu}YqltwmcuQ8HAeRSmUHFbW?im8iBw4x(K}u;@0^Y1Dn%M>Qc+ zb&wZKwJ`j7e=``5H+zF<^RWUKs&wIqoP9y*?jPv^dcAm_Y5 zwhLpA6=rVa2C^uga&;4!Fjknlgj|acSz*LAl3Ztn$juX$8_ziho$05ITmUI1utBSW zRx@Dfh!>VLqxNbEjzJHGQsHUdz3wmKx@c6qi}yXkQLc?5+|<744PVd3}{tKCutG+O5U@lvU?Q z)p{002VvK(gnrzu$G!^3FedR*?DzV#OEoW@FbYTLHKjAcNzi>>`(K5Y$=<`4Zh@G> z1ZEq+EN~0VHvV#LLU2nj1F+`!D$FX@_mor^!r+T_~*gy@w-Q4(x?8s$HM(Y=cU z4;QEh5dtuZ6;O0MNEW)=`&z?WG|dUq`jDiiT7Zf^!jVx79X#@ z0;K<}_?%Z2e-`DoP%8*W$%kh$MFp=Y-aEvsf=t%u0Z#kL*M3MFr*AB94U3y(sKHRL zz;GRc(i$tB``rZhW2Uj8Zjq+8A#kX5BKkJcpfEHj&;xJ{R(q;7(x5x4BDy)%7Y^0M zQcByQO!*CNzVyTrxLcZQ@MXZo$ce~c&I0uY*DfwoO=JzyPuTkja#2BW?a zn4QXYMYUOAZC5d72DQ$__CzsO->!eDiHfjZYr^vMSH||FV2`y%^(`=K8x1|HJ?w>U z;zwaN^;IZ**GVGzd34ZV+3c6n5xy5Df7C)GuKSd7);=c#*v~4D| zZC$W!L+HW~rl@#kyE3T}6qcycU#tF0t;Ix5OuU}hw!EsSi^Pa0f$d%Xb2Vuh{F@l&ALjd>QR~=+}%ynpQCBx;UDsy#OdugL3iKbTTkvBG!zy>SN_z%rX!t>mv}N>D;5;5 zwJyzI&jZ`Xv^vcib@`wh^Qgriez`fMs{A%N?0Vy$`eCxjh1YU=LBdy-m&>*JK1mc{ zlhF0n_~Rt%cKvXVyWo^3!P9c7LOZgu6-3Sm(x)3y=snHZ#d$%18%gN}#ql2uJABtm zzV^J3KYiSFTzuw)VhJ+IyASrAF!X}>sghH&?+v6`>h`HKo!TT$xU2JHi0x>FwRIt%K-mPp)zG;=55V z6a(~;O!lKaXmG&0Lye6>9F7>^M&S$ZfX80KAC%-MffOinLmyK9^lsQ~`eEy7xj3i2 z*M)Ofj;-~kO{ zY^Spu9lShswxi#6qjYqO6zGQoK%Wk9JK=!B1|MKQEzYHbuTZ>&umLDfL8~hAucMPXfewzzdeR}S8<+}9)r_&8QIL=~Z>k0n@I74!|ALPz` z=-W&G8%F^aZ9Qqi#t!_B6Wk$E7dgB&##frl10{ocgi+$b<3GjZQ|>w;oEGQ^RY>Jv z8Aco_ox>*I0uAtT@RwK@d)&v#eE5!J-$_86*S#D2eGe?~V8_CzNJXSW^PMiO6ir3L zPrSnGj70;^KWp;OJ@*;8N&Y9;&x7*_0&kJuJ{9clevaJ*|E!F2x%YYyg>XxbA7W}O z=#{+V{Hu<$=kYJRF!EzM8}0Okw;S{%x05h!Hy~vLY5? zP+`DAcuhjFSjdI*7g5mUE1xccqj;|@@@}`uSMROdzq@+xqkD^dBYJ`U^78$~;dw;l zuOU!1S5}tqFKvCb*`#@Z)lXM{Z#icd>7Cl+tw0*HkyVtp&zQUQ(48Dfcc^U?Py9D% zBwE5!?Umlvk%6&q7_u)t)odfhsBNayuB25!D>VSCsR>w1D}WQJ1z1le(X)VI3cYEe z0nR9RLBUxCFQyY1pG#|i^JyJ$A=TOoa$OMCOG0~$tPoj@xq(!TJ^GLQ$p86A4;z=W zO5B5|mKMgcnr%~9vhD2Z>HNf2c1HO_Rv+dC*~B17XA=V-l1+|;$*fugtgNEqM^;f@ zToRYET4@_uJ?V69^xF1=Y{K3v^2@Ahi>L#2$|~J1R%DiXtz;${JWftdDVzA(ksa8$ zOtSjE6RVad8k3nBdqFFkK9$+kT_{ z&-xOKXvy`1rJqW)kW4LY9wL~AYAos|ey7OimRd#f950}xb{zu=o!5a4tD7JVmFWuxK--{Cd@~B}!L*W#l21u$T?VL?)Ax~YG zGLo5vAc6ckGs*eO_c8lMSF~r97f#Ug&SSwZuu3truFpXhXQ(4SE9$n<=vygkla;cc zYGIW@8VvMO|7Ro&UA_wlt8AOcl@wGTTY_NqL|cHM&dlkJsIW^SRI&h za|&$56#(&wE&*?e>u*UD8nvvp=S9f<<)M5B1G%D;XfaV5nk9Thj0AQ@iBe`DPbvAr z4#s#wUcz;Pz_$MyNMgdI8&k|;H7M;3c0)f$RrB?(fwkq2+5^tvvirT9OPOG)F7$5< zcrv4ZZ@`QHLqbazTLV!xGooJ7FyspM&AD;~EevoP_=Lb3fzt+&O_7VruXy%@zr%u< z?zg&`Q$Nf4*T*bmbp0vniShyU89LvmH%Fv1#*vwtg5B5fh6c$^=vw6q?a$|qDrx1| zI?>uyL<`)lztN#}X1j){V&=W)x6q$ZJwze2>xd1-9Jp%sH2G!9jwe&|1a$!5MN4rT zn1o3q$5SV??|EN}@A|S)>8}oCMXEYv3g1LHN20cq?zkdKc2fK04qSV3c*G?sFZ_}c z1I5*i#`K7|u3kuSBA+p#cUt=b@||)WeK$+_Put4BOfIH+GMCJ^7w}wa8LxEtS1D>RZ92(i z!bupfYxgysD4IJxSB@8>`c1V8UtJN^9+Ur)PKerNWMI#9`H!^c@l{YeS**4`$ycMF z&)lRr>RoxpY6BNANEPS_Pq)UW53ZnbYw7FclC!YXzZHca#$S(GQXaU!%T#}r+x z6SDBy-!gfXX(4;QE-1sirXcOkF>@bp#TB$yllR2r@onUglPCHsd>d9VGDRa4m6g;1HFHLv z(-+tcb{QjeeF{!;27kzLnf{lv`ix$KqnyHX%a}E0F+QbRI_7>uS#b@C#vGdg9&)Jk z-I-(q(M8?2&!lOCyqGjd6}$C~Jv7xXr|M(0$LPyu5l&DLvjo~Uqu7fgL@ewFK%zg?1VB!m9EPlViK8(Za>QAkvh4k6ephj$nVDPzMu3Z zT^z>Fsr2P09gWh8I{0I;{_NQC9-UzdWnt<(WO4~kLD?wN5*<0Z(L$Ck7vR73XBB$G zi z8nA{$h13(GAt7By0GTI8jw?MSq8rLNDUXEwk^F~zLO>niJVCjb{h-vLt49C!n2^rl z(wVajE>t8orA7>DbO|j85TWi81c){sb=9Dx87D5(3(51ZP#J?t5pT;o0FQ7XqW|V_ zzeNQpR9}?n@b3;(a}K>^P-KCmBq~oaR&jTqibbmWM3R3&{~kg4h8GuiT1BP4J)m$} zRJ9snr3i4R&>Y%t*Haf6Dr+^6rw=dbjfx}@2QEDgkK*4bsUh4K4y zN%t9(81R;?@cS>TDQN*NtMA1SoP(10`nO+AM>JF^CwXQ`cOMlTKr=@>vvN#hT1(e1 ziG0?!KN-*lUueN^o}sN=nLCmN`ZUD9e^A${+jb`sy@1+Nw*9>41jS6%hRj@i`IydN zAPrZA3RR?mW+aE|j5wS})kpa$omxe+A5)8>fOH6`xJ5di+X8vmY`UnTxE@^_M+m!3 z>wZ9hycXs2F~$3uX6pK)&ghQ_%v(B}`EUJW1PTO{TBSZyuh)6)&vXP36GE<4^$G$_ zRbgsOWd`ar*)@RXXkn%~D9lK5#d#g-?5ffhVoCazRZxmW;YM+$nwMo`6}zP%By{!> dqLjBGqO#hLa%TS_B$nTlYZvK0P*cx>`M-GAy<-3X diff --git a/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc b/Wrappers/Python/cil/optimisation/functions/__pycache__/TotalVariationNew.cpython-310.pyc deleted file mode 100644 index 61876cc7f5fe76b9822b8ebc3f96907ef499010e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9895 zcmd5?OK;p*b|zV@r%JLctL10AZ+Fj3RBpK}X(l~rrR{0Ar`2P?qcPfw2N5dGV%4Q2 zmRV%^l4ZSEo5;Wb0SpAQ%PP|BdNIEvn;^(yR$R;`i@>|dBAYCdeCP5}ReE@A>O+^?Z8Px1m)>qv{kgqs@kh%`Yo6$)cT4iFrbg3W3zOTH z8~mbY2^zA7#==^^+pE6*o*^`&yCZWOFSr^qMMJ3hrPyi`E@`+S;Te5r1fQJdkHP^<7+ z{vMu9@Hu`N-&M?VgI_sLj_R0!t(6{IwtUn#h_iJqBE^CAh*K9c^>o-E1ed2Z3w=K5P z_PDju9Oq1v&96TNf$_7H9ZhDo1D~1rXKkaA0s|1)j>*Kl1 z+ho+V(soSWUuo7y#jc4Nq--+N<>TE>%3qUti6kzZWZfnm37trG6br2JjlH!Um_m3v zY<{!RwnaNWuUg!Bb3Qq~T{(2@c;opWy4a8zu(s)23vzEg;qBU8)5&&1w5>m7+_QY< zdI8%uUs#}oS-W5t^F60e!X|0ku~^@i55YGml#QN}U8b|;2|L*CvcRJuFRYc5^rgZ_ z>ko{BMqu_w1#&RoiY2n|a!dGDaL^wdq+?96)wSKhfHgLS**;hr94yoL0hq;ZvsNSg z_F#FyJ{g@443ayO1qsSA!X?|(7pRHRhukSdP(P}Q7 z*=`QoH@5rBi%W~mdL?G~V^f%23#T)pEh8$^HFu5V>~N+lY{hGJR+_dOU`B3jntdmL z5H2k)O1_c#__+yjfkAMk)g%J4@qWg|)vq598C;iR1J8koxNT6Dtg`8N=J+~mo@-?b zJqf&C&vv(188?eta*~s=ah#A)Q zgs>cGP_v!-ff(aQ^GVNaTg_~}2P0!zR%#J3N&P1m&?A0{G^x6Fd1 zLY2BEoFLKEGTYBAn2{BhaP8Dy+D+;=Lj9M?5J()EtUgTIn5{asl3d8~b}W%m{3n0p zaPDJj7h5qQDh#?|xge+wG4K0yWMk`%I%u+uvEyD~R(-2Z@+=MZXs3C(mj%}E!8q0u zM#!80pZiOApE;>)mn{!MZ@Oc$vo88W8UJ%wPYZSuoF9&cWQ=$`QbXH?XNtYf`cr6j zeBh(5Jlu`tn!NRM5ghCqu!@NlM15J--{`by&Y|AO`K0#`JaY+6wYjFxD14Hr2Bpq*7fNEV~_R z8RKSPCfu?ipYO1(ha}E$pTu-XcTZqXBTm9UZJH85FlL$JgMyZL?v??4d139^!5-E8 zz=YnMZwQCx_CAZpJA0&Ym;r=~F59sP31CaDy+qlh7M;5m5YUQ5ea*&}+3lLm8tbK= zfhaUNANr^h__01TtZM)sv2LGi~|tcKTE_L|8q!ypn*gV zF*5)k2s$LNq4CJt3`7RB{##p#7a?eJu=Gj1m;@>bQi(UwI`Qxv_`>3y5b~7C9%Cfaf+;E!5aY6nScCf(sN7^uv~9w98wsT#0_s?X1wJSqTp`>%|LQ3 z7CYJ(7KGae1a*LXJi_B7Vm`J@@R_7NhDSTL<48nGIFwL3Kq%+ZGQtc9Ypd@d5`#d0?AvggNMNU4=C)6X^q7;5tIkmY~x_5zSwZA=Lkiq1OplaIvDa( z@4}hPuillOXMss@aTl{E0OKyEetY)O@(Hy5-{s+a;~e35lkrNpc^-eH=?8O{tlK}# z7%9amma|(Y#p)FE&UG+%<=k(>M{vFtbCJr|9NCq%C@&Fpq_)>rg^HGT6-D}?dM>&A ze?TQr0yR_)wT^~tk@`wS_DBmABNw98&_k-{!y?K;m_u0%b(Ezr&y~I+J`T#A%7ik= zhXr|mi|z-7FpoYHVF6_|n8aNH^H1UK0#{H@%kpAaMtvq!Iy2&D!KI^Fo;$|sVF|78 zg%c>}@N7=3b6W9oSV4IOEd|jGt{&1n*SPXT39b+8wLB%E)JOjkQ~QUX>@P6{V4Gf( zyePMN!a{b-s z%ov%|k1E5kEh=Y0P*l#2Jen8@g`#2-h(wy(i*ndsl$VMW*wjdb5~HlxY02v^MDnV6;GJu0qHag~ZoRD4LqO)9=e#YZT@c@2YX0kbI|#AE2|il@*^*4LL^TpK$paih{O(>+~+po3Twp(ht??u;i|2p+E`M zKt0s_sQ{VQqgY;j!>#tO)+t6TSKDD*|AD*|s3i4DGB>>HuNseNHZ6S?yFsKzE z^axK0e77x8#DYIAn133>15fkr~}J} z>3mXTO|L>DN@_*NrOm3kcHwhjMHj7uVki-WY%TKqD-AfMFepJfNYkHl9d%mw zLbksgo|l7Zv|c<^f2#cDUk@swJ^-%h=$#p0lUzJYnCn~uzEOEmw&3j=dd$+ixJpv; z%HnTT#qG$E?*RqnlaW9t*kkd!GN^`m;2V_56Cj`;gC2~yjQy$NAHxbS&p|q$X{hIq zu7KLfa55}V4LU$|^nHe&poBPbwQ~)aswiiK^m8q^esqItyb@0EiAz$Gj@8QwpTO!m zR(~I3N*EzI1L`KYc0~#G>k2fafctnq`2kQ^r-ZX3G*)`Pi@TeDqmu5$J4O9+@WIhd zUOi$!T$9HdVKTQQ+a{@vETgIfABM$46{U8lKGQI2DJ*tA!YuOCl3kS0{%Ht}kx#R@vES34{i-%$OcCFVw7Jo|9k#7+Mh{TVnz}sden!;;?Ez3y#PgH^f@CXx2fEH=JW$`if)7u_k z)g2l~zFoSVs3bFjJ!dbv5ChNQJb5{+MfsrHGoD8iFvx_^4Ao&&phi(Gr&VEK;9ETCf-uVv?gg!U34; z9Hu#GsqbSWC3pv4prVzA9#qdwYXx-%e+3|#0x(UbFa@7FgR7+K>NLLTei}Wfjux$o zmXbDy=T-FA)fxS!HjN(W53~vokgKY*=r@z2S)~W~-nbVdM10yUjiD(*AsK=t$&>o2 z?XQn{%?#xvxzg-(-VOO|VSf3Md`n=UAoqBJkZ@w(s3of|NS%QIF0;Hk&*!`T8IddZsih%?gWE71g~;jdqp9- zbkqop^E`J%E=Y+%KVa-{ve&KYn=y)u+Yord_%^+Mqy~CZ9YcG(HlQbaR#0c_WQJwD znF>HN3q_mpn|(5QqZ7uqyP4ul{73*<$Y!eVO$H3S?QtJTahXAp784SZ#gzO08LN&n zkk&gGj79Y1FVZFH?MAv@x*XfI1>QWjESxiCdL4&cMT(~DwPI{JDc%@vMclw`RC!9# zi;Quk0TO2&IZ4G19Xa8xN?}ed=+pmk7Enu zWz4-M=oe68f~srlt8tEMRV>i5(=@eA$Ie(;mQF=PGI`Uzw|1De;o76)Wm=RVI;YQ_(e~IqIV+je3^S5M<(H z(nn@qWX|P`{^_qMbSpC!!sUgjk}mpnGJjX3_*yYl-@JiE1rTH9)miQ0=4*sCbF`dWnjcs0dK; z4XP&D=^E7HCmq0q%h8=9tf~$pJJm?h5X~P*vMySp4ezdq#TvXfg!i2EI#<}M9<>`! z2j7lUotm`BKb6Hu8a07*I7l--80;VJOC8Wmw|QA^Lw(yX6nIkU?Pn8nQsgdIlqMaen&W=9kH`4{9lbp^X{NWziH)(wYOy{n z_7F>AU}CCJF)MY~A%RI(_n+VxqJ2T1gMjA5&#!g^2<$f50%8Jm20BMLevAR+G@#1HkZi|(R3 zBb7L21p2!uWoBM`%+kGRT15{;muNv4=qcF))(Ax%MQvr zxhuHah;6U5lsU=2 zJ0d{@cylCmBem)8e6jmfy$-9ZH^B6$dK3NSvHxEm9P$80=uI%UePFQ9h=!EW7&@cg z#fcu+HtOYA@sT_))Jw;^LJ`{_ACJn3!WongCJEd%mpH*W*KT}Xh;b(O3$s^@bKy?F zU6nSdhkK=4ZBtwy11M@VBDd6Cz8>p!m($Kn70 From 5a302c88e2e3f526a9684c4217937979b29055c2 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 9 Oct 2023 10:05:15 +0000 Subject: [PATCH 035/115] Fixed tests --- Wrappers/Python/test/test_BlockOperator.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index bf7904982b..0cfaacffa5 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -45,14 +45,14 @@ def test_norms(self): self.assertAlmostEqual(G.norm(), numpy.sqrt(8), 2) self.assertAlmostEqual(G2.norm(), numpy.sqrt(8), 2) self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) - self.assertAlmostEqual(A.norms()[0], numpy.sqrt(8), 2) - self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms()[1], numpy.sqrt(8), 2) #sets_norm A.set_norms([2,3]) #gets cached norm - self.assertListEqual(A.norms(), [2,3], 2) + self.assertListEqual(A.get_norms(), [2,3], 2) self.assertEqual(A.norm(), numpy.sqrt(13)) @@ -64,8 +64,8 @@ def test_norms(self): A.set_norms([None, None]) #recalculates norm self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) - self.assertAlmostEqual(A.norms()[0], numpy.sqrt(8), 2) - self.assertAlmostEqual(A.norms()[1], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms()[1], numpy.sqrt(8), 2) #Check the warnings on set_norms #Check the length of list that is passed From 0bffa2483e12553b1953951042278cd1eac65cec Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 11 Oct 2023 10:45:47 +0000 Subject: [PATCH 036/115] Added a note to the documentation about which sampler to use --- Wrappers/Python/cil/framework/sampler.py | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/framework/sampler.py index 3530ec3076..6e3eadc607 100644 --- a/Wrappers/Python/cil/framework/sampler.py +++ b/Wrappers/Python/cil/framework/sampler.py @@ -92,7 +92,15 @@ class Sampler(): 4 [3 4 0 0 2 3 3 2 2 1 1 4 4 3 0 2 4 4 2 4] - + Note + ----- + The optimal choice of sampler depends on the data and the number of calls to the sampler. + + For random sampling with replacement, there is the possibility, with a small number of calls to the sampler that some indices will not have been selected. For the case of uniform probabilities, the default, the number of + iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `num_subsets`. + For example, to be 99% certain that you have seen all indices, for `n=20` you should take at least 152 samples, `n=50` at least 426 samples. To be more likely than not, for `n=20` you should take 78 samples and `n=50` you should take 228 samples. + In general, we note that for a large number of samples (e.g. `>20*num_subsets`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_subsets`) the user may wish to consider + another sampling method e.g. random without replacement, which, when calling `num_subsets` samples is guaranteed to see each index exactly once. """ From 222c37770f515d0e490ec7ff879397e6430fed85 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 09:50:21 +0000 Subject: [PATCH 037/115] Moved the sampler to the algorithms folder --- Wrappers/Python/cil/framework/__init__.py | 2 +- .../cil/optimisation/algorithms/SPDHG.py | 2 +- .../cil/optimisation/algorithms/__init__.py | 1 + .../algorithms}/sampler.py | 0 docs/docs_environment.yml | 49 ------------------- 5 files changed, 3 insertions(+), 51 deletions(-) rename Wrappers/Python/cil/{framework => optimisation/algorithms}/sampler.py (100%) delete mode 100644 docs/docs_environment.yml diff --git a/Wrappers/Python/cil/framework/__init__.py b/Wrappers/Python/cil/framework/__init__.py index 19e6e89c1e..437ecd787a 100644 --- a/Wrappers/Python/cil/framework/__init__.py +++ b/Wrappers/Python/cil/framework/__init__.py @@ -34,4 +34,4 @@ from .BlockGeometry import BlockGeometry from .framework import DataOrder from .framework import Partitioner -from .sampler import Sampler + diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 62ba0675ad..efc5fe7354 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -22,7 +22,7 @@ import numpy as np import warnings import logging -from cil.framework import Sampler +from sampler import Sampler from numbers import Number diff --git a/Wrappers/Python/cil/optimisation/algorithms/__init__.py b/Wrappers/Python/cil/optimisation/algorithms/__init__.py index b6b23bcb58..00ff33b9d2 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/__init__.py +++ b/Wrappers/Python/cil/optimisation/algorithms/__init__.py @@ -26,3 +26,4 @@ from .PDHG import PDHG from .ADMM import LADMM from .SPDHG import SPDHG +from .sampler import Sampler diff --git a/Wrappers/Python/cil/framework/sampler.py b/Wrappers/Python/cil/optimisation/algorithms/sampler.py similarity index 100% rename from Wrappers/Python/cil/framework/sampler.py rename to Wrappers/Python/cil/optimisation/algorithms/sampler.py diff --git a/docs/docs_environment.yml b/docs/docs_environment.yml deleted file mode 100644 index 20621fcd22..0000000000 --- a/docs/docs_environment.yml +++ /dev/null @@ -1,49 +0,0 @@ -# -*- coding: utf-8 -*- -# Copyright 2021 United Kingdom Research and Innovation -# Copyright 2021 The University of Manchester -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# -# Authors: -# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt - -name: cil_testing -channels: - - conda-forge - - intel - - ccpi - - defaults - - astra-toolbox -dependencies: - - dxchange - - python-wget - - scikit-image - - packaging - - numba - - tigre=2.4 - - sphinx_rtd_theme - - sphinxcontrib-bibtex - - pydata-sphinx-theme<0.9 - - sphinx=3.5.* - - recommonmark=0.6.* - - sphinx-panels=0.5 - - sphinx-autobuild=0.7 - - sphinx-click=2.7 - - sphinx-copybutton=0.3 - - astra-toolbox>=1.9.9.dev5,<2.1 - - ccpi-regulariser=22.0.0 - - tomophantom=2.0.0 - - ipywidgets - - tqdm - - jinja2<3.1 - - cil-data From 1d70eb326098db34b305707ce6609363fc7b4a9f Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 10:32:18 +0000 Subject: [PATCH 038/115] Updated tests --- Wrappers/Python/test/test_sampler.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index cbabbc991a..39b01bc964 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -23,7 +23,7 @@ import sys from testclass import CCPiTestClass import numpy as np -from cil.framework import Sampler +from cil.optimisation.algorithms import Sampler initialise_tests() sys.path.append(os.path.dirname(os.path.abspath(__file__))) From 5c9fa3aa5905d9e76671b63e440988618ff7dbc3 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 11:58:18 +0000 Subject: [PATCH 039/115] Sampler inheritance --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index efc5fe7354..cfdbb93e79 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -22,7 +22,7 @@ import numpy as np import warnings import logging -from sampler import Sampler +from cil.optimisation.algorithms import Sampler from numbers import Number From 8e842765b85b5abe8e9be4e80fda03ec42c1ed08 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 15:24:09 +0000 Subject: [PATCH 040/115] Moved sampler to a new folder algorithms.utilities- think there is still a bug somewhere --- .../cil/optimisation/algorithms/SPDHG.py | 2 +- .../cil/optimisation/algorithms/__init__.py | 1 - .../cil/optimisation/utilities/__init__.py | 21 +++++++++++++++++++ .../{algorithms => utilities}/sampler.py | 0 Wrappers/Python/test/test_sampler.py | 2 +- 5 files changed, 23 insertions(+), 3 deletions(-) create mode 100644 Wrappers/Python/cil/optimisation/utilities/__init__.py rename Wrappers/Python/cil/optimisation/{algorithms => utilities}/sampler.py (100%) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index cfdbb93e79..18ccfa3ce6 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -22,7 +22,7 @@ import numpy as np import warnings import logging -from cil.optimisation.algorithms import Sampler +from cil.optimisation.utilities import Sampler from numbers import Number diff --git a/Wrappers/Python/cil/optimisation/algorithms/__init__.py b/Wrappers/Python/cil/optimisation/algorithms/__init__.py index 00ff33b9d2..b6b23bcb58 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/__init__.py +++ b/Wrappers/Python/cil/optimisation/algorithms/__init__.py @@ -26,4 +26,3 @@ from .PDHG import PDHG from .ADMM import LADMM from .SPDHG import SPDHG -from .sampler import Sampler diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py new file mode 100644 index 0000000000..706ceb6e4a --- /dev/null +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -0,0 +1,21 @@ +# -*- coding: utf-8 -*- +# Copyright 2018 United Kingdom Research and Innovation +# Copyright 2018 The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: +# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt + + +from .sampler import Sampler diff --git a/Wrappers/Python/cil/optimisation/algorithms/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py similarity index 100% rename from Wrappers/Python/cil/optimisation/algorithms/sampler.py rename to Wrappers/Python/cil/optimisation/utilities/sampler.py diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 39b01bc964..f58f818f29 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -23,7 +23,7 @@ import sys from testclass import CCPiTestClass import numpy as np -from cil.optimisation.algorithms import Sampler +from cil.optimisation.utilities import Sampler initialise_tests() sys.path.append(os.path.dirname(os.path.abspath(__file__))) From c55225750aa01976a3ab3d558ad81ffbf8884b55 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 12 Oct 2023 16:03:32 +0000 Subject: [PATCH 041/115] changed cmake file for new folder --- Wrappers/Python/CMake/setup.py.in | 1 + 1 file changed, 1 insertion(+) diff --git a/Wrappers/Python/CMake/setup.py.in b/Wrappers/Python/CMake/setup.py.in index 96cbea46b3..fe4cc43950 100644 --- a/Wrappers/Python/CMake/setup.py.in +++ b/Wrappers/Python/CMake/setup.py.in @@ -36,6 +36,7 @@ setup( 'cil.optimisation.functions', 'cil.optimisation.algorithms', 'cil.optimisation.operators', + 'cil.optimisation.utilities', 'cil.processors', 'cil.utilities', 'cil.utilities.jupyter', 'cil.plugins', From c6e1458d2625c290d5cf010674d3d3a77dc49b6a Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 16 Oct 2023 15:14:08 +0000 Subject: [PATCH 042/115] Some changes from Edo --- .../cil/optimisation/algorithms/SPDHG.py | 55 ++++++++++--------- .../cil/optimisation/utilities/__init__.py | 4 +- Wrappers/Python/test/test_algorithms.py | 2 +- docs/doc_environment.yml | 49 +++++++++++++++++ 4 files changed, 81 insertions(+), 29 deletions(-) create mode 100644 docs/doc_environment.yml diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 18ccfa3ce6..daf65645e9 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -52,10 +52,10 @@ class SPDHG(Algorithm): gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: instance of the Sampler class - Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets + sampler: an instance of a `cil.optimisation.utilities.Sampler` class + Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets precalculated_norms : list of floats - precalculated list of norms of the operators + precalculated list of norms of the operators #TODO: to remove based on pull request #1513 **kwargs: prob : list of floats, optional, default=None @@ -98,21 +98,23 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, - initial=None, precalculated_norms=None, sampler=None, **kwargs): + def __init__(self, f=None, g=None, operator=None, + initial=None, precalculated_norms=None, sampler=None, **kwargs): super(SPDHG, self).__init__(**kwargs) - self.prob_weights = kwargs.get('prob', None) - if kwargs.get('norms', None) is not None: + if precalculated_norms is None and kwargs.get('prob') is not None: + precalculated_norms = kwargs.get('norms', None) warnings.warn( - 'norms is being deprecated, pass instead precalculated_norms=your_custom_norms') - if precalculated_norms is None: - precalculated_norms = kwargs.get('norms', None) - - if self.prob_weights is not None: - warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)".\ - If you have passed both prob and a sampler then prob will be') + 'norms is being deprecated, pass instead precalculated_norms=your_custom_norms') + if sampler is not None: + self.prob_weights = sampler.prob + else: + if kwargs.get('prob', None) is not None: + warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)') + self.prob_weights = kwargs.get('prob', [1/len(operator)]*len(operator)) + sampler=Sampler.randomWithReplacement(len(operator), prob=self.prob_weights) + if f is not None and operator is not None and g is not None: self.set_up(f=f, g=g, operator=operator, @@ -165,9 +167,9 @@ def set_step_sizes_custom(self, sigma=None, tau=None): Parameters ---------- sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem + List of Step size parameters for Dual problem tau : positive float, optional, default=None - Step size parameter for Primal problem + Step size parameter for Primal problem The user can set these or default values are calculated, either sigma, tau, both or None can be passed. """ @@ -209,6 +211,11 @@ def set_step_sizes_custom(self, sigma=None, tau=None): "The value of tau should be a Number") self._tau = tau + def set_step_sizes_default(self): + """Calculates the default values for sigma and tau """ + self.set_step_sizes_custom(sigma=None, tau=None) + + def check_convergence(self): # TODO: check this with someone else """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma @@ -216,18 +223,14 @@ def check_convergence(self): Returns ------- Boolean - True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. + True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. N.B Convergence criterion currently can only be checked for scalar values of tau. """ for i in range(len(self._sigma)): if isinstance(self.tau, Number) and isinstance(self._sigma[i], Number): if self._sigma[i] * self._tau * self.norms[i]**2 > self.prob_weights[i]: - warnings.warn( - "Convergence criterion of SPDHG for scalar step-sizes is not satisfied.") return False return True else: - warnings.warn( - "Convergence criterion currently can only be checked for scalar values of tau.") return False def set_up(self, f, g, operator, @@ -249,8 +252,8 @@ def set_up(self, f, g, operator, Initial point for the SPDHG algorithm gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: instance of the Sampler class - Method of selecting the next mini-batch. If None, random sampling and each subset will have probability = 1/number of subsets. + sampler: an instance of a `cil.optimisation.utilities.Sampler` class + Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets precalculated_norms : list of floats precalculated list of norms of the operators ''' @@ -290,7 +293,7 @@ def set_up(self, f, g, operator, else: if not isinstance(sampler, Sampler): raise ValueError( - "The sampler should be an instance of the CIL Sampler class") + "The sampler should be an instance of the cil.optimisation.utilities.Sampler class") self.sampler = sampler if sampler.prob is None: self.prob_weights = [1/self.ndual_subsets] * self.ndual_subsets @@ -298,7 +301,7 @@ def set_up(self, f, g, operator, self.prob_weights = sampler.prob # might not want to do this until it is called (if computationally expensive) - self.set_step_sizes_custom() + self.set_step_sizes_default() # initialize primal variable if initial is None: @@ -327,7 +330,7 @@ def update(self): self.g.proximal(self.x_tmp, self._tau, out=self.x) # Choose subset - i = self.sampler.next() + i = next(self.sampler) # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py index 706ceb6e4a..6aa6db103f 100644 --- a/Wrappers/Python/cil/optimisation/utilities/__init__.py +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- -# Copyright 2018 United Kingdom Research and Innovation -# Copyright 2018 The University of Manchester +# Copyright 2023 United Kingdom Research and Innovation +# Copyright 2023 The University of Manchester # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index c93eabce07..e21d8c14d8 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -29,7 +29,7 @@ from cil.framework import AcquisitionGeometry from cil.framework import BlockDataContainer from cil.framework import BlockGeometry -from cil.framework import Sampler +from cil.optimisation.utilities import Sampler from cil.optimisation.operators import IdentityOperator from cil.optimisation.operators import GradientOperator, BlockOperator, MatrixOperator diff --git a/docs/doc_environment.yml b/docs/doc_environment.yml new file mode 100644 index 0000000000..89a8341e8c --- /dev/null +++ b/docs/doc_environment.yml @@ -0,0 +1,49 @@ +# -*- coding: utf-8 -*- +# Copyright 2021 United Kingdom Research and Innovation +# Copyright 2021 The University of Manchester +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# Authors: +# CIL Developers, listed at: https://github.com/TomographicImaging/CIL/blob/master/NOTICE.txt + +name: docs +channels: + - conda-forge + - intel + - ccpi + - defaults + - astra-toolbox +dependencies: + - dxchange + - python-wget + - scikit-image + - packaging + - numba + - tigre=2.4 + - sphinx_rtd_theme + - sphinxcontrib-bibtex + - pydata-sphinx-theme<0.9 + - sphinx=3.5.* + - recommonmark=0.6.* + - sphinx-panels=0.5 + - sphinx-autobuild=0.7 + - sphinx-click=2.7 + - sphinx-copybutton=0.3 + - astra-toolbox>=1.9.9.dev5,<2.1 + - ccpi-regulariser=22.0.0 + - tomophantom=2.0.0 + - ipywidgets + - tqdm + - jinja2<3.1 + - cil-data \ No newline at end of file From 2b35fadde4d4434f810e4580a343a26c6a5cf616 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 16 Oct 2023 16:13:34 +0000 Subject: [PATCH 043/115] Maths documentation --- .../cil/optimisation/algorithms/SPDHG.py | 43 ++++++++++++++++++- 1 file changed, 41 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index daf65645e9..216af804a5 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -134,9 +134,18 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): Parameters ---------- gamma : float - parameter controlling the trade-off between the primal and dual step sizes + parameter controlling the trade-off between the primal and dual step sizes rho : float - parameter controlling the size of the product :math: \sigma\tau :math: + parameter controlling the size of the product :math: \sigma\tau :math: + + Note + ----- + The step sizes `sigma` anf `tau` are set using the equations: + .. math:: + + \sigma_i=\gamma\rho / (\|K_i\|**2)\\ + \tau = (\rho/\gamma)\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + """ if isinstance(gamma, Number): if gamma <= 0: @@ -172,6 +181,36 @@ def set_step_sizes_custom(self, sigma=None, tau=None): Step size parameter for Primal problem The user can set these or default values are calculated, either sigma, tau, both or None can be passed. + + Note + ----- + There are 4 possible cases considered by this function: + + - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: + .. math:: + + \sigma_i=0.99 / (\|K_i\|**2) + + and `tau` is set as per case 2 + + - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula + + .. math:: + + \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + + - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula + + .. math:: + + \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) + + - Case 4: Both `sigma` and `tau` are provided. + + + + + """ gamma = 1. rho = .99 From 43e6fee9a58af98cdacda89e45932cbb245875c5 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 16 Oct 2023 16:46:36 +0000 Subject: [PATCH 044/115] Some more Edo comments on sampler --- .../cil/optimisation/utilities/sampler.py | 144 ++++++++---------- docs/doc_environment.yml | 3 +- 2 files changed, 65 insertions(+), 82 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 6e3eadc607..67703308f9 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -24,29 +24,29 @@ class Sampler(): r""" - A class to select from a list of integers {0, 1, …, S-1}, with each integer representing the index of a subset - The function next() outputs a single next index from the {0,1,…,S-1} subset list. Different orders possible incl with and without replacement. To be run again and again, depending on how many iterations. + A class to select from a list of indices {0, 1, …, S-1} + The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. Parameters ---------- - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. + The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". - order: list of integers - The list of integers the method selects from using next. + order: list of indices + The list of indices the method selects from using next. shuffle= bool, default=False - If True, after each num_subsets calls of next the sampling order is shuffled randomly. + If True, the drawing order changes every each `num_indices`, otherwise the same random order each time the data is sampled is used. - prob: list of floats of length num_subsets that sum to 1. - For random sampling with replacement, this is the probability for each integer to be called by next. + prob: list of floats of length num_indices that sum to 1. + For random sampling with replacement, this is the probability for each index to be called by next. seed:int, default=None - Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. + Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. @@ -97,20 +97,20 @@ class Sampler(): The optimal choice of sampler depends on the data and the number of calls to the sampler. For random sampling with replacement, there is the possibility, with a small number of calls to the sampler that some indices will not have been selected. For the case of uniform probabilities, the default, the number of - iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `num_subsets`. + iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `num_indices`. For example, to be 99% certain that you have seen all indices, for `n=20` you should take at least 152 samples, `n=50` at least 426 samples. To be more likely than not, for `n=20` you should take 78 samples and `n=50` you should take 228 samples. - In general, we note that for a large number of samples (e.g. `>20*num_subsets`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_subsets`) the user may wish to consider - another sampling method e.g. random without replacement, which, when calling `num_subsets` samples is guaranteed to see each index exactly once. + In general, we note that for a large number of samples (e.g. `>20*num_indices`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_indices`) the user may wish to consider + another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. """ @staticmethod - def sequential(num_subsets): + def sequential(num_indices): """ Function that outputs a sampler that outputs sequentially. - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. Example ------- @@ -133,8 +133,8 @@ def sequential(num_subsets): 9 0 """ - order = list(range(num_subsets)) - sampler = Sampler(num_subsets, sampling_type='sequential', order=order) + order = list(range(num_indices)) + sampler = Sampler(num_indices, sampling_type='sequential', order=order) return sampler @staticmethod @@ -142,7 +142,7 @@ def customOrder(customlist): """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. - customlist: list of integers + customlist: list of indices The list that will be sampled from in order. Example @@ -167,18 +167,18 @@ def customOrder(customlist): [1 4 6 7 8] """ - num_subsets = len(customlist) + num_indices = len(customlist) sampler = Sampler( - num_subsets, sampling_type='custom_order', order=customlist) + num_indices, sampling_type='custom_order', order=customlist) return sampler @staticmethod - def hermanMeyer(num_subsets): + def hermanMeyer(num_indices): """ Function that takes a number of subsets and returns a sampler which outputs a Herman Meyer order - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. For Herman-Meyer sampling this number should not be prime. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. Reference ---------- @@ -229,22 +229,22 @@ def _herman_meyer_order(n): math.prod(factors[factor_n+1:]) * mapping return order - order = _herman_meyer_order(num_subsets) + order = _herman_meyer_order(num_indices) sampler = Sampler( - num_subsets, sampling_type='herman_meyer', order=order) + num_indices, sampling_type='herman_meyer', order=order) return sampler @staticmethod - def staggered(num_subsets, offset): + def staggered(num_indices, offset): """ Function that takes a number of subsets and returns a sampler which outputs in a staggered order. - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. - The offset should be less than the num_subsets + The offset should be less than the num_indices Example ------- @@ -272,24 +272,24 @@ def staggered(num_subsets, offset): 14 [ 0 4 8 12 16] """ - if offset >= num_subsets: + if offset >= num_indices: raise (ValueError('The offset should be less than the number of subsets')) - indices = list(range(num_subsets)) + indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = Sampler(num_subsets, sampling_type='staggered', order=order) + sampler = Sampler(num_indices, sampling_type='staggered', order=order) return sampler @staticmethod - def randomWithReplacement(num_subsets, prob=None, seed=None): + def randomWithReplacement(num_indices, prob=None, seed=None): """ - Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets with given probability and with replacement. + Function that takes a number of subsets and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices with given probability and with replacement. - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - prob: list of floats of length num_subsets that sum to 1. default=None - This is the probability for each integer to be called by next. If None, then the integers will be sampled uniformly. + prob: list of floats of length num_indices that sum to 1. default=None + This is the probability for each index to be called by next. If None, then the indices will be sampled uniformly. seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. @@ -314,25 +314,26 @@ def randomWithReplacement(num_subsets, prob=None, seed=None): """ if prob == None: - prob = [1/num_subsets] * num_subsets + prob = [1/num_indices] * num_indices sampler = Sampler( - num_subsets, sampling_type='random_with_replacement', prob=prob, seed=seed) + num_indices, sampling_type='random_with_replacement', prob=prob, seed=seed) return sampler @staticmethod - def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): + def randomWithoutReplacement(num_indices, seed=None, shuffle=True): """ - Function that takes a number of subsets and returns a sampler which outputs from a list of integers {0, 1, …, S-1} with S=num_subsets uniformly randomly without replacement. + Function that takes a number of subsets and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. shuffle:boolean, default=True - If True, there is a random shuffle after all the integers have been seen once, if false the same random order each time the data is sampled is used. + If True, the drawing order changes every each `num_indices`, otherwise the same random order each time the data is sampled is used. + Example ------- >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) @@ -346,37 +347,18 @@ def randomWithoutReplacement(num_subsets, seed=None, shuffle=True): [6 2 1 0 4 3 5 6 2 1 0 4 3 5 6 2] """ - order = list(range(num_subsets)) - sampler = Sampler(num_subsets, sampling_type='random_without_replacement', + order = list(range(num_indices)) + sampler = Sampler(num_indices, sampling_type='random_without_replacement', order=order, shuffle=shuffle, seed=seed) return sampler - def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=None, seed=None): + def __init__(self, num_indices, sampling_type, shuffle=False, order=None, prob=None, seed=None): """ This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. - Parameters - ---------- - num_subsets: int - The sampler will select from a list of integers {0, 1, …, S-1} with S=num_subsets. - - sampling_type:str - The sampling type used. - - order: list of integers - The list of integers the method selects from using next. - - shuffle= bool, default=False - If True, after each num_subsets calls of next, the sampling order is shuffled randomly. - - prob: list of floats of length num_subsets that sum to 1. - For random sampling with replacement, this is the probability for each integer to be called by next. - - seed:int, default=None - Random seed for the methods that use a random number generator. If set to None, the seed will be set using the current time. """ self.type = sampling_type - self.num_subsets = num_subsets + self.num_indices = num_indices if seed is not None: self.seed = seed else: @@ -392,50 +374,50 @@ def __init__(self, num_subsets, sampling_type, shuffle=False, order=None, prob=N self.prob = prob if prob is not None: self.iterator = self._next_prob - self.last_subset = self.num_subsets-1 + self.last_subset = self.num_indices-1 def _next_order(self): """ The user should call sampler.next() or next(sampler) rather than use this function. - A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. This function is used by samplers that sample without replacement. """ # print(self.last_subset) - if self.shuffle == True and self.last_subset == self.num_subsets-1: + if self.shuffle == True and self.last_subset == self.num_indices-1: self.order = self.generator.permutation(self.order) # print(self.order) - self.last_subset = (self.last_subset+1) % self.num_subsets + self.last_subset = (self.last_subset+1) % self.num_indices return (self.order[self.last_subset]) def _next_prob(self): """ The user should call sampler.next() or next(sampler) rather than use this function. - A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - This function us used by samplers that select from a list of integers {0, 1, …, S-1}, with S=num_subsets, randomly with replacement. + This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with replacement. """ - return int(self.generator.choice(self.num_subsets, 1, p=self.prob)) + return int(self.generator.choice(self.num_indices, 1, p=self.prob)) def next(self): - """ A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. """ + """ A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. """ return (self.iterator()) def __next__(self): """ - A function of the sampler that selects from a list of integers {0, 1, …, S-1}, with S=num_subsets, the next sample according to the type of sampling. + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. Allows the user to call next(sampler), to get the same result as sampler.next()""" return (self.next()) def get_samples(self, num_samples=20): """ - Function that takes an integer, num_samples, and returns the first num_samples as a numpy array. + Function that takes an index, num_samples, and returns the first num_samples as a numpy array. num_samples: int, default=20 The number of samples to return. @@ -450,7 +432,7 @@ def get_samples(self, num_samples=20): """ save_generator = self.generator save_last_subset = self.last_subset - self.last_subset = self.num_subsets-1 + self.last_subset = self.num_indices-1 save_order = self.order self.order = self.initial_order self.generator = np.random.RandomState(self.seed) diff --git a/docs/doc_environment.yml b/docs/doc_environment.yml index 89a8341e8c..1a19df766e 100644 --- a/docs/doc_environment.yml +++ b/docs/doc_environment.yml @@ -46,4 +46,5 @@ dependencies: - ipywidgets - tqdm - jinja2<3.1 - - cil-data \ No newline at end of file + - cil-data + \ No newline at end of file From f77b5538784f327a1d67cb7c9eab528acdd7f888 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 17 Oct 2023 08:32:50 +0000 Subject: [PATCH 045/115] Tried to sort the tests --- .../cil/optimisation/utilities/sampler.py | 30 ++++++++--------- Wrappers/Python/test/test_sampler.py | 32 +++++++++---------- 2 files changed, 31 insertions(+), 31 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 67703308f9..0691318840 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -175,7 +175,7 @@ def customOrder(customlist): @staticmethod def hermanMeyer(num_indices): """ - Function that takes a number of subsets and returns a sampler which outputs a Herman Meyer order + Function that takes a number of indices and returns a sampler which outputs a Herman Meyer order num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. @@ -193,7 +193,7 @@ def hermanMeyer(num_indices): """ def _herman_meyer_order(n): - # Assuming that the subsets are in geometrical order + # Assuming that the indices are in geometrical order n_variable = n i = 2 factors = [] @@ -208,7 +208,7 @@ def _herman_meyer_order(n): n_factors = len(factors) if n_factors == 0: raise ValueError( - 'Herman Meyer sampling defaults to sequential ordering if the number of subsets is prime. Please use an alternative sampling method or change the number of subsets. ') + 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') order = [0 for _ in range(n)] value = 0 for factor_n in range(n_factors): @@ -237,7 +237,7 @@ def _herman_meyer_order(n): @staticmethod def staggered(num_indices, offset): """ - Function that takes a number of subsets and returns a sampler which outputs in a staggered order. + Function that takes a number of indices and returns a sampler which outputs in a staggered order. num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -273,7 +273,7 @@ def staggered(num_indices, offset): [ 0 4 8 12 16] """ if offset >= num_indices: - raise (ValueError('The offset should be less than the number of subsets')) + raise (ValueError('The offset should be less than the number of indices')) indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] @@ -283,7 +283,7 @@ def staggered(num_indices, offset): @staticmethod def randomWithReplacement(num_indices, prob=None, seed=None): """ - Function that takes a number of subsets and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices with given probability and with replacement. + Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices with given probability and with replacement. num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -322,7 +322,7 @@ def randomWithReplacement(num_indices, prob=None, seed=None): @staticmethod def randomWithoutReplacement(num_indices, seed=None, shuffle=True): """ - Function that takes a number of subsets and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. + Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. num_indices: int @@ -374,7 +374,7 @@ def __init__(self, num_indices, sampling_type, shuffle=False, order=None, prob=N self.prob = prob if prob is not None: self.iterator = self._next_prob - self.last_subset = self.num_indices-1 + self.last_index = self.num_indices-1 def _next_order(self): """ @@ -385,12 +385,12 @@ def _next_order(self): This function is used by samplers that sample without replacement. """ - # print(self.last_subset) - if self.shuffle == True and self.last_subset == self.num_indices-1: + # print(self.last_index) + if self.shuffle == True and self.last_index == self.num_indices-1: self.order = self.generator.permutation(self.order) # print(self.order) - self.last_subset = (self.last_subset+1) % self.num_indices - return (self.order[self.last_subset]) + self.last_index = (self.last_index+1) % self.num_indices + return (self.order[self.last_index]) def _next_prob(self): """ @@ -431,13 +431,13 @@ def get_samples(self, num_samples=20): """ save_generator = self.generator - save_last_subset = self.last_subset - self.last_subset = self.num_indices-1 + save_last_index = self.last_index + self.last_index = self.num_indices-1 save_order = self.order self.order = self.initial_order self.generator = np.random.RandomState(self.seed) output = [self.next() for _ in range(num_samples)] self.generator = save_generator self.order = save_order - self.last_subset = save_last_subset + self.last_index = save_last_index return (np.array(output)) diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index f58f818f29..d751034d45 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -33,62 +33,62 @@ class TestSamplers(CCPiTestClass): def test_init(self): sampler = Sampler.sequential(10) - self.assertEqual(sampler.num_subsets, 10) + self.assertEqual(sampler.num_indices, 10) self.assertEqual(sampler.type, 'sequential') self.assertListEqual(sampler.order, list(range(10))) self.assertListEqual(sampler.initial_order, list(range(10))) self.assertEqual(sampler.shuffle, False) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 9) + self.assertEqual(sampler.last_index, 9) sampler = Sampler.randomWithoutReplacement(7, shuffle=True) - self.assertEqual(sampler.num_subsets, 7) + self.assertEqual(sampler.num_indices, 7) self.assertEqual(sampler.type, 'random_without_replacement') self.assertListEqual(sampler.order, list(range(7))) self.assertListEqual(sampler.initial_order, list(range(7))) self.assertEqual(sampler.shuffle, True) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 6) + self.assertEqual(sampler.last_index, 6) sampler = Sampler.randomWithoutReplacement(8, shuffle=False, seed=1) - self.assertEqual(sampler.num_subsets, 8) + self.assertEqual(sampler.num_indices, 8) self.assertEqual(sampler.type, 'random_without_replacement') self.assertEqual(sampler.shuffle, False) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 7) + self.assertEqual(sampler.last_index, 7) self.assertEqual(sampler.seed, 1) sampler = Sampler.hermanMeyer(12) - self.assertEqual(sampler.num_subsets, 12) + self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'herman_meyer') self.assertEqual(sampler.shuffle, False) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 11) + self.assertEqual(sampler.last_index, 11) self.assertListEqual( sampler.order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.initial_order, [ 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) sampler = Sampler.randomWithReplacement(5) - self.assertEqual(sampler.num_subsets, 5) + self.assertEqual(sampler.num_indices, 5) self.assertEqual(sampler.type, 'random_with_replacement') self.assertEqual(sampler.order, None) self.assertEqual(sampler.initial_order, None) self.assertEqual(sampler.shuffle, False) self.assertListEqual(sampler.prob, [1/5] * 5) - self.assertEqual(sampler.last_subset, 4) + self.assertEqual(sampler.last_index, 4) sampler = Sampler.randomWithReplacement(4, [0.7, 0.1, 0.1, 0.1]) - self.assertEqual(sampler.num_subsets, 4) + self.assertEqual(sampler.num_indices, 4) self.assertEqual(sampler.type, 'random_with_replacement') self.assertEqual(sampler.order, None) self.assertEqual(sampler.initial_order, None) self.assertEqual(sampler.shuffle, False) self.assertListEqual(sampler.prob, [0.7, 0.1, 0.1, 0.1]) - self.assertEqual(sampler.last_subset, 3) + self.assertEqual(sampler.last_index, 3) sampler = Sampler.staggered(21, 4) - self.assertEqual(sampler.num_subsets, 21) + self.assertEqual(sampler.num_indices, 21) self.assertEqual(sampler.type, 'staggered') self.assertListEqual(sampler.order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) @@ -96,7 +96,7 @@ def test_init(self): 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) self.assertEqual(sampler.shuffle, False) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 20) + self.assertEqual(sampler.last_index, 20) try: Sampler.staggered(22, 25) @@ -104,13 +104,13 @@ def test_init(self): self.assertTrue(True) sampler = Sampler.customOrder([1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler.num_subsets, 7) + self.assertEqual(sampler.num_indices, 7) self.assertEqual(sampler.type, 'custom_order') self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) self.assertListEqual(sampler.initial_order, [1, 4, 6, 7, 8, 9, 11]) self.assertEqual(sampler.shuffle, False) self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_subset, 6) + self.assertEqual(sampler.last_index, 6) From cf1b7f19b43ceeb9c62034ccc6da0b4af2bb9854 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 17 Oct 2023 08:58:13 +0000 Subject: [PATCH 046/115] Vaggelis comment on checks --- .../Python/cil/optimisation/operators/Operator.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/Operator.py b/Wrappers/Python/cil/optimisation/operators/Operator.py index ee46c45e3b..cc18e4fe6a 100644 --- a/Wrappers/Python/cil/optimisation/operators/Operator.py +++ b/Wrappers/Python/cil/optimisation/operators/Operator.py @@ -72,12 +72,12 @@ def norm(self, **kwargs): def set_norm(self, norm=None): '''Sets the norm of the operator to a custom value. ''' - try: - if norm is not None and norm <=0: - raise ValueError("Norm must be a positive real value or None, got {}".format(norm)) - except TypeError: - raise TypeError("Norm must be a positive real value or None, got {} of type {}".format(norm, type(norm))) - + + if norm is not None and isinstance(norm, Number) is False: + raise TypeError("Norm must be a number or None, got {} of type {}".format(norm, type(norm))) + + if isinstance(norm, Number) and norm <=0: + raise ValueError("Norm must be a positive real valued number or None, got {}".format(norm)) self._norm = norm From c2c4df9fed19b4508ed1b0ffbe5752215c6bedbe Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 17 Oct 2023 09:53:54 +0000 Subject: [PATCH 047/115] Change to jinja version in doc_environment.yml --- docs/doc_environment.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/doc_environment.yml b/docs/doc_environment.yml index 1a19df766e..2fd8ca35e5 100644 --- a/docs/doc_environment.yml +++ b/docs/doc_environment.yml @@ -45,6 +45,6 @@ dependencies: - tomophantom=2.0.0 - ipywidgets - tqdm - - jinja2<3.1 + - jinja2=3.03 - cil-data \ No newline at end of file From d11296f76b7475bdcf85cf5202d65cf6ec4f8baf Mon Sep 17 00:00:00 2001 From: lauramurgatroyd Date: Wed, 18 Oct 2023 10:40:07 +0100 Subject: [PATCH 048/115] Revert changes to docs_environment.yml --- docs/doc_environment.yml | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/docs/doc_environment.yml b/docs/doc_environment.yml index 2fd8ca35e5..07adaa7426 100644 --- a/docs/doc_environment.yml +++ b/docs/doc_environment.yml @@ -45,6 +45,5 @@ dependencies: - tomophantom=2.0.0 - ipywidgets - tqdm - - jinja2=3.03 + - jinja2<3.1 - cil-data - \ No newline at end of file From 32e057b03831de3caab91e7b09749cda196e6287 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 18 Oct 2023 10:22:42 +0000 Subject: [PATCH 049/115] Docstring change --- Wrappers/Python/cil/optimisation/operators/BlockOperator.py | 3 +-- Wrappers/Python/test/test_Operator.py | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 2309dc1b37..554897c351 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -141,8 +141,7 @@ def get_item(self, row, col): return self.operators[index] def norm(self): - '''Returns the square root of the sum of the norms of the individual operators in the BlockOperators - ''' + '''Returns the Euclidean norm of the norms of the individual operators in the BlockOperators ''' return numpy.sqrt(numpy.sum(numpy.array(self.get_norms())**2)) def get_norms(self, ): diff --git a/Wrappers/Python/test/test_Operator.py b/Wrappers/Python/test/test_Operator.py index 4eee146def..fc289c019d 100644 --- a/Wrappers/Python/test/test_Operator.py +++ b/Wrappers/Python/test/test_Operator.py @@ -679,7 +679,7 @@ def test_BlockOperator(self): self.assertNumpyArrayEqual(res.get_item(1).as_array(), 4 * u.as_array()) - + x1 = B.adjoint(z1) # this should be [15 u, 10 u] el1 = B.get_item(0,0).adjoint(z1.get_item(0)) + B.get_item(1,0).adjoint(z1.get_item(1)) From 4e0ca6a6ae6b50f99b8a20003d9be3bcb2b802b1 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 18 Oct 2023 10:28:42 +0000 Subject: [PATCH 050/115] Docstring change --- Wrappers/Python/cil/optimisation/operators/BlockOperator.py | 4 ---- 1 file changed, 4 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 554897c351..fb8ae11167 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -349,10 +349,6 @@ def range_geometry(self): tmp.append(self.get_item(i, 0).range_geometry()) return BlockGeometry(*tmp) - # shape = (self.shape[1], 1) - # return BlockGeometry(*[el.range_geometry() for el in self.operators], - # shape=shape) - def sum_abs_row(self): res = [] From 87f1a00310b1d0a2267710d422d728b333e23e58 Mon Sep 17 00:00:00 2001 From: lauramurgatroyd Date: Wed, 18 Oct 2023 11:58:30 +0100 Subject: [PATCH 051/115] Revert naming of docs environment file --- docs/{doc_environment.yml => docs_environment.yml} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename docs/{doc_environment.yml => docs_environment.yml} (100%) diff --git a/docs/doc_environment.yml b/docs/docs_environment.yml similarity index 100% rename from docs/doc_environment.yml rename to docs/docs_environment.yml From 2ff165a261484de0654da54d3dbea41f4b1882c8 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 18 Oct 2023 14:15:44 +0000 Subject: [PATCH 052/115] Updated changelog --- CHANGELOG.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 349e90a9c7..0bf6d85168 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,7 @@ +*xx.x.x + - Added the functions `set_norms` and `get_norms` to the `BlockOperator` class + * 23.1.0 - Fix bug in IndicatorBox proximal_conjugate - Allow CCPi Regulariser functions for non CIL object From 81fc7e2aa7787d906b6687b4e7d5d8f398cdff52 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 18 Oct 2023 14:17:21 +0000 Subject: [PATCH 053/115] Updated changelog --- CHANGELOG.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0bf6d85168..36ff528404 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,7 @@ *xx.x.x - - Added the functions `set_norms` and `get_norms` to the `BlockOperator` class + - Added the a `Sampler` class as a CIL optimisation utility + - Updated the `SPDHG` algorithm to take a stochastic `Sampler` and to more easily set step sizes * 23.1.0 - Fix bug in IndicatorBox proximal_conjugate From 8f100e0fe71eca523a070a2ab810dd87044173ee Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 18 Oct 2023 14:17:55 +0000 Subject: [PATCH 054/115] Updated changelog --- CHANGELOG.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 349e90a9c7..dccff500fb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,6 @@ - +* xx.x.x + - Added the functions `set_norms` and `get_norms` to the `BlockOperator` class + - * 23.1.0 - Fix bug in IndicatorBox proximal_conjugate - Allow CCPi Regulariser functions for non CIL object From 381342c0086c5cf4dc4bbd6af70fb0f293e5cea9 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 25 Oct 2023 10:20:04 +0000 Subject: [PATCH 055/115] Changes to docstring --- Wrappers/Python/cil/optimisation/operators/BlockOperator.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index fb8ae11167..3cfa676f28 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -151,6 +151,9 @@ def get_norms(self, ): def set_norms(self, norms): '''Uses the set_norm() function in Operator to set the norms of the operators in the BlockOperator from a list of custom values. + + Args: + :param: norms (:obj:`list`): A list of positive real values the same length as the number of operators in the BlockOperator. ''' if len(norms) != len(self): raise ValueError( From 876d4c99c805c83ac6efe1678d6ae0cb793dd1ef Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 26 Oct 2023 17:01:45 +0100 Subject: [PATCH 056/115] Added size to the BlockOperator --- .../Python/cil/optimisation/operators/BlockOperator.py | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 3cfa676f28..3126507a88 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -155,7 +155,7 @@ def set_norms(self, norms): Args: :param: norms (:obj:`list`): A list of positive real values the same length as the number of operators in the BlockOperator. ''' - if len(norms) != len(self): + if len(norms) != self.size: raise ValueError( "The length of the list of norms should be equal to the number of operators in the BlockOperator") @@ -384,8 +384,13 @@ def sum_abs_col(self): return BlockDataContainer(*res) def __len__(self): - return len(self.operators) + + @property + def size(self): + return len(self.operators) + + def __getitem__(self, index): '''returns the index-th operator in the block irrespectively of it's shape''' From b983e2f92f92c3cc706ba103ea4b8adb0ac389f6 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 31 Oct 2023 11:42:34 +0000 Subject: [PATCH 057/115] Removed precalculated_norms and pull the prob_weights from the sampler --- .../cil/optimisation/algorithms/SPDHG.py | 77 ++++++------------- .../cil/optimisation/utilities/sampler.py | 19 +++-- Wrappers/Python/test/test_algorithms.py | 4 +- 3 files changed, 37 insertions(+), 63 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 216af804a5..82f4ff8b8f 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -24,7 +24,7 @@ import logging from cil.optimisation.utilities import Sampler from numbers import Number - +import numpy as np class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -49,19 +49,16 @@ class SPDHG(Algorithm): List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - gamma : float parameter controlling the trade-off between the primal and dual step sizes sampler: an instance of a `cil.optimisation.utilities.Sampler` class Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets - precalculated_norms : list of floats - precalculated list of norms of the operators #TODO: to remove based on pull request #1513 **kwargs: prob : list of floats, optional, default=None List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ norms : list of floats - precalculated list of norms of the operators. To be deprecated - replaced by precalculated_norms + precalculated list of norms of the operators. To be deprecated and placed by the `set_norms` functionalist in a BlockOperator. Example ------- @@ -99,27 +96,30 @@ class SPDHG(Algorithm): ''' def __init__(self, f=None, g=None, operator=None, - initial=None, precalculated_norms=None, sampler=None, **kwargs): + initial=None, sampler=None, **kwargs): super(SPDHG, self).__init__(**kwargs) - if precalculated_norms is None and kwargs.get('prob') is not None: - precalculated_norms = kwargs.get('norms', None) + if kwargs.get('norms', None) is not None: + operator.set_norms(kwargs.get('norms')) warnings.warn( - 'norms is being deprecated, pass instead precalculated_norms=your_custom_norms') + ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') + if sampler is not None: - self.prob_weights = sampler.prob + if kwargs.get('prob', None) is not None: + warnings.warn('`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') else: if kwargs.get('prob', None) is not None: - warnings.warn('prob is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob)') - self.prob_weights = kwargs.get('prob', [1/len(operator)]*len(operator)) - sampler=Sampler.randomWithReplacement(len(operator), prob=self.prob_weights) + warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') + sampler=Sampler.randomWithReplacement(len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) - if f is not None and operator is not None and g is not None: + if f is not None and operator is not None and g is not None and sampler is not None: self.set_up(f=f, g=g, operator=operator, - initial=initial, sampler=sampler, precalculated_norms=precalculated_norms) + initial=initial, sampler=sampler) + + @property def sigma(self): return self._sigma @@ -273,7 +273,7 @@ def check_convergence(self): return False def set_up(self, f, g, operator, - initial=None, sampler=None, precalculated_norms=None): + initial=None, sampler=None): '''set-up of the algorithm Parameters ---------- @@ -293,8 +293,6 @@ def set_up(self, f, g, operator, parameter controlling the trade-off between the primal and dual step sizes sampler: an instance of a `cil.optimisation.utilities.Sampler` class Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets - precalculated_norms : list of floats - precalculated list of norms of the operators ''' logging.info("{} setting up".format(self.__class__.__name__, )) @@ -303,41 +301,14 @@ def set_up(self, f, g, operator, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - - if precalculated_norms is None: - # Compute norm of each sub-operator - self.norms = [self.operator.get_item(i, 0).norm() - for i in range(self.ndual_subsets)] - else: - if len(precalculated_norms) == self.ndual_subsets: - if all(isinstance(x, Number) for x in precalculated_norms): - if all(x > 0 for x in precalculated_norms): - pass - else: - raise ValueError( - "The norms of the operators should be positive") - else: - raise ValueError( - "The norms of the operators should be a Number") - else: - raise ValueError( - "Please pass a list of floats to the precalculated norms with the same number of entries as number of operators") - self.norms = precalculated_norms - - if sampler is None: - if self.prob_weights is None: - self.prob_weights = [1/self.ndual_subsets] * self.ndual_subsets - self.sampler = Sampler.randomWithReplacement( - self.ndual_subsets, prob=self.prob_weights) - else: - if not isinstance(sampler, Sampler): - raise ValueError( - "The sampler should be an instance of the cil.optimisation.utilities.Sampler class") - self.sampler = sampler - if sampler.prob is None: - self.prob_weights = [1/self.ndual_subsets] * self.ndual_subsets - else: - self.prob_weights = sampler.prob + self.sampler=sampler + self.norms = operator.get_norms() + + self.prob_weights=sampler.prob_weights #TODO: write unit tests for this #TODO: consider the case it is uniform and not saving the array + if self.prob_weights is None: + x=sampler.get_sampler(10000) + self.prob_weights=[np.count_nonzero((x==i)) for i in range(len(operator))] + self.prob_weights/=sum(self.prob_weights) # might not want to do this until it is called (if computationally expensive) self.set_step_sizes_default() diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 0691318840..a19a946de4 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -48,6 +48,8 @@ class Sampler(): seed:int, default=None Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. + prob_weights: list of floats of length num_indices that sum to 1. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example @@ -134,7 +136,7 @@ def sequential(num_indices): 0 """ order = list(range(num_indices)) - sampler = Sampler(num_indices, sampling_type='sequential', order=order) + sampler = Sampler(num_indices, sampling_type='sequential', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod @@ -167,9 +169,9 @@ def customOrder(customlist): [1 4 6 7 8] """ - num_indices = len(customlist) + num_indices = len(customlist)#TODO: is this an issue sampler = Sampler( - num_indices, sampling_type='custom_order', order=customlist) + num_indices, sampling_type='custom_order', order=customlist, prob_weights=None)#TODO: return sampler @staticmethod @@ -231,7 +233,7 @@ def _herman_meyer_order(n): order = _herman_meyer_order(num_indices) sampler = Sampler( - num_indices, sampling_type='herman_meyer', order=order) + num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod @@ -277,7 +279,7 @@ def staggered(num_indices, offset): indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = Sampler(num_indices, sampling_type='staggered', order=order) + sampler = Sampler(num_indices, sampling_type='staggered', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod @@ -316,7 +318,7 @@ def randomWithReplacement(num_indices, prob=None, seed=None): if prob == None: prob = [1/num_indices] * num_indices sampler = Sampler( - num_indices, sampling_type='random_with_replacement', prob=prob, seed=seed) + num_indices, sampling_type='random_with_replacement', prob=prob, seed=seed, prob_weights=prob) return sampler @staticmethod @@ -349,14 +351,15 @@ def randomWithoutReplacement(num_indices, seed=None, shuffle=True): order = list(range(num_indices)) sampler = Sampler(num_indices, sampling_type='random_without_replacement', - order=order, shuffle=shuffle, seed=seed) + order=order, shuffle=shuffle, seed=seed, prob_weights=[1/num_indices]*num_indices) return sampler - def __init__(self, num_indices, sampling_type, shuffle=False, order=None, prob=None, seed=None): + def __init__(self, num_indices, sampling_type, shuffle=False, order=None, prob=None, seed=None, prob_weights=None): """ This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. """ + self.prob_weights=prob_weights self.type = sampling_type self.num_indices = num_indices if seed is not None: diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index e21d8c14d8..1c372c0306 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -830,9 +830,9 @@ def test_SPDHG_defaults_and_setters(self): def test_spdhg_non_default_init(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10, precalculated_norms=[1]*self.subsets ) + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) - self.assertListEqual(spdhg.norms, [1]*self.subsets) + self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) self.assertTrue(isinstance(spdhg.sampler, Sampler)) self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) From 71cbdf9c03f2afb8d937ba45857121082b0d3cd8 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 31 Oct 2023 12:11:20 +0000 Subject: [PATCH 058/115] Changes to setting tau and new unit test --- .../cil/optimisation/algorithms/SPDHG.py | 18 ++++++++++-------- Wrappers/Python/test/test_algorithms.py | 10 ++++++++++ 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 82f4ff8b8f..eaee7ce942 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -165,9 +165,9 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): "We currently only support scalar values of gamma") self._sigma = [gamma * rho / ni for ni in self.norms] - - self._tau = min([pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)]) + values=[pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)] + self._tau = min([value for value in values if value>1e-6]) #TODO: what value should this be self._tau *= (rho / gamma) def set_step_sizes_custom(self, sigma=None, tau=None): @@ -237,8 +237,9 @@ def set_step_sizes_custom(self, sigma=None, tau=None): gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] if tau is None: - self._tau = min([pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)]) + values=[pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)] + self._tau = min([value for value in values if value>1e-6]) #TODO: what value should this be self._tau *= (rho / gamma) else: if isinstance(tau, Number): @@ -304,11 +305,12 @@ def set_up(self, f, g, operator, self.sampler=sampler self.norms = operator.get_norms() - self.prob_weights=sampler.prob_weights #TODO: write unit tests for this #TODO: consider the case it is uniform and not saving the array + self.prob_weights=sampler.prob_weights #TODO: consider the case it is uniform and not saving the array if self.prob_weights is None: - x=sampler.get_sampler(10000) + x=sampler.get_samples(10000) self.prob_weights=[np.count_nonzero((x==i)) for i in range(len(operator))] - self.prob_weights/=sum(self.prob_weights) + total=sum(self.prob_weights) + self.prob_weights[:] = [x / total for x in self.prob_weights] # might not want to do this until it is called (if computationally expensive) self.set_step_sizes_default() diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 1c372c0306..f582ca3181 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -838,6 +838,16 @@ def test_spdhg_non_default_init(self): self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) self.assertEqual(spdhg.max_iteration, 1000) self.assertEqual(spdhg.update_objective_interval, 10) + + def test_spdhg_custom_sampler(self): + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.customOrder([0,0,0,0]), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + self.assertListEqual(spdhg.prob_weights, [1]+[0]*(len(self.A)-1)) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.customOrder([0,1,0,1]), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + self.assertListEqual(spdhg.prob_weights, [.5]+[.5]+[0]*(len(self.A)-2)) + + def test_spdhg_check_convergence(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) From f0f4de3cbcb6f5fbc8ce061fc345d3a8f50a18a2 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 2 Nov 2023 17:38:53 +0000 Subject: [PATCH 059/115] Changes after discussion with Edo and Gemma --- .../optimisation/operators/BlockOperator.py | 38 +++++++++---------- .../cil/optimisation/operators/Operator.py | 15 +++++--- Wrappers/Python/test/test_BlockOperator.py | 10 ++--- 3 files changed, 32 insertions(+), 31 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 3cfa676f28..8bb92e734b 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -56,16 +56,11 @@ class BlockOperator(Operator): def __init__(self, *args, **kwargs): ''' - Class creator + This is the class creator. - Note: - Do not include the `self` parameter in the ``Args`` section. - - Args: + Parameters: :param: vararg (Operator): Operators in the block. - :param: shape (:obj:`tuple`, optional): If shape is passed the Operators in - vararg are considered input in a row-by-row fashion. - Shape and number of Operators must match. + :param: shape (:obj:`tuple`, optional): If shape is passed the Operators in vararg are considered input in a row-by-row fashion. Note that shape and number of Operators must match. Example: BlockOperator(op0,op1) results in a row block @@ -129,7 +124,7 @@ def row_wise_compatible(self): return compatible def get_item(self, row, col): - '''returns the Operator at specified row and col''' + '''Returns the Operator at specified row and col''' if row > self.shape[0]: raise ValueError( 'Requested row {} > max {}'.format(row, self.shape[0])) @@ -142,9 +137,9 @@ def get_item(self, row, col): def norm(self): '''Returns the Euclidean norm of the norms of the individual operators in the BlockOperators ''' - return numpy.sqrt(numpy.sum(numpy.array(self.get_norms())**2)) + return numpy.sqrt(numpy.sum(numpy.array(self.get_norms_as_list())**2)) - def get_norms(self, ): + def get_norms_as_list(self, ): '''Returns a list of the individual norms of the Operators in the BlockOperator ''' return [op.norm() for op in self.operators] @@ -153,7 +148,8 @@ def set_norms(self, norms): '''Uses the set_norm() function in Operator to set the norms of the operators in the BlockOperator from a list of custom values. Args: - :param: norms (:obj:`list`): A list of positive real values the same length as the number of operators in the BlockOperator. + + param norms (:obj:`list`): A list of positive real values the same length as the number of operators in the BlockOperator. ''' if len(norms) != len(self): raise ValueError( @@ -294,7 +290,9 @@ def get_output_shape(self, xshape, adjoint=False): def __rmul__(self, scalar): '''Defines the left multiplication with a scalar - :paramer scalar: (number or iterable containing numbers): + Args: + + :`scalar`: (number or iterable containing numbers): Returns: a block operator with Scaled Operators inside''' if isinstance(scalar, list) or isinstance(scalar, tuple) or \ @@ -312,9 +310,9 @@ def __rmul__(self, scalar): @property def T(self): - '''Return the transposed of self - - input in a row-by-row''' + '''Returns the transposed of self. + + Recall the input list is shaped in a row-by-row fashion''' newshape = (self.shape[1], self.shape[0]) oplist = [] for col in range(newshape[1]): @@ -323,7 +321,7 @@ def T(self): return type(self)(*oplist, shape=newshape) def domain_geometry(self): - '''returns the domain of the BlockOperator + '''Returns the domain of the BlockOperator If the shape of the BlockOperator is (N,1) the domain is a ImageGeometry or AcquisitionGeometry. Otherwise it is a BlockGeometry. @@ -345,7 +343,7 @@ def domain_geometry(self): # shape=self.shape) def range_geometry(self): - '''returns the range of the BlockOperator''' + '''Returns the range of the BlockOperator''' tmp = [] for i in range(self.shape[0]): @@ -388,9 +386,9 @@ def __len__(self): return len(self.operators) def __getitem__(self, index): - '''returns the index-th operator in the block irrespectively of it's shape''' + '''Returns the index-th operator in the block irrespectively of it's shape''' return self.operators[index] def get_as_list(self): - '''returns the list of operators''' + '''Returns the list of operators''' return self.operators diff --git a/Wrappers/Python/cil/optimisation/operators/Operator.py b/Wrappers/Python/cil/optimisation/operators/Operator.py index cc18e4fe6a..c10032fca2 100644 --- a/Wrappers/Python/cil/optimisation/operators/Operator.py +++ b/Wrappers/Python/cil/optimisation/operators/Operator.py @@ -72,12 +72,15 @@ def norm(self, **kwargs): def set_norm(self, norm=None): '''Sets the norm of the operator to a custom value. ''' - - if norm is not None and isinstance(norm, Number) is False: - raise TypeError("Norm must be a number or None, got {} of type {}".format(norm, type(norm))) - - if isinstance(norm, Number) and norm <=0: - raise ValueError("Norm must be a positive real valued number or None, got {}".format(norm)) + + if norm is not None: + if isinstance(norm, Number): + if norm <= 0: + raise ValueError( + "Norm must be a positive real valued number or None, got {}".format(norm)) + else: + raise TypeError( + "Norm must be a number or None, got {} of type {}".format(norm, type(norm))) self._norm = norm diff --git a/Wrappers/Python/test/test_BlockOperator.py b/Wrappers/Python/test/test_BlockOperator.py index 0cfaacffa5..34219054e8 100644 --- a/Wrappers/Python/test/test_BlockOperator.py +++ b/Wrappers/Python/test/test_BlockOperator.py @@ -45,14 +45,14 @@ def test_norms(self): self.assertAlmostEqual(G.norm(), numpy.sqrt(8), 2) self.assertAlmostEqual(G2.norm(), numpy.sqrt(8), 2) self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) - self.assertAlmostEqual(A.get_norms()[0], numpy.sqrt(8), 2) - self.assertAlmostEqual(A.get_norms()[1], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms_as_list()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms_as_list()[1], numpy.sqrt(8), 2) #sets_norm A.set_norms([2,3]) #gets cached norm - self.assertListEqual(A.get_norms(), [2,3], 2) + self.assertListEqual(A.get_norms_as_list(), [2,3], 2) self.assertEqual(A.norm(), numpy.sqrt(13)) @@ -64,8 +64,8 @@ def test_norms(self): A.set_norms([None, None]) #recalculates norm self.assertAlmostEqual(A.norm(), numpy.sqrt(16), 2) - self.assertAlmostEqual(A.get_norms()[0], numpy.sqrt(8), 2) - self.assertAlmostEqual(A.get_norms()[1], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms_as_list()[0], numpy.sqrt(8), 2) + self.assertAlmostEqual(A.get_norms_as_list()[1], numpy.sqrt(8), 2) #Check the warnings on set_norms #Check the length of list that is passed From 26584c94206b12765b8ed4281b5dbf86d89fdb75 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 2 Nov 2023 17:51:46 +0000 Subject: [PATCH 060/115] Documentation changes --- Wrappers/Python/cil/optimisation/operators/BlockOperator.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 1cd1d8a4b6..a0575c8825 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -263,11 +263,11 @@ def adjoint(self, x, out=None): ) def is_linear(self): - '''returns whether all the elements of the BlockOperator are linear''' + '''Returns whether all the elements of the BlockOperator are linear''' return functools.reduce(lambda x, y: x and y.is_linear(), self.operators, True) def get_output_shape(self, xshape, adjoint=False): - '''returns the shape of the output BlockDataContainer + '''Returns the shape of the output BlockDataContainer A(N,M) direct u(M,1) -> N,1 A(N,M)^T adjoint u(N,1) -> M,1 From d182423403a20b2d90eb359a2c6cfccc11239985 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 3 Nov 2023 13:24:02 +0000 Subject: [PATCH 061/115] Changes to SPDHG with block_norms --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index eaee7ce942..ee694f32d7 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -303,7 +303,7 @@ def set_up(self, f, g, operator, self.operator = operator self.ndual_subsets = self.operator.shape[0] self.sampler=sampler - self.norms = operator.get_norms() + self.norms = operator.get_norms_as_list() self.prob_weights=sampler.prob_weights #TODO: consider the case it is uniform and not saving the array if self.prob_weights is None: From ad86a5802679642afc02e1979f38cc5fd9661624 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 6 Nov 2023 13:02:50 +0000 Subject: [PATCH 062/115] Started setting up factory methods --- .../cil/optimisation/utilities/sampler.py | 385 +++++++++++++----- Wrappers/Python/test/test_sampler.py | 143 +++---- 2 files changed, 349 insertions(+), 179 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index a19a946de4..5631d511de 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -20,6 +20,255 @@ import math import time +class SamplerFromFunction(): + def __init__(self, num_indices,function, sampling_type='from_function', prob_weights=None): + """ + TODO: How should a user call this? + A class to select from a list of indices {0, 1, …, S-1} + The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + + + Parameters + ---------- + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + + sampling_type:str + The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + + + function: TODO: + + + prob_weights: list of floats of length num_indices that sum to 1. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + + """ + self.sampling_type=sampling_type + self.num_indices=num_indices + self.function=function + self.prob_weights=prob_weights + if self.prob_weights is None: + self.prob_weights=[1/num_indices]*num_indices + self.iteration_number=-1 + + + + def next(self): + """ + + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + """ + + self.iteration_number+=1 + return (self.function(self.iteration_number)) + + def __next__(self): + """ + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + Allows the user to call next(sampler), to get the same result as sampler.next()""" + return (self.next()) + + def get_samples(self, num_samples=20): + """ + Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + + num_samples: int, default=20 + The number of samples to return. + + Example + ------- + + >>> sampler=Sampler.randomWithReplacement(5) + >>> print(sampler.get_samples()) + [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] + """ + save_last_index = self.iteration_number + self.iteration_number = -1 + output = [self.next() for _ in range(num_samples)] + self.iteration_number = save_last_index + return (np.array(output)) + + +class SamplerFromOrder(): + + def __init__(self, num_indices, order, sampling_type, prob_weights=None): + + """ + TODO: How should a user call this? + A class to select from a list of indices {0, 1, …, S-1} + The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + + + Parameters + ---------- + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + + sampling_type:str + The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + + order: list of indices + The list of indices the method selects from using next. + + + prob_weights: list of floats of length num_indices that sum to 1. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + + + """ + self.prob_weights=prob_weights + self.type = sampling_type + self.num_indices = num_indices + self.order = order + self.initial_order = self.order + + + self.last_index = len(order)-1 + + + + def next(self): + """ + + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + """ + + self.last_index = (self.last_index+1) % len(self.order) + return (self.order[self.last_index]) + + def __next__(self): + """ + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + Allows the user to call next(sampler), to get the same result as sampler.next()""" + return (self.next()) + + def get_samples(self, num_samples=20): + """ + Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + + num_samples: int, default=20 + The number of samples to return. + + Example + ------- + + >>> sampler=Sampler.randomWithReplacement(5) + >>> print(sampler.get_samples()) + [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] + + """ + save_last_index = self.last_index + self.last_index = len(self.order)-1 + output = [self.next() for _ in range(num_samples)] + self.last_index = save_last_index + return (np.array(output)) + + +class SamplerRandom(): + + r""" + A class to select from a list of indices {0, 1, …, S-1} using numpy.random.choice with and without replacement. + The function next() outputs a single next index from the list {0,1,…,S-1} . To be run again and again, depending on how many iterations. + + + Parameters + ---------- + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + + sampling_type:str + The sampling type used. + + + replace= bool + If True, sample with replace, otherwise sample without replacement + + + prob: list of floats of length num_indices that sum to 1. + For random sampling with replacement, this is the probability for each index to be called by next. + + seed:int, default=None + Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. + + prob_weights: list of floats of length num_indices that sum to 1. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + + """ + def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): + """ + This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. + + """ + + self.replace=replace + self.prob=prob + if prob is None: + self.prob=[1/num_indices]*num_indices + if replace: + self.prob_weights=prob + else: + self.prob_weights=[1/num_indices]*num_indices + self.type = sampling_type + self.num_indices = num_indices + if seed is not None: + self.seed = seed + else: + self.seed = int(time.time()) + self.generator = np.random.RandomState(self.seed) + + + + + def next(self): + """ + + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with and without replacement. + + """ + if self.replace: + return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) + else: + return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) + + + + def __next__(self): + """ + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + Allows the user to call next(sampler), to get the same result as sampler.next()""" + return (self.next()) + + def get_samples(self, num_samples=20): + """ + Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + + num_samples: int, default=20 + The number of samples to return. + + Example + ------- + + >>> sampler=Sampler.randomWithReplacement(5) + >>> print(sampler.get_samples()) + [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] + + """ + save_generator = self.generator + self.generator = np.random.RandomState(self.seed) + output = [self.next() for _ in range(num_samples)] + self.generator = save_generator + return (np.array(output)) class Sampler(): @@ -39,9 +288,6 @@ class Sampler(): order: list of indices The list of indices the method selects from using next. - shuffle= bool, default=False - If True, the drawing order changes every each `num_indices`, otherwise the same random order each time the data is sampled is used. - prob: list of floats of length num_indices that sum to 1. For random sampling with replacement, this is the probability for each index to be called by next. @@ -136,21 +382,23 @@ def sequential(num_indices): 0 """ order = list(range(num_indices)) - sampler = Sampler(num_indices, sampling_type='sequential', order=order, prob_weights=[1/num_indices]*num_indices) + sampler = SamplerFromOrder(num_indices, sampling_type='sequential', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod - def customOrder(customlist): + def customOrder(num_indices, customlist, prob_weights=None): #TODO: swap to underscores """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. customlist: list of indices The list that will be sampled from in order. + #TODO: + Example -------- - >>> sampler=Sampler.customOrder([1,4,6,7,8,9,11]) + >>> sampler=Sampler.customOrder(12,[1,4,6,7,8,9,11]) >>> print(sampler.get_samples(11)) >>> for _ in range(9): >>> print(sampler.next()) @@ -169,9 +417,15 @@ def customOrder(customlist): [1 4 6 7 8] """ - num_indices = len(customlist)#TODO: is this an issue - sampler = Sampler( - num_indices, sampling_type='custom_order', order=customlist, prob_weights=None)#TODO: + if prob_weights is None: + temp_list=[] + for i in range(num_indices): + temp_list.append(customlist.count(i)) + total=sum(temp_list) + prob_weights=[x/total for x in temp_list] + + sampler = SamplerFromOrder( + num_indices, sampling_type='custom_order', order=customlist, prob_weights=prob_weights) return sampler @staticmethod @@ -232,7 +486,7 @@ def _herman_meyer_order(n): return order order = _herman_meyer_order(num_indices) - sampler = Sampler( + sampler = SamplerFromOrder( num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @@ -279,7 +533,7 @@ def staggered(num_indices, offset): indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = Sampler(num_indices, sampling_type='staggered', order=order, prob_weights=[1/num_indices]*num_indices) + sampler = SamplerFromOrder(num_indices, sampling_type='staggered', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod @@ -317,12 +571,12 @@ def randomWithReplacement(num_indices, prob=None, seed=None): if prob == None: prob = [1/num_indices] * num_indices - sampler = Sampler( - num_indices, sampling_type='random_with_replacement', prob=prob, seed=seed, prob_weights=prob) + sampler = SamplerRandom( + num_indices, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) return sampler @staticmethod - def randomWithoutReplacement(num_indices, seed=None, shuffle=True): + def randomWithoutReplacement(num_indices, seed=None, prob=None): """ Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. @@ -333,8 +587,6 @@ def randomWithoutReplacement(num_indices, seed=None, shuffle=True): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - shuffle:boolean, default=True - If True, the drawing order changes every each `num_indices`, otherwise the same random order each time the data is sampled is used. Example ------- @@ -342,105 +594,34 @@ def randomWithoutReplacement(num_indices, seed=None, shuffle=True): >>> print(sampler.get_samples(16)) [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] - Example - ------- - >>> sampler=Sampler.randomWithoutReplacement(7, seed=1, shuffle=False) - >>> print(sampler.get_samples(16)) - [6 2 1 0 4 3 5 6 2 1 0 4 3 5 6 2] - """ - order = list(range(num_indices)) - sampler = Sampler(num_indices, sampling_type='random_without_replacement', - order=order, shuffle=shuffle, seed=seed, prob_weights=[1/num_indices]*num_indices) - return sampler - - def __init__(self, num_indices, sampling_type, shuffle=False, order=None, prob=None, seed=None, prob_weights=None): """ - This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. - """ - self.prob_weights=prob_weights - self.type = sampling_type - self.num_indices = num_indices - if seed is not None: - self.seed = seed - else: - self.seed = int(time.time()) - self.generator = np.random.RandomState(self.seed) - self.order = order - if order is not None: - self.iterator = self._next_order - self.shuffle = shuffle - if self.type == 'random_without_replacement' and self.shuffle == False: - self.order = self.generator.permutation(self.order) - self.initial_order = self.order - self.prob = prob - if prob is not None: - self.iterator = self._next_prob - self.last_index = self.num_indices-1 - - def _next_order(self): - """ - The user should call sampler.next() or next(sampler) rather than use this function. - - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - This function is used by samplers that sample without replacement. + sampler = SamplerRandom(num_indices, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob ) + return sampler + @staticmethod + def from_function(num_indices, function): """ - # print(self.last_index) - if self.shuffle == True and self.last_index == self.num_indices-1: - self.order = self.generator.permutation(self.order) - # print(self.order) - self.last_index = (self.last_index+1) % self.num_indices - return (self.order[self.last_index]) - - def _next_prob(self): - """ - The user should call sampler.next() or next(sampler) rather than use this function. + Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices TODO: - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with replacement. - - """ - return int(self.generator.choice(self.num_indices, 1, p=self.prob)) - def next(self): - """ A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. """ + num_indices: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - return (self.iterator()) + function: TODO: - def __next__(self): - """ - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + + Example + ------- + TODO: - Allows the user to call next(sampler), to get the same result as sampler.next()""" - return (self.next()) - def get_samples(self, num_samples=20): """ - Function that takes an index, num_samples, and returns the first num_samples as a numpy array. - num_samples: int, default=20 - The number of samples to return. + sampler = SamplerFromFunction(num_indices, sampling_type='random_without_replacement', function=function ) + return sampler - Example - ------- - >>> sampler=Sampler.randomWithReplacement(5) - >>> print(sampler.get_samples()) - [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] - """ - save_generator = self.generator - save_last_index = self.last_index - self.last_index = self.num_indices-1 - save_order = self.order - self.order = self.initial_order - self.generator = np.random.RandomState(self.seed) - output = [self.next() for _ in range(num_samples)] - self.generator = save_generator - self.order = save_order - self.last_index = save_last_index - return (np.array(output)) + \ No newline at end of file diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index d751034d45..3de70afd05 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -37,55 +37,43 @@ def test_init(self): self.assertEqual(sampler.type, 'sequential') self.assertListEqual(sampler.order, list(range(10))) self.assertListEqual(sampler.initial_order, list(range(10))) - self.assertEqual(sampler.shuffle, False) - self.assertEqual(sampler.prob, None) self.assertEqual(sampler.last_index, 9) + self.assertListEqual(sampler.prob_weights, [1/10]*10) - sampler = Sampler.randomWithoutReplacement(7, shuffle=True) + sampler = Sampler.randomWithoutReplacement(7) self.assertEqual(sampler.num_indices, 7) self.assertEqual(sampler.type, 'random_without_replacement') - self.assertListEqual(sampler.order, list(range(7))) - self.assertListEqual(sampler.initial_order, list(range(7))) - self.assertEqual(sampler.shuffle, True) - self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_index, 6) + self.assertEqual(sampler.prob, [1/7]*7) + self.assertListEqual(sampler.prob_weights, sampler.prob) - sampler = Sampler.randomWithoutReplacement(8, shuffle=False, seed=1) + sampler = Sampler.randomWithoutReplacement(8, seed=1) self.assertEqual(sampler.num_indices, 8) self.assertEqual(sampler.type, 'random_without_replacement') - self.assertEqual(sampler.shuffle, False) - self.assertEqual(sampler.prob, None) - self.assertEqual(sampler.last_index, 7) + self.assertEqual(sampler.prob, [1/8]*8) self.assertEqual(sampler.seed, 1) + self.assertListEqual(sampler.prob_weights, sampler.prob) sampler = Sampler.hermanMeyer(12) self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'herman_meyer') - self.assertEqual(sampler.shuffle, False) - self.assertEqual(sampler.prob, None) self.assertEqual(sampler.last_index, 11) self.assertListEqual( sampler.order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.initial_order, [ 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) + self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.randomWithReplacement(5) self.assertEqual(sampler.num_indices, 5) self.assertEqual(sampler.type, 'random_with_replacement') - self.assertEqual(sampler.order, None) - self.assertEqual(sampler.initial_order, None) - self.assertEqual(sampler.shuffle, False) self.assertListEqual(sampler.prob, [1/5] * 5) - self.assertEqual(sampler.last_index, 4) + self.assertListEqual(sampler.prob_weights, [1/5] * 5) sampler = Sampler.randomWithReplacement(4, [0.7, 0.1, 0.1, 0.1]) self.assertEqual(sampler.num_indices, 4) self.assertEqual(sampler.type, 'random_with_replacement') - self.assertEqual(sampler.order, None) - self.assertEqual(sampler.initial_order, None) - self.assertEqual(sampler.shuffle, False) self.assertListEqual(sampler.prob, [0.7, 0.1, 0.1, 0.1]) - self.assertEqual(sampler.last_index, 3) + self.assertListEqual(sampler.prob_weights, [0.7, 0.1, 0.1, 0.1]) sampler = Sampler.staggered(21, 4) self.assertEqual(sampler.num_indices, 21) @@ -94,76 +82,73 @@ def test_init(self): 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) self.assertListEqual(sampler.initial_order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) - self.assertEqual(sampler.shuffle, False) - self.assertEqual(sampler.prob, None) self.assertEqual(sampler.last_index, 20) + self.assertListEqual(sampler.prob_weights, [1/21] * 21) try: Sampler.staggered(22, 25) except ValueError: self.assertTrue(True) - sampler = Sampler.customOrder([1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler.num_indices, 7) + sampler = Sampler.customOrder(12, [1, 4, 6, 7, 8, 9, 11]) + self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'custom_order') self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) self.assertListEqual(sampler.initial_order, [1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler.shuffle, False) - self.assertEqual(sampler.prob, None) self.assertEqual(sampler.last_index, 6) + self.assertListEqual(sampler.prob_weights, [ + 0, 1/7, 0, 0, 1/7, 0, 1/7, 1/7, 1/7, 1/7, 0, 1/7]) - - def test_sequential_iterator_and_get_samples(self): - - #Test the squential sampler + + # Test the squential sampler sampler = Sampler.sequential(10) for i in range(25): self.assertEqual(next(sampler), i % 10) - if i%5==0: # Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(), np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) - + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(), np.array( + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) + sampler = Sampler.sequential(10) for i in range(25): - self.assertEqual(sampler.next(), i % 10) # Repeat the test for .next() - if i%5==0: - self.assertNumpyArrayEqual(sampler.get_samples(), np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) - - def test_random_without_replacement_iterator_and_get_samples(self): - #Test the random without replacement sampler - sampler = Sampler.randomWithoutReplacement(7, shuffle=True, seed=1) - order = [6, 2, 1, 0, 4, 3, 5, 1, 0, 4, 2, 5, - 6, 3, 3, 2, 1, 4, 0, 5, 6, 2, 6, 3, 4] + # Repeat the test for .next() + self.assertEqual(sampler.next(), i % 10) + if i % 5 == 0: + self.assertNumpyArrayEqual(sampler.get_samples(), np.array( + [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) + + def test_random_without_replacement_iterator_and_get_samples(self): + # Test the random without replacement sampler + sampler = Sampler.randomWithoutReplacement(7, seed=1) + order = [2, 5, 0, 2, 1, 0, 1, 2, 2, 3, 2, 4, + 1, 6, 0, 4, 2, 3, 0, 1, 5, 6, 2, 4, 6] for i in range(25): self.assertEqual(next(sampler), order[i]) - if i%4==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(6), np.array(order[:6])) - - #Repeat the test for shuffle=False - sampler = Sampler.randomWithoutReplacement(8, shuffle=False, seed=1) - order = [7, 2, 1, 6, 0, 4, 3, 5] - for i in range(25): - self.assertEqual(sampler.next(), order[i % 8]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(5), np.array(order[:5])) + if i % 4 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(6), np.array(order[:6])) - def test_herman_meyer_iterator_and_get_samples(self): - #Test the Herman Meyer sampler + def test_herman_meyer_iterator_and_get_samples(self): + # Test the Herman Meyer sampler sampler = Sampler.hermanMeyer(12) - order = [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11, 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + order = [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, + 11, 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] for i in range(25): self.assertEqual(sampler.next(), order[i % 12]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(14), np.array(order[:14])) - def test_random_with_replacement_iterator_and_get_samples(self): - #Test the Random with replacement sampler + def test_random_with_replacement_iterator_and_get_samples(self): + # Test the Random with replacement sampler sampler = Sampler.randomWithReplacement(5, seed=5) - order=[1, 4, 1, 4, 2, 3, 3, 2, 1, 0, 0, 3, 2, 0, 4, 1, 2, 1, 3, 2, 2, 1, 1, 1, 1] + order = [1, 4, 1, 4, 2, 3, 3, 2, 1, 0, 0, 3, + 2, 0, 4, 1, 2, 1, 3, 2, 2, 1, 1, 1, 1] for i in range(25): self.assertEqual(next(sampler), order[i]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(14), np.array(order[:14])) sampler = Sampler.randomWithReplacement( 4, [0.7, 0.1, 0.1, 0.1], seed=5) @@ -171,24 +156,28 @@ def test_random_with_replacement_iterator_and_get_samples(self): 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] for i in range(25): self.assertEqual(sampler.next(), order[i]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(14), np.array(order[:14])) - def test_staggered_iterator_and_get_samples(self): - #Test the staggered sampler + def test_staggered_iterator_and_get_samples(self): + # Test the staggered sampler sampler = Sampler.staggered(21, 4) order = [0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] for i in range(25): self.assertEqual(next(sampler), order[i % 21]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(10), np.array(order[:10])) - - def test_custom_order_iterator_and_get_samples(self): - #Test the custom order sampler - sampler = Sampler.customOrder([1, 4, 6, 7, 8, 9, 11]) - order = [1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11,1, 4, 6, 7, 8, 9, 11] + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(10), np.array(order[:10])) + + def test_custom_order_iterator_and_get_samples(self): + # Test the custom order sampler + sampler = Sampler.customOrder(12, [1, 4, 6, 7, 8, 9, 11]) + order = [1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, + 11, 1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, 11] for i in range(25): self.assertEqual(sampler.next(), order[i % 7]) - if i%5==0:# Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(10), np.array(order[:10])) \ No newline at end of file + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual( + sampler.get_samples(10), np.array(order[:10])) From 40ba3f44565435aebe4387869ec16fc06eedc4f8 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 6 Nov 2023 14:38:18 +0000 Subject: [PATCH 063/115] Added function sampler --- .../cil/optimisation/algorithms/SPDHG.py | 2 +- .../cil/optimisation/utilities/sampler.py | 97 ++++++++++++++----- Wrappers/Python/test/test_algorithms.py | 8 +- Wrappers/Python/test/test_sampler.py | 48 ++++++--- 4 files changed, 111 insertions(+), 44 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index ee694f32d7..7d0dc6c8fd 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -111,7 +111,7 @@ def __init__(self, f=None, g=None, operator=None, else: if kwargs.get('prob', None) is not None: warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - sampler=Sampler.randomWithReplacement(len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) + sampler=Sampler.random_with_replacement(len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) if f is not None and operator is not None and g is not None and sampler is not None: diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 5631d511de..0e7b908a33 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -23,9 +23,9 @@ class SamplerFromFunction(): def __init__(self, num_indices,function, sampling_type='from_function', prob_weights=None): """ - TODO: How should a user call this? - A class to select from a list of indices {0, 1, …, S-1} - The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + The user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. + A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. + The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. Parameters @@ -37,15 +37,21 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". - function: TODO: - + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - + + Note + ----- + If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise + the get_samples() function may not accurately return the correct samples and may interrupt the next sample returned. + + + """ - self.sampling_type=sampling_type + self.type=sampling_type self.num_indices=num_indices self.function=function self.prob_weights=prob_weights @@ -82,7 +88,7 @@ def get_samples(self, num_samples=20): Example ------- - >>> sampler=Sampler.randomWithReplacement(5) + >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples()) [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ @@ -98,7 +104,7 @@ class SamplerFromOrder(): def __init__(self, num_indices, order, sampling_type, prob_weights=None): """ - TODO: How should a user call this? + The user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. A class to select from a list of indices {0, 1, …, S-1} The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. @@ -159,7 +165,7 @@ def get_samples(self, num_samples=20): Example ------- - >>> sampler=Sampler.randomWithReplacement(5) + >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples()) [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] @@ -174,6 +180,7 @@ def get_samples(self, num_samples=20): class SamplerRandom(): r""" + The user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. A class to select from a list of indices {0, 1, …, S-1} using numpy.random.choice with and without replacement. The function next() outputs a single next index from the list {0,1,…,S-1} . To be run again and again, depending on how many iterations. @@ -259,7 +266,7 @@ def get_samples(self, num_samples=20): Example ------- - >>> sampler=Sampler.randomWithReplacement(5) + >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples()) [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] @@ -321,7 +328,7 @@ class Sampler(): Example ------- - >>> sampler=Sampler.randomWithReplacement(5) + >>> sampler=Sampler.random_with_replacement(5) >>> for _ in range(12): >>> print(next(sampler)) >>> print(sampler.get_samples()) @@ -386,7 +393,7 @@ def sequential(num_indices): return sampler @staticmethod - def customOrder(num_indices, customlist, prob_weights=None): #TODO: swap to underscores + def custom_order(num_indices, customlist, prob_weights=None): #TODO: swap to underscores """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. @@ -398,7 +405,7 @@ def customOrder(num_indices, customlist, prob_weights=None): #TODO: swap to unde Example -------- - >>> sampler=Sampler.customOrder(12,[1,4,6,7,8,9,11]) + >>> sampler=Sampler.custom_order(12,[1,4,6,7,8,9,11]) >>> print(sampler.get_samples(11)) >>> for _ in range(9): >>> print(sampler.next()) @@ -429,7 +436,7 @@ def customOrder(num_indices, customlist, prob_weights=None): #TODO: swap to unde return sampler @staticmethod - def hermanMeyer(num_indices): + def herman_meyer(num_indices): """ Function that takes a number of indices and returns a sampler which outputs a Herman Meyer order @@ -442,7 +449,7 @@ def hermanMeyer(num_indices): Example ------- - >>> sampler=Sampler.hermanMeyer(12) + >>> sampler=Sampler.herman_meyer(12) >>> print(sampler.get_samples(16)) [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] @@ -537,7 +544,7 @@ def staggered(num_indices, offset): return sampler @staticmethod - def randomWithReplacement(num_indices, prob=None, seed=None): + def random_with_replacement(num_indices, prob=None, seed=None): """ Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices with given probability and with replacement. @@ -555,7 +562,7 @@ def randomWithReplacement(num_indices, prob=None, seed=None): ------- - >>> sampler=Sampler.randomWithReplacement(5) + >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples(10)) [3 4 0 0 2 3 3 2 2 1] @@ -563,7 +570,7 @@ def randomWithReplacement(num_indices, prob=None, seed=None): Example ------- - >>> sampler=Sampler.randomWithReplacement(4, [0.7,0.1,0.1,0.1]) + >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) >>> print(sampler.get_samples(10)) [0 1 3 0 0 3 0 0 0 0] @@ -576,7 +583,7 @@ def randomWithReplacement(num_indices, prob=None, seed=None): return sampler @staticmethod - def randomWithoutReplacement(num_indices, seed=None, prob=None): + def random_without_replacement(num_indices, seed=None, prob=None): """ Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. @@ -603,23 +610,61 @@ def randomWithoutReplacement(num_indices, seed=None, prob=None): @staticmethod def from_function(num_indices, function): """ - Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices TODO: + A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. + The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - function: TODO: + sampling_type:str + The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + + + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. + + prob_weights: list of floats of length num_indices that sum to 1. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + + Note + ----- + If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise + the get_samples() function may not accurately return the correct samples and may interrupt the next sample returned. - Example ------- - TODO: - + >>> def test_function(iteration_number): + >>> if iteration_number<500: + >>> np.random.seed(iteration_number) + >>> return(np.random.choice(49,1)[0]) + >>> else: + >>> np.random.seed(iteration_number) + >>> return(np.random.choice(50,1)[0]) + + + >>> sampler=Sampler.from_function(50, test_function) + >>> for _ in range(11): + >>> print(sampler.next()) + >>> print(list(sampler.get_samples(25))) + 44 + 37 + 40 + 42 + 46 + 35 + 10 + 47 + 3 + 28 + 9 + [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] """ - sampler = SamplerFromFunction(num_indices, sampling_type='random_without_replacement', function=function ) + sampler = SamplerFromFunction(num_indices, sampling_type='from_function', function=function ) return sampler diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index f582ca3181..699329cb93 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -789,7 +789,6 @@ def test_SPDHG_defaults_and_setters(self): self.assertListEqual(spdhg.norms, [self.A.get_item(i, 0).norm() for i in range(self.subsets)]) self.assertListEqual(spdhg.prob_weights, [1/self.subsets] * self.subsets) - self.assertTrue(isinstance(spdhg.sampler, Sampler)) self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) @@ -829,21 +828,20 @@ def test_SPDHG_defaults_and_setters(self): def test_spdhg_non_default_init(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.randomWithReplacement(10, list(np.arange(1,11)/55.)), + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.random_with_replacement(10, list(np.arange(1,11)/55.)), initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) - self.assertTrue(isinstance(spdhg.sampler, Sampler)) self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) self.assertEqual(spdhg.max_iteration, 1000) self.assertEqual(spdhg.update_objective_interval, 10) def test_spdhg_custom_sampler(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.customOrder([0,0,0,0]), + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order( len(self.A), [0,0,0,0]), initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) self.assertListEqual(spdhg.prob_weights, [1]+[0]*(len(self.A)-1)) - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.customOrder([0,1,0,1]), + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A),[0,1,0,1]), initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) self.assertListEqual(spdhg.prob_weights, [.5]+[.5]+[0]*(len(self.A)-2)) diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 3de70afd05..0b33a5b135 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -30,6 +30,15 @@ class TestSamplers(CCPiTestClass): + + def example_function(self, iteration_number): + if iteration_number < 500: + np.random.seed(iteration_number) + return (np.random.choice(49, 1)[0]) + else: + np.random.seed(iteration_number) + return (np.random.choice(50, 1)[0]) + def test_init(self): sampler = Sampler.sequential(10) @@ -40,20 +49,20 @@ def test_init(self): self.assertEqual(sampler.last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) - sampler = Sampler.randomWithoutReplacement(7) + sampler = Sampler.random_without_replacement(7) self.assertEqual(sampler.num_indices, 7) self.assertEqual(sampler.type, 'random_without_replacement') self.assertEqual(sampler.prob, [1/7]*7) self.assertListEqual(sampler.prob_weights, sampler.prob) - sampler = Sampler.randomWithoutReplacement(8, seed=1) + sampler = Sampler.random_without_replacement(8, seed=1) self.assertEqual(sampler.num_indices, 8) self.assertEqual(sampler.type, 'random_without_replacement') self.assertEqual(sampler.prob, [1/8]*8) self.assertEqual(sampler.seed, 1) self.assertListEqual(sampler.prob_weights, sampler.prob) - sampler = Sampler.hermanMeyer(12) + sampler = Sampler.herman_meyer(12) self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'herman_meyer') self.assertEqual(sampler.last_index, 11) @@ -63,13 +72,13 @@ def test_init(self): 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.prob_weights, [1/12] * 12) - sampler = Sampler.randomWithReplacement(5) + sampler = Sampler.random_with_replacement(5) self.assertEqual(sampler.num_indices, 5) self.assertEqual(sampler.type, 'random_with_replacement') self.assertListEqual(sampler.prob, [1/5] * 5) self.assertListEqual(sampler.prob_weights, [1/5] * 5) - sampler = Sampler.randomWithReplacement(4, [0.7, 0.1, 0.1, 0.1]) + sampler = Sampler.random_with_replacement(4, [0.7, 0.1, 0.1, 0.1]) self.assertEqual(sampler.num_indices, 4) self.assertEqual(sampler.type, 'random_with_replacement') self.assertListEqual(sampler.prob, [0.7, 0.1, 0.1, 0.1]) @@ -90,7 +99,7 @@ def test_init(self): except ValueError: self.assertTrue(True) - sampler = Sampler.customOrder(12, [1, 4, 6, 7, 8, 9, 11]) + sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'custom_order') self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) @@ -99,8 +108,23 @@ def test_init(self): self.assertListEqual(sampler.prob_weights, [ 0, 1/7, 0, 0, 1/7, 0, 1/7, 1/7, 1/7, 1/7, 0, 1/7]) - def test_sequential_iterator_and_get_samples(self): + sampler = Sampler.from_function(50, self.example_function) + self.assertListEqual(sampler.prob_weights, [1/50] * 50) + self.assertEqual(sampler.num_indices, 50) + self.assertEqual(sampler.type, 'from_function') + + def test_from_function(self): + + sampler = Sampler.from_function(50, self.example_function) + order = [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, + 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] + for i in range(25): + self.assertEqual(next(sampler), order[i]) + if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler + self.assertNumpyArrayEqual(sampler.get_samples(), np.array( + order)[:20]) + def test_sequential_iterator_and_get_samples(self): # Test the squential sampler sampler = Sampler.sequential(10) for i in range(25): @@ -119,7 +143,7 @@ def test_sequential_iterator_and_get_samples(self): def test_random_without_replacement_iterator_and_get_samples(self): # Test the random without replacement sampler - sampler = Sampler.randomWithoutReplacement(7, seed=1) + sampler = Sampler.random_without_replacement(7, seed=1) order = [2, 5, 0, 2, 1, 0, 1, 2, 2, 3, 2, 4, 1, 6, 0, 4, 2, 3, 0, 1, 5, 6, 2, 4, 6] for i in range(25): @@ -130,7 +154,7 @@ def test_random_without_replacement_iterator_and_get_samples(self): def test_herman_meyer_iterator_and_get_samples(self): # Test the Herman Meyer sampler - sampler = Sampler.hermanMeyer(12) + sampler = Sampler.herman_meyer(12) order = [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11, 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] for i in range(25): @@ -141,7 +165,7 @@ def test_herman_meyer_iterator_and_get_samples(self): def test_random_with_replacement_iterator_and_get_samples(self): # Test the Random with replacement sampler - sampler = Sampler.randomWithReplacement(5, seed=5) + sampler = Sampler.random_with_replacement(5, seed=5) order = [1, 4, 1, 4, 2, 3, 3, 2, 1, 0, 0, 3, 2, 0, 4, 1, 2, 1, 3, 2, 2, 1, 1, 1, 1] for i in range(25): @@ -150,7 +174,7 @@ def test_random_with_replacement_iterator_and_get_samples(self): self.assertNumpyArrayEqual( sampler.get_samples(14), np.array(order[:14])) - sampler = Sampler.randomWithReplacement( + sampler = Sampler.random_with_replacement( 4, [0.7, 0.1, 0.1, 0.1], seed=5) order = [0, 2, 0, 3, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] @@ -173,7 +197,7 @@ def test_staggered_iterator_and_get_samples(self): def test_custom_order_iterator_and_get_samples(self): # Test the custom order sampler - sampler = Sampler.customOrder(12, [1, 4, 6, 7, 8, 9, 11]) + sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) order = [1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, 11] for i in range(25): From 376045863d5e37987207b723bb31a51b1852f068 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 7 Nov 2023 13:50:55 +0000 Subject: [PATCH 064/115] prob_weights to sampler --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 7d0dc6c8fd..c8771dbc82 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -307,10 +307,7 @@ def set_up(self, f, g, operator, self.prob_weights=sampler.prob_weights #TODO: consider the case it is uniform and not saving the array if self.prob_weights is None: - x=sampler.get_samples(10000) - self.prob_weights=[np.count_nonzero((x==i)) for i in range(len(operator))] - total=sum(self.prob_weights) - self.prob_weights[:] = [x / total for x in self.prob_weights] + self.prob_weights=[1/self.ndual_subsets]*self.ndual_subsets # might not want to do this until it is called (if computationally expensive) self.set_step_sizes_default() From 878675d195ea5f7b420183a299aa67932fa61787 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 7 Nov 2023 14:39:33 +0000 Subject: [PATCH 065/115] TODO:s --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 5 ++++- Wrappers/Python/cil/optimisation/utilities/sampler.py | 10 +++++----- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index c8771dbc82..507b401f6d 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -98,6 +98,7 @@ class SPDHG(Algorithm): def __init__(self, f=None, g=None, operator=None, initial=None, sampler=None, **kwargs): + #TODO: keep sigma, tau, gamma in the init and call set_custom_step_sizes super(SPDHG, self).__init__(**kwargs) if kwargs.get('norms', None) is not None: @@ -107,6 +108,8 @@ def __init__(self, f=None, g=None, operator=None, if sampler is not None: if kwargs.get('prob', None) is not None: + #TODO: change warnings to logging + #TODO: change this one to an error warnings.warn('`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') else: if kwargs.get('prob', None) is not None: @@ -140,7 +143,7 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): Note ----- - The step sizes `sigma` anf `tau` are set using the equations: + The step sizes `sigma` and `tau` are set using the equations: .. math:: \sigma_i=\gamma\rho / (\|K_i\|**2)\\ diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 0e7b908a33..e12b064789 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -57,7 +57,7 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei self.prob_weights=prob_weights if self.prob_weights is None: self.prob_weights=[1/num_indices]*num_indices - self.iteration_number=-1 + self.iteration_number=-1 #TODO:start at 0. @@ -68,7 +68,7 @@ def next(self): """ - self.iteration_number+=1 + self.iteration_number+=1 #TODO: call, iterate and then return return (self.function(self.iteration_number)) def __next__(self): @@ -245,7 +245,7 @@ def next(self): if self.replace: return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) else: - return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) + return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) #TODO: @@ -363,7 +363,7 @@ class Sampler(): def sequential(num_indices): """ Function that outputs a sampler that outputs sequentially. - + #TODO: docstring num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -393,7 +393,7 @@ def sequential(num_indices): return sampler @staticmethod - def custom_order(num_indices, customlist, prob_weights=None): #TODO: swap to underscores + def custom_order(num_indices, customlist, prob_weights=None): """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. From 2d99762bf6fa1c836f009ea795fe88924cb8533b Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 8 Nov 2023 11:51:49 +0000 Subject: [PATCH 066/115] Updates to sampler --- .../cil/optimisation/utilities/sampler.py | 72 ++++++++++++------- Wrappers/Python/test/test_sampler.py | 40 ++++++++--- 2 files changed, 76 insertions(+), 36 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index e12b064789..15048cd967 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -39,7 +39,7 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - prob_weights: list of floats of length num_indices that sum to 1. + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices #TODO: write unit tests. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. @@ -54,10 +54,12 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei self.type=sampling_type self.num_indices=num_indices self.function=function + if abs(sum(prob_weights)-1)>1e-6: + raise ValueError('The provided prob_weights must sum to one') + if any(np.array(prob_weights)<0): + raise ValueError('The provided prob_weights must be greater than or equal to zero') self.prob_weights=prob_weights - if self.prob_weights is None: - self.prob_weights=[1/num_indices]*num_indices - self.iteration_number=-1 #TODO:start at 0. + self.iteration_number=0 @@ -67,9 +69,9 @@ def next(self): A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. """ - - self.iteration_number+=1 #TODO: call, iterate and then return - return (self.function(self.iteration_number)) + out=self.function(self.iteration_number) + self.iteration_number=self.iteration_number+1 + return (out) def __next__(self): """ @@ -93,7 +95,7 @@ def get_samples(self, num_samples=20): [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ save_last_index = self.iteration_number - self.iteration_number = -1 + self.iteration_number = 0 output = [self.next() for _ in range(num_samples)] self.iteration_number = save_last_index return (np.array(output)) @@ -127,13 +129,15 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): """ + if abs(sum(prob_weights)-1)>1e-6: + raise ValueError('The provided prob_weights must sum to one') + if any(np.array(prob_weights)<0): + raise ValueError('The provided prob_weights must be greater than or equal to zero') + self.prob_weights=prob_weights self.type = sampling_type self.num_indices = num_indices - self.order = order - self.initial_order = self.order - - + self.order = order self.last_index = len(order)-1 @@ -223,6 +227,11 @@ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): self.prob_weights=prob else: self.prob_weights=[1/num_indices]*num_indices + if abs(sum(self.prob_weights)-1)>1e-6: + raise ValueError('The provided prob_weights must sum to one') + if any(np.array(self.prob_weights)<0): + raise ValueError('The provided prob_weights must be greater than or equal to zero') + self.type = sampling_type self.num_indices = num_indices if seed is not None: @@ -242,10 +251,9 @@ def next(self): This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with and without replacement. """ - if self.replace: - return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) - else: - return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) #TODO: + + return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) + @@ -290,7 +298,7 @@ class Sampler(): The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + The sampling type used. Choose from "from_function", "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". order: list of indices The list of indices the method selects from using next. @@ -363,7 +371,9 @@ class Sampler(): def sequential(num_indices): """ Function that outputs a sampler that outputs sequentially. - #TODO: docstring + + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -393,14 +403,19 @@ def sequential(num_indices): return sampler @staticmethod - def custom_order(num_indices, customlist, prob_weights=None): + def custom_order(num_indices, custom_list, prob_weights=None): """ Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. - customlist: list of indices + Parameters + ---------- + num_indices: `int` + The sampler will select indices for `{1,....,n}` according to the order in `custom_list` where `n` is `num_indices`. + custom_list: `list` of `int` The list that will be sampled from in order. - #TODO: + prob_weights: list of floats of length num_indices that sum to 1. Default is None and the prob_weights are calculated automatically. + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example -------- @@ -427,12 +442,13 @@ def custom_order(num_indices, customlist, prob_weights=None): if prob_weights is None: temp_list=[] for i in range(num_indices): - temp_list.append(customlist.count(i)) + temp_list.append(custom_list.count(i)) total=sum(temp_list) prob_weights=[x/total for x in temp_list] + sampler = SamplerFromOrder( - num_indices, sampling_type='custom_order', order=customlist, prob_weights=prob_weights) + num_indices, sampling_type='custom_order', order=custom_list, prob_weights=prob_weights) return sampler @staticmethod @@ -608,7 +624,7 @@ def random_without_replacement(num_indices, seed=None, prob=None): return sampler @staticmethod - def from_function(num_indices, function): + def from_function(num_indices, function, prob_weights=None): """ A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. @@ -622,10 +638,9 @@ def from_function(num_indices, function): sampling_type:str The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - prob_weights: list of floats of length num_indices that sum to 1. + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. @@ -663,8 +678,11 @@ def from_function(num_indices, function): [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] """ + if prob_weights is None: + prob_weights=[1/num_indices]*num_indices + - sampler = SamplerFromFunction(num_indices, sampling_type='from_function', function=function ) + sampler = SamplerFromFunction(num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) return sampler diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 0b33a5b135..576660a3d9 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -45,7 +45,6 @@ def test_init(self): self.assertEqual(sampler.num_indices, 10) self.assertEqual(sampler.type, 'sequential') self.assertListEqual(sampler.order, list(range(10))) - self.assertListEqual(sampler.initial_order, list(range(10))) self.assertEqual(sampler.last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) @@ -68,8 +67,6 @@ def test_init(self): self.assertEqual(sampler.last_index, 11) self.assertListEqual( sampler.order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) - self.assertListEqual(sampler.initial_order, [ - 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.random_with_replacement(5) @@ -89,29 +86,54 @@ def test_init(self): self.assertEqual(sampler.type, 'staggered') self.assertListEqual(sampler.order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) - self.assertListEqual(sampler.initial_order, [ - 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) self.assertEqual(sampler.last_index, 20) self.assertListEqual(sampler.prob_weights, [1/21] * 21) - try: + with self.assertRaises(ValueError): Sampler.staggered(22, 25) - except ValueError: - self.assertTrue(True) + sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler.type, 'custom_order') self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) - self.assertListEqual(sampler.initial_order, [1, 4, 6, 7, 8, 9, 11]) self.assertEqual(sampler.last_index, 6) self.assertListEqual(sampler.prob_weights, [ 0, 1/7, 0, 0, 1/7, 0, 1/7, 1/7, 1/7, 1/7, 0, 1/7]) + + sampler = Sampler.custom_order(10, [0,1, 2, 3, 4]) + self.assertEqual(sampler.num_indices, 10) + self.assertEqual(sampler.type, 'custom_order') + self.assertListEqual(sampler.order, [0,1,2,3,4]) + self.assertEqual(sampler.last_index, 4) + self.assertListEqual(sampler.prob_weights, [ + 1/5,1/5,1/5,1/5,1/5,0,0,0,0,0]) + + sampler = Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[1/10]*10) + self.assertListEqual(sampler.prob_weights, [1/10]*10) + + #Check probabilities sum to one and are positive + with self.assertRaises(ValueError): + Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[1/11]*10) + with self.assertRaises(ValueError): + Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[-1]+[2]+[0]*8) + sampler = Sampler.from_function(50, self.example_function) self.assertListEqual(sampler.prob_weights, [1/50] * 50) self.assertEqual(sampler.num_indices, 50) self.assertEqual(sampler.type, 'from_function') + + sampler = Sampler.from_function(40, self.example_function, [1]+[0]*39) + self.assertListEqual(sampler.prob_weights, [1]+[0]*39) + self.assertEqual(sampler.num_indices, 40) + self.assertEqual(sampler.type, 'from_function') + + #check probabilities sum to 1 and are positive + with self.assertRaises(ValueError): + Sampler.from_function(40, self.example_function, [0.9]+[0]*39) + with self.assertRaises(ValueError): + Sampler.from_function(40, self.example_function, [-1]+[2]+[0]*38) def test_from_function(self): From 7154834a167b97ba41178155646cb8a5688d3fe1 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 8 Nov 2023 13:28:50 +0000 Subject: [PATCH 067/115] Updates to SPDHG after stochastic meeting --- .../cil/optimisation/algorithms/SPDHG.py | 88 +++++++++++-------- 1 file changed, 50 insertions(+), 38 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 507b401f6d..37e4786382 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -26,6 +26,7 @@ from numbers import Number import numpy as np + class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient @@ -65,22 +66,41 @@ class SPDHG(Algorithm): Example of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py + Note - ---- + ----- + When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: - Convergence is guaranteed provided that [2, eq. (12)]: + - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: + .. math:: - .. math:: + \sigma_i=0.99 / (\|K_i\|**2) + + and `tau` is set as per case 2 + + - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula + + .. math:: + + \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + + - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula + + .. math:: + + \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) + + - Case 4: Both `sigma` and `tau` are provided. - \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i Note ---- - Notation for primal and dual step-sizes are reversed with comparison - to SPDHG.py + Convergence is guaranteed provided that [2, eq. (12)]: + .. math:: + \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i References ---------- @@ -95,34 +115,30 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, + def __init__(self, f=None, g=None, operator=None, sigma=None, tau=None, initial=None, sampler=None, **kwargs): - #TODO: keep sigma, tau, gamma in the init and call set_custom_step_sizes super(SPDHG, self).__init__(**kwargs) if kwargs.get('norms', None) is not None: operator.set_norms(kwargs.get('norms')) warnings.warn( - ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') - + ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') + if sampler is not None: if kwargs.get('prob', None) is not None: - #TODO: change warnings to logging - #TODO: change this one to an error - warnings.warn('`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') + raise TypeError( + '`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') else: if kwargs.get('prob', None) is not None: - warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - sampler=Sampler.random_with_replacement(len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) - + logging.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') + sampler = Sampler.random_with_replacement( + len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) if f is not None and operator is not None and g is not None and sampler is not None: - self.set_up(f=f, g=g, operator=operator, + self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, initial=initial, sampler=sampler) - - @property def sigma(self): return self._sigma @@ -140,7 +156,7 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): parameter controlling the trade-off between the primal and dual step sizes rho : float parameter controlling the size of the product :math: \sigma\tau :math: - + Note ----- The step sizes `sigma` and `tau` are set using the equations: @@ -168,9 +184,9 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): "We currently only support scalar values of gamma") self._sigma = [gamma * rho / ni for ni in self.norms] - values=[pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)] - self._tau = min([value for value in values if value>1e-6]) #TODO: what value should this be + values = [pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)] + self._tau = min([value for value in values if value > 1e-8]) self._tau *= (rho / gamma) def set_step_sizes_custom(self, sigma=None, tau=None): @@ -184,7 +200,7 @@ def set_step_sizes_custom(self, sigma=None, tau=None): Step size parameter for Primal problem The user can set these or default values are calculated, either sigma, tau, both or None can be passed. - + Note ----- There are 4 possible cases considered by this function: @@ -201,7 +217,7 @@ def set_step_sizes_custom(self, sigma=None, tau=None): .. math:: \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - + - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula .. math:: @@ -209,10 +225,6 @@ def set_step_sizes_custom(self, sigma=None, tau=None): \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - Case 4: Both `sigma` and `tau` are provided. - - - - """ gamma = 1. @@ -240,9 +252,9 @@ def set_step_sizes_custom(self, sigma=None, tau=None): gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] if tau is None: - values=[pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)] - self._tau = min([value for value in values if value>1e-6]) #TODO: what value should this be + values = [pi / (si * ni**2) for pi, ni, + si in zip(self.prob_weights, self.norms, self._sigma)] + self._tau = min([value for value in values if value > 1e-8]) self._tau *= (rho / gamma) else: if isinstance(tau, Number): @@ -258,7 +270,6 @@ def set_step_sizes_default(self): """Calculates the default values for sigma and tau """ self.set_step_sizes_custom(sigma=None, tau=None) - def check_convergence(self): # TODO: check this with someone else """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma @@ -276,7 +287,7 @@ def check_convergence(self): else: return False - def set_up(self, f, g, operator, + def set_up(self, f, g, operator, sigma=None, tau=None, initial=None, sampler=None): '''set-up of the algorithm Parameters @@ -305,15 +316,16 @@ def set_up(self, f, g, operator, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - self.sampler=sampler + self.sampler = sampler self.norms = operator.get_norms_as_list() - self.prob_weights=sampler.prob_weights #TODO: consider the case it is uniform and not saving the array + # TODO: consider the case it is uniform and not saving the array + self.prob_weights = sampler.prob_weights if self.prob_weights is None: - self.prob_weights=[1/self.ndual_subsets]*self.ndual_subsets + self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets # might not want to do this until it is called (if computationally expensive) - self.set_step_sizes_default() + self.set_step_sizes_custom(sigma=sigma, tau=tau) # initialize primal variable if initial is None: From 4e7f2b66d58d8f8931399d16cf1333599d6b6f99 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 8 Nov 2023 14:23:41 +0000 Subject: [PATCH 068/115] Merge error fixed --- .../cil/optimisation/operators/BlockOperator.py | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index d81387c35a..2c02b950f2 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -77,12 +77,7 @@ class BlockOperator(Operator): __array_priority__ = 1 def __init__(self, *args, **kwargs): - - Example: - BlockOperator(op0,op1) results in a row block - BlockOperator(op0,op1,shape=(1,2)) results in a column block - ''' - + self.operators = args shape = kwargs.get('shape', None) if shape is None: @@ -141,7 +136,6 @@ def row_wise_compatible(self): return compatible def get_item(self, row, col): - '''Returns the Operator at specified row and col Parameters ---------- @@ -150,7 +144,6 @@ def get_item(self, row, col): col: `int` The column index required. ''' - if row > self.shape[0]: raise ValueError( 'Requested row {} > max {}'.format(row, self.shape[0])) @@ -300,7 +293,6 @@ def is_linear(self): def get_output_shape(self, xshape, adjoint=False): '''Returns the shape of the output BlockDataContainer - Parameters ---------- xshape: BlockDataContainer @@ -309,7 +301,6 @@ def get_output_shape(self, xshape, adjoint=False): Examples -------- - A(N,M) direct u(M,1) -> N,1 A(N,M)^T adjoint u(N,1) -> M,1 @@ -334,10 +325,10 @@ def __rmul__(self, scalar): Parameters ------------ + scalar: number or iterable containing numbers ''' - if isinstance(scalar, list) or isinstance(scalar, tuple) or \ isinstance(scalar, numpy.ndarray): if len(scalar) != len(self.operators): @@ -354,6 +345,7 @@ def __rmul__(self, scalar): @property def T(self): '''Returns the transposed of self. + Recall the input list is shaped in a row-by-row fashion''' newshape = (self.shape[1], self.shape[0]) oplist = [] From d861a13fd1a30be982eb8126d5f31471e34e77ca Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 15 Nov 2023 16:12:54 +0000 Subject: [PATCH 069/115] SPDHG documentation changes --- .../Python/cil/optimisation/algorithms/SPDHG.py | 13 +++---------- 1 file changed, 3 insertions(+), 10 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 37e4786382..3d0a589f8a 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -54,8 +54,8 @@ class SPDHG(Algorithm): parameter controlling the trade-off between the primal and dual step sizes sampler: an instance of a `cil.optimisation.utilities.Sampler` class Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets + **kwargs: - prob : list of floats, optional, default=None List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ norms : list of floats @@ -81,13 +81,11 @@ class SPDHG(Algorithm): - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula .. math:: - \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula .. math:: - \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - Case 4: Both `sigma` and `tau` are provided. @@ -99,7 +97,6 @@ class SPDHG(Algorithm): Convergence is guaranteed provided that [2, eq. (12)]: .. math:: - \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i References @@ -148,7 +145,7 @@ def tau(self): return self._tau def set_step_sizes_from_ratio(self, gamma=1., rho=.99): - """ Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. + r""" Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. Parameters ---------- @@ -161,7 +158,6 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): ----- The step sizes `sigma` and `tau` are set using the equations: .. math:: - \sigma_i=\gamma\rho / (\|K_i\|**2)\\ \tau = (\rho/\gamma)\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) @@ -190,7 +186,7 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): self._tau *= (rho / gamma) def set_step_sizes_custom(self, sigma=None, tau=None): - """ Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. + r""" Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. Parameters ---------- @@ -207,7 +203,6 @@ def set_step_sizes_custom(self, sigma=None, tau=None): - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: .. math:: - \sigma_i=0.99 / (\|K_i\|**2) and `tau` is set as per case 2 @@ -215,13 +210,11 @@ def set_step_sizes_custom(self, sigma=None, tau=None): - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula .. math:: - \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula .. math:: - \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - Case 4: Both `sigma` and `tau` are provided. From 0af2e61cf046cf2fd61635a82506aff692894703 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 22 Nov 2023 16:37:09 +0000 Subject: [PATCH 070/115] Changes from meeting with Edo and Gemma --- .../cil/optimisation/algorithms/SPDHG.py | 69 +++++--- .../cil/optimisation/utilities/sampler.py | 147 ++++++++---------- Wrappers/Python/test/test_algorithms.py | 38 ++--- 3 files changed, 131 insertions(+), 123 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 3d0a589f8a..5fb1a5631e 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -112,30 +112,52 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, sigma=None, tau=None, + def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=None, sampler=None, **kwargs): - super(SPDHG, self).__init__(**kwargs) - if kwargs.get('norms', None) is not None: - operator.set_norms(kwargs.get('norms')) + + max_iteration=kwargs.pop('max_iteration', 0) + update_objective_interval=kwargs.pop('update_objective_interval', 1) + log_file=kwargs.pop('log_file', None) + super(SPDHG, self).__init__(max_iteration=max_iteration, update_objective_interval=update_objective_interval, log_file=log_file) + + + self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, + initial=initial, sampler=sampler) + + def _deprecated_kwargs(self, deprecated_kwargs): + """ + Handle deprecated keyword arguments for backward compatibility. + + Parameters + ---------- + deprecated_kwargs : dict + Dictionary of keyword arguments. + + Notes + ----- + This method is called by the set_up method. + """ + norms= deprecated_kwargs.pop('norms', None) + prob=deprecated_kwargs.pop('prob', None) + if norms is not None: + self.operator.set_norms(norms) warnings.warn( ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') - if sampler is not None: - if kwargs.get('prob', None) is not None: + if self.sampler is not None: + if prob is not None: raise TypeError( '`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') else: - if kwargs.get('prob', None) is not None: - logging.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - sampler = Sampler.random_with_replacement( - len(operator), prob=kwargs.get('prob', [1/len(operator)]*len(operator))) - - if f is not None and operator is not None and g is not None and sampler is not None: - self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - initial=initial, sampler=sampler) - + if prob is not None: + warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') + self.sampler = Sampler.random_with_replacement(len(operator), prob=prob) + + if deprecated_kwargs: + warnings.warn("Additional keyword arguments passed but not used: {}".format(deprecated_kwargs)) + @property def sigma(self): return self._sigma @@ -185,7 +207,7 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): self._tau = min([value for value in values if value > 1e-8]) self._tau *= (rho / gamma) - def set_step_sizes_custom(self, sigma=None, tau=None): + def set_step_sizes(self, sigma=None, tau=None): r""" Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. Parameters @@ -259,12 +281,7 @@ def set_step_sizes_custom(self, sigma=None, tau=None): "The value of tau should be a Number") self._tau = tau - def set_step_sizes_default(self): - """Calculates the default values for sigma and tau """ - self.set_step_sizes_custom(sigma=None, tau=None) - def check_convergence(self): - # TODO: check this with someone else """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma Returns @@ -281,7 +298,7 @@ def check_convergence(self): return False def set_up(self, f, g, operator, sigma=None, tau=None, - initial=None, sampler=None): + initial=None, sampler=None, **deprecated_kwargs): '''set-up of the algorithm Parameters ---------- @@ -310,15 +327,17 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self.operator = operator self.ndual_subsets = self.operator.shape[0] self.sampler = sampler + self._deprecated_kwargs(deprecated_kwargs) + if self.sampler is None: + self.sampler=Sampler.random_with_replacement(len(operator)) self.norms = operator.get_norms_as_list() - # TODO: consider the case it is uniform and not saving the array - self.prob_weights = sampler.prob_weights + self.prob_weights = self.sampler.prob_weights # TODO: consider the case it is uniform and not saving the array if self.prob_weights is None: self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets # might not want to do this until it is called (if computationally expensive) - self.set_step_sizes_custom(sigma=sigma, tau=tau) + self.set_step_sizes(sigma=sigma, tau=tau) # initialize primal variable if initial is None: diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 15048cd967..d89d2b9421 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -20,8 +20,9 @@ import math import time + class SamplerFromFunction(): - def __init__(self, num_indices,function, sampling_type='from_function', prob_weights=None): + def __init__(self, num_indices, function, sampling_type='from_function', prob_weights=None): """ The user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. @@ -34,7 +35,7 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + The sampling type used. Choose from "from_function". function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. @@ -49,28 +50,27 @@ def __init__(self, num_indices,function, sampling_type='from_function', prob_wei the get_samples() function may not accurately return the correct samples and may interrupt the next sample returned. - + """ - self.type=sampling_type - self.num_indices=num_indices - self.function=function - if abs(sum(prob_weights)-1)>1e-6: + self.type = sampling_type + self.num_indices = num_indices + self.function = function + if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') - if any(np.array(prob_weights)<0): - raise ValueError('The provided prob_weights must be greater than or equal to zero') - self.prob_weights=prob_weights - self.iteration_number=0 - - - + if any(np.array(prob_weights) < 0): + raise ValueError( + 'The provided prob_weights must be greater than or equal to zero') + self.prob_weights = prob_weights + self.iteration_number = 0 + def next(self): """ - + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. """ - out=self.function(self.iteration_number) - self.iteration_number=self.iteration_number+1 + out = self.function(self.iteration_number) + self.iteration_number = self.iteration_number+1 return (out) def __next__(self): @@ -80,7 +80,7 @@ def __next__(self): Allows the user to call next(sampler), to get the same result as sampler.next()""" return (self.next()) - def get_samples(self, num_samples=20): + def get_samples(self, num_samples=20): """ Function that takes an index, num_samples, and returns the first num_samples as a numpy array. @@ -98,13 +98,12 @@ def get_samples(self, num_samples=20): self.iteration_number = 0 output = [self.next() for _ in range(num_samples)] self.iteration_number = save_last_index - return (np.array(output)) - - + return (np.array(output)) + + class SamplerFromOrder(): - + def __init__(self, num_indices, order, sampling_type, prob_weights=None): - """ The user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. A class to select from a list of indices {0, 1, …, S-1} @@ -117,7 +116,7 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", and "staggered" order: list of indices The list of indices the method selects from using next. @@ -126,29 +125,28 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - + """ - if abs(sum(prob_weights)-1)>1e-6: + if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') - if any(np.array(prob_weights)<0): - raise ValueError('The provided prob_weights must be greater than or equal to zero') - - self.prob_weights=prob_weights + if any(np.array(prob_weights) < 0): + raise ValueError( + 'The provided prob_weights must be greater than or equal to zero') + + self.prob_weights = prob_weights self.type = sampling_type self.num_indices = num_indices - self.order = order + self.order = order self.last_index = len(order)-1 - - - + def next(self): """ - + A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. """ - + self.last_index = (self.last_index+1) % len(self.order) return (self.order[self.last_index]) @@ -159,7 +157,7 @@ def __next__(self): Allows the user to call next(sampler), to get the same result as sampler.next()""" return (self.next()) - def get_samples(self, num_samples=20): + def get_samples(self, num_samples=20): """ Function that takes an index, num_samples, and returns the first num_samples as a numpy array. @@ -195,12 +193,10 @@ class SamplerRandom(): The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. + The sampling type used. Choose from "random_with_replacement" and "random_without_replacement" - replace= bool If True, sample with replace, otherwise sample without replacement - prob: list of floats of length num_indices that sum to 1. For random sampling with replacement, this is the probability for each index to be called by next. @@ -210,28 +206,28 @@ class SamplerRandom(): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - """ + def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): """ This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. """ - self.replace=replace - self.prob=prob + self.replace = replace + self.prob = prob if prob is None: - self.prob=[1/num_indices]*num_indices + self.prob = [1/num_indices]*num_indices if replace: - self.prob_weights=prob + self.prob_weights = prob else: - self.prob_weights=[1/num_indices]*num_indices - if abs(sum(self.prob_weights)-1)>1e-6: + self.prob_weights = [1/num_indices]*num_indices + if abs(sum(self.prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') - if any(np.array(self.prob_weights)<0): - raise ValueError('The provided prob_weights must be greater than or equal to zero') - + if any(np.array(self.prob_weights) < 0): + raise ValueError( + 'The provided prob_weights must be greater than or equal to zero') + self.type = sampling_type self.num_indices = num_indices if seed is not None: @@ -240,9 +236,6 @@ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): self.seed = int(time.time()) self.generator = np.random.RandomState(self.seed) - - - def next(self): """ @@ -251,11 +244,8 @@ def next(self): This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with and without replacement. """ - - return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) - - + return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) def __next__(self): """ @@ -285,6 +275,7 @@ def get_samples(self, num_samples=20): self.generator = save_generator return (np.array(output)) + class Sampler(): r""" @@ -298,7 +289,7 @@ class Sampler(): The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str - The sampling type used. Choose from "from_function", "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + The sampling type used. Choose from "from_function", "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement", "random_without_replacement" and "from_function". order: list of indices The list of indices the method selects from using next. @@ -371,7 +362,7 @@ class Sampler(): def sequential(num_indices): """ Function that outputs a sampler that outputs sequentially. - + Parameters ---------- num_indices: int @@ -399,7 +390,8 @@ def sequential(num_indices): 0 """ order = list(range(num_indices)) - sampler = SamplerFromOrder(num_indices, sampling_type='sequential', order=order, prob_weights=[1/num_indices]*num_indices) + sampler = SamplerFromOrder(num_indices, sampling_type='sequential', order=order, prob_weights=[ + 1/num_indices]*num_indices) return sampler @staticmethod @@ -416,7 +408,7 @@ def custom_order(num_indices, custom_list, prob_weights=None): prob_weights: list of floats of length num_indices that sum to 1. Default is None and the prob_weights are calculated automatically. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - + Example -------- @@ -439,14 +431,13 @@ def custom_order(num_indices, custom_list, prob_weights=None): [1 4 6 7 8] """ - if prob_weights is None: - temp_list=[] + if prob_weights is None: + temp_list = [] for i in range(num_indices): temp_list.append(custom_list.count(i)) - total=sum(temp_list) - prob_weights=[x/total for x in temp_list] - - + total = sum(temp_list) + prob_weights = [x/total for x in temp_list] + sampler = SamplerFromOrder( num_indices, sampling_type='custom_order', order=custom_list, prob_weights=prob_weights) return sampler @@ -556,7 +547,8 @@ def staggered(num_indices, offset): indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = SamplerFromOrder(num_indices, sampling_type='staggered', order=order, prob_weights=[1/num_indices]*num_indices) + sampler = SamplerFromOrder(num_indices, sampling_type='staggered', order=order, prob_weights=[ + 1/num_indices]*num_indices) return sampler @staticmethod @@ -610,7 +602,7 @@ def random_without_replacement(num_indices, seed=None, prob=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + Example ------- >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) @@ -620,7 +612,8 @@ def random_without_replacement(num_indices, seed=None, prob=None): """ - sampler = SamplerRandom(num_indices, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob ) + sampler = SamplerRandom( + num_indices, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob) return sampler @staticmethod @@ -658,7 +651,7 @@ def from_function(num_indices, function, prob_weights=None): >>> else: >>> np.random.seed(iteration_number) >>> return(np.random.choice(50,1)[0]) - + >>> sampler=Sampler.from_function(50, test_function) >>> for _ in range(11): @@ -679,12 +672,8 @@ def from_function(num_indices, function, prob_weights=None): """ if prob_weights is None: - prob_weights=[1/num_indices]*num_indices - + prob_weights = [1/num_indices]*num_indices - sampler = SamplerFromFunction(num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) + sampler = SamplerFromFunction( + num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) return sampler - - - - \ No newline at end of file diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index e863abf20a..2283fe2371 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -808,21 +808,21 @@ def test_SPDHG_defaults_and_setters(self): gamma=1. rho=.99 - spdhg.set_step_sizes_custom() + spdhg.set_step_sizes() self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=100) + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, 100) - spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=None) + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, min([(pi / (si * ni**2))*(rho / gamma) for pi, ni, si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) - spdhg.set_step_sizes_custom(sigma=None, tau=100) + spdhg.set_step_sizes(sigma=None, tau=100) self.assertListEqual(spdhg.sigma, [gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg.norms, spdhg.prob_weights)] ) self.assertEqual(spdhg.tau, 100) @@ -862,19 +862,19 @@ def test_spdhg_check_convergence(self): spdhg.set_step_sizes_from_ratio(gamma,rho) self.assertFalse(spdhg.check_convergence()) - spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=100) + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) self.assertFalse(spdhg.check_convergence()) - spdhg.set_step_sizes_custom(sigma=[1]*self.subsets, tau=None) + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) self.assertTrue(spdhg.check_convergence()) - spdhg.set_step_sizes_custom(sigma=None, tau=100) + spdhg.set_step_sizes(sigma=None, tau=100) self.assertTrue(spdhg.check_convergence()) @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(12,12)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -922,7 +922,7 @@ def test_SPDHG_vs_PDHG_implicit(self): # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 70, + max_iteration = 80, update_objective_interval = 1000) pdhg.run(verbose=0) @@ -957,7 +957,7 @@ def test_SPDHG_vs_PDHG_implicit(self): prob = [1/len(A)]*len(A) spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 320, + max_iteration = 200, update_objective_interval=1000, prob = prob) spdhg.run(1000, verbose=0) @@ -974,7 +974,7 @@ def test_SPDHG_vs_PDHG_implicit(self): @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_PDHG_explicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(12,12)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -1039,8 +1039,8 @@ def test_SPDHG_vs_PDHG_explicit(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 220, - update_objective_interval=220, prob = prob) + max_iteration = 300, + update_objective_interval=300, prob = prob) spdhg.run(1000, verbose=0) @@ -1059,8 +1059,8 @@ def test_SPDHG_vs_PDHG_explicit(self): f = BlockFunction(f1, f2) # Setup and run the PDHG algorithm pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma) - pdhg.max_iteration = 180 - pdhg.update_objective_interval =180 + pdhg.max_iteration = 300 + pdhg.update_objective_interval =300 pdhg.run(1000, verbose=0) @@ -1155,15 +1155,15 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 330, - update_objective_interval=330, prob = prob.copy(), use_axpby=True) + max_iteration = 250, + update_objective_interval=250, prob = prob.copy(), use_axpby=True) ) algos[0].run(1000, verbose=0) algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 330, - update_objective_interval=330, prob = prob.copy(), use_axpby=False) + max_iteration = 250, + update_objective_interval=250, prob = prob.copy(), use_axpby=False) ) algos[1].run(1000, verbose=0) From 8e140345f5f88e9889481f30382bd4a6700848cb Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 22 Nov 2023 16:39:15 +0000 Subject: [PATCH 071/115] Remove changes to BlockOperator.py --- Wrappers/Python/cil/optimisation/operators/BlockOperator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index 78357e68b6..c92b3d54d4 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -77,7 +77,7 @@ class BlockOperator(Operator): __array_priority__ = 1 def __init__(self, *args, **kwargs): - + self.operators = args shape = kwargs.get('shape', None) if shape is None: From 5c34e69af5d4beada2c7a791702bf94d2c687c5d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 22 Nov 2023 16:44:40 +0000 Subject: [PATCH 072/115] sigma and tau properties --- .../cil/optimisation/algorithms/SPDHG.py | 49 ++++++++++--------- .../cil/optimisation/utilities/sampler.py | 2 +- 2 files changed, 26 insertions(+), 25 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 5fb1a5631e..d64b85c98c 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -54,7 +54,7 @@ class SPDHG(Algorithm): parameter controlling the trade-off between the primal and dual step sizes sampler: an instance of a `cil.optimisation.utilities.Sampler` class Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets - + **kwargs: prob : list of floats, optional, default=None List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ @@ -112,20 +112,18 @@ class SPDHG(Algorithm): Physics in Medicine & Biology, Volume 64, Number 22, 2019. ''' - def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, + def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=None, sampler=None, **kwargs): - - - max_iteration=kwargs.pop('max_iteration', 0) - update_objective_interval=kwargs.pop('update_objective_interval', 1) - log_file=kwargs.pop('log_file', None) - super(SPDHG, self).__init__(max_iteration=max_iteration, update_objective_interval=update_objective_interval, log_file=log_file) - + max_iteration = kwargs.pop('max_iteration', 0) + update_objective_interval = kwargs.pop('update_objective_interval', 1) + log_file = kwargs.pop('log_file', None) + super(SPDHG, self).__init__(max_iteration=max_iteration, + update_objective_interval=update_objective_interval, log_file=log_file) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - initial=initial, sampler=sampler) - + initial=initial, sampler=sampler) + def _deprecated_kwargs(self, deprecated_kwargs): """ Handle deprecated keyword arguments for backward compatibility. @@ -139,9 +137,9 @@ def _deprecated_kwargs(self, deprecated_kwargs): ----- This method is called by the set_up method. """ - norms= deprecated_kwargs.pop('norms', None) - prob=deprecated_kwargs.pop('prob', None) - if norms is not None: + norms = deprecated_kwargs.pop('norms', None) + prob = deprecated_kwargs.pop('prob', None) + if norms is not None: self.operator.set_norms(norms) warnings.warn( ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') @@ -153,11 +151,13 @@ def _deprecated_kwargs(self, deprecated_kwargs): else: if prob is not None: warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - self.sampler = Sampler.random_with_replacement(len(operator), prob=prob) - + self.sampler = Sampler.random_with_replacement( + len(operator), prob=prob) + if deprecated_kwargs: - warnings.warn("Additional keyword arguments passed but not used: {}".format(deprecated_kwargs)) - + warnings.warn("Additional keyword arguments passed but not used: {}".format( + deprecated_kwargs)) + @property def sigma(self): return self._sigma @@ -329,10 +329,11 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self.sampler = sampler self._deprecated_kwargs(deprecated_kwargs) if self.sampler is None: - self.sampler=Sampler.random_with_replacement(len(operator)) + self.sampler = Sampler.random_with_replacement(len(operator)) self.norms = operator.get_norms_as_list() - self.prob_weights = self.sampler.prob_weights # TODO: consider the case it is uniform and not saving the array + # TODO: consider the case it is uniform and not saving the array + self.prob_weights = self.sampler.prob_weights if self.prob_weights is None: self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets @@ -361,9 +362,9 @@ def set_up(self, f, g, operator, sigma=None, tau=None, def update(self): # Gradient descent for the primal variable # x_tmp = x - tau * zbar - self.x.sapyb(1., self.zbar, -self._tau, out=self.x_tmp) + self.x.sapyb(1., self.zbar, -self.tau, out=self.x_tmp) - self.g.proximal(self.x_tmp, self._tau, out=self.x) + self.g.proximal(self.x_tmp, self.tau, out=self.x) # Choose subset i = next(self.sampler) @@ -372,9 +373,9 @@ def update(self): # y_k = y_old[i] + sigma[i] * K[i] x y_k = self.operator[i].direct(self.x) - y_k.sapyb(self._sigma[i], self.y_old[i], 1., out=y_k) + y_k.sapyb(self.sigma[i], self.y_old[i], 1., out=y_k) - y_k = self.f[i].proximal_conjugate(y_k, self._sigma[i]) + y_k = self.f[i].proximal_conjugate(y_k, self.sigma[i]) # Back-project # x_tmp = K[i]^*(y_k - y_old[i]) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index d89d2b9421..6b73c3c6ee 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -40,7 +40,7 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices #TODO: write unit tests. + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. From d1fffdf5fb6ec7b8cd21e1f990802d6309f45dc6 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 23 Nov 2023 11:23:33 +0000 Subject: [PATCH 073/115] Another attempt at speeding up unit tests --- Wrappers/Python/test/test_algorithms.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 2283fe2371..d501af8389 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -1155,14 +1155,14 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 250, + max_iteration = 200, update_objective_interval=250, prob = prob.copy(), use_axpby=True) ) algos[0].run(1000, verbose=0) algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 250, + max_iteration = 200, update_objective_interval=250, prob = prob.copy(), use_axpby=False) ) @@ -1177,7 +1177,7 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): ) logging.info("Quality measures {}".format(qm)) assert qm[0] < 0.005 - assert qm[1] < 5.e-05 + assert qm[1] < 0.001 @unittest.skipUnless(has_astra, "ccpi-astra not available") From b3dc8a1cae4c151f387b6fc0b7f1f6229a11ee37 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 23 Nov 2023 13:27:41 +0000 Subject: [PATCH 074/115] Added random seeds to tests --- Wrappers/Python/test/test_algorithms.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index d501af8389..d9ba1d353a 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -957,8 +957,8 @@ def test_SPDHG_vs_PDHG_implicit(self): prob = [1/len(A)]*len(A) spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 200, - update_objective_interval=1000, prob = prob) + max_iteration = 250, sampler=Sampler.random_with_replacement(len(A), seed=2), + update_objective_interval=1000) spdhg.run(1000, verbose=0) qm = (mae(spdhg.get_output(), pdhg.get_output()), @@ -974,7 +974,7 @@ def test_SPDHG_vs_PDHG_implicit(self): @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_PDHG_explicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(12,12)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -1040,7 +1040,7 @@ def test_SPDHG_vs_PDHG_explicit(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] spdhg = SPDHG(f=F,g=G,operator=A, max_iteration = 300, - update_objective_interval=300, prob = prob) + update_objective_interval=300, sampler=Sampler.random_with_replacement(len(A), prob=prob, seed=10)) spdhg.run(1000, verbose=0) @@ -1155,15 +1155,15 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 200, - update_objective_interval=250, prob = prob.copy(), use_axpby=True) + max_iteration = 220, + update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=True) ) algos[0].run(1000, verbose=0) algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 200, - update_objective_interval=250, prob = prob.copy(), use_axpby=False) + max_iteration = 220, + update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=False) ) algos[1].run(1000, verbose=0) From edbaa9fc02e7f29c8bce560889c05f53ddcbb0c9 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 24 Nov 2023 17:08:51 +0000 Subject: [PATCH 075/115] Started on Gemma's suggestions --- .../cil/optimisation/algorithms/SPDHG.py | 21 +-- .../cil/optimisation/utilities/sampler.py | 143 +++++++++--------- 2 files changed, 85 insertions(+), 79 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index d64b85c98c..fd85883ced 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -144,14 +144,14 @@ def _deprecated_kwargs(self, deprecated_kwargs): warnings.warn( ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') - if self.sampler is not None: + if self._sampler is not None: if prob is not None: raise TypeError( '`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') else: if prob is not None: warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - self.sampler = Sampler.random_with_replacement( + self._sampler = Sampler.random_with_replacement( len(operator), prob=prob) if deprecated_kwargs: @@ -289,7 +289,7 @@ def check_convergence(self): Boolean True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. N.B Convergence criterion currently can only be checked for scalar values of tau. """ - for i in range(len(self._sigma)): + for i in range(self.ndual_subsets): if isinstance(self.tau, Number) and isinstance(self._sigma[i], Number): if self._sigma[i] * self._tau * self.norms[i]**2 > self.prob_weights[i]: return False @@ -326,18 +326,19 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self.g = g self.operator = operator self.ndual_subsets = self.operator.shape[0] - self.sampler = sampler + self._sampler = sampler self._deprecated_kwargs(deprecated_kwargs) - if self.sampler is None: - self.sampler = Sampler.random_with_replacement(len(operator)) + if self._sampler is None: + self._sampler = Sampler.random_with_replacement(len(operator)) self.norms = operator.get_norms_as_list() # TODO: consider the case it is uniform and not saving the array - self.prob_weights = self.sampler.prob_weights - if self.prob_weights is None: + if self._sampler.prob_weights is None: self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets + else: + self.prob_weights=self._sampler.prob_weights - # might not want to do this until it is called (if computationally expensive) + self.set_step_sizes(sigma=sigma, tau=tau) # initialize primal variable @@ -367,7 +368,7 @@ def update(self): self.g.proximal(self.x_tmp, self.tau, out=self.x) # Choose subset - i = next(self.sampler) + i = next(self._sampler) # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 6b73c3c6ee..25dcf04d4f 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -42,6 +42,33 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + Example + ------- + >>> def test_function(iteration_number): + >>> if iteration_number<500: + >>> np.random.seed(iteration_number) + >>> return(np.random.choice(49,1)[0]) + >>> else: + >>> np.random.seed(iteration_number) + >>> return(np.random.choice(50,1)[0]) + + + >>> sampler=SamplerFromFunction(50, test_function) + >>> for _ in range(11): + >>> print(sampler.next()) + >>> print(list(sampler.get_samples(25))) + 44 + 37 + 40 + 42 + 46 + 35 + 10 + 47 + 3 + 28 + 9 + [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] Note @@ -52,38 +79,33 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we """ - self.type = sampling_type - self.num_indices = num_indices + self._type = sampling_type + self._num_indices = num_indices self.function = function if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') if any(np.array(prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') - self.prob_weights = prob_weights - self.iteration_number = 0 + self._prob_weights = prob_weights + self._iteration_number = 0 def next(self): """ - - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - + Returns and increments the sampler """ - out = self.function(self.iteration_number) - self.iteration_number = self.iteration_number+1 - return (out) + out = self.function(self._iteration_number) + self._iteration_number +=1 + return out def __next__(self): - """ - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - Allows the user to call next(sampler), to get the same result as sampler.next()""" - return (self.next()) + return self.next() def get_samples(self, num_samples=20): """ Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + TODO: change this to be relevant to this class! num_samples: int, default=20 The number of samples to return. @@ -94,11 +116,11 @@ def get_samples(self, num_samples=20): >>> print(sampler.get_samples()) [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ - save_last_index = self.iteration_number - self.iteration_number = 0 + save_last_index = self._iteration_number + self._iteration_number = 0 output = [self.next() for _ in range(num_samples)] - self.iteration_number = save_last_index - return (np.array(output)) + self._iteration_number = save_last_index + return np.array(output) class SamplerFromOrder(): @@ -134,28 +156,21 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') - self.prob_weights = prob_weights - self.type = sampling_type - self.num_indices = num_indices - self.order = order - self.last_index = len(order)-1 + self._prob_weights = prob_weights + self._type = sampling_type + self._num_indices = num_indices + self._order = order + self._last_index = len(order)-1 + # TODO: add in properties for the things that need calling by SPDHG def next(self): - """ + """Returns and increments the sampler """ - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - """ - - self.last_index = (self.last_index+1) % len(self.order) - return (self.order[self.last_index]) + self._last_index = (self._last_index+1) % len(self._order) + return self._order[self._last_index] def __next__(self): - """ - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - Allows the user to call next(sampler), to get the same result as sampler.next()""" - return (self.next()) + return self.next() def get_samples(self, num_samples=20): """ @@ -172,11 +187,11 @@ def get_samples(self, num_samples=20): [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ - save_last_index = self.last_index - self.last_index = len(self.order)-1 + save_last_index = self._last_index + self._last_index = len(self._order)-1 output = [self.next() for _ in range(num_samples)] - self.last_index = save_last_index - return (np.array(output)) + self._last_index = save_last_index + return np.array(output) class SamplerRandom(): @@ -214,45 +229,35 @@ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): """ - self.replace = replace - self.prob = prob + self._replace = replace + self._prob = prob if prob is None: - self.prob = [1/num_indices]*num_indices + self._prob = [1/num_indices]*num_indices if replace: - self.prob_weights = prob + self._prob_weights = self._prob else: - self.prob_weights = [1/num_indices]*num_indices - if abs(sum(self.prob_weights)-1) > 1e-6: + self._prob_weights = [1/num_indices]*num_indices + if abs(sum(self._prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') - if any(np.array(self.prob_weights) < 0): + if any(np.array(self._prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') - self.type = sampling_type - self.num_indices = num_indices + self._type = sampling_type + self._num_indices = num_indices if seed is not None: - self.seed = seed + self._seed = seed else: - self.seed = int(time.time()) - self.generator = np.random.RandomState(self.seed) + self._seed = int(time.time()) + self._generator = np.random.RandomState(self._seed) def next(self): - """ - - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. + """ Returns and increments the sampler """ - This function us used by samplers that select from a list of indices{0, 1, …, S-1}, with S=num_indices, randomly with and without replacement. - - """ - - return int(self.generator.choice(self.num_indices, 1, p=self.prob, replace=self.replace)) + return int(self._generator.choice(self._num_indices, 1, p=self._prob, replace=self._replace)) def __next__(self): - """ - A function of the sampler that selects from a list of indices {0, 1, …, S-1}, with S=num_indices, the next sample according to the type of sampling. - - Allows the user to call next(sampler), to get the same result as sampler.next()""" - return (self.next()) + return self.next() def get_samples(self, num_samples=20): """ @@ -269,11 +274,11 @@ def get_samples(self, num_samples=20): [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ - save_generator = self.generator - self.generator = np.random.RandomState(self.seed) + save_generator = self._generator + self._generator = np.random.RandomState(self._seed) output = [self.next() for _ in range(num_samples)] - self.generator = save_generator - return (np.array(output)) + self._generator = save_generator + return np.array(output) class Sampler(): From dc1b67ae30b8496e9c80ef5f5be91d54c1792b53 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 27 Nov 2023 14:20:41 +0000 Subject: [PATCH 076/115] Some more of Gemma's changes --- .../cil/optimisation/algorithms/SPDHG.py | 172 ++++++++-------- .../cil/optimisation/utilities/__init__.py | 3 + .../cil/optimisation/utilities/sampler.py | 188 +++++++++++++----- Wrappers/Python/test/test_sampler.py | 56 +++--- docs/source/optimisation.rst | 29 +++ 5 files changed, 285 insertions(+), 163 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index fd85883ced..fd6baa70c1 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -19,6 +19,7 @@ # Claire Delplancke (University of Bath) from cil.optimisation.algorithms import Algorithm +from cil.optimisation.operators import BlockOperator import numpy as np import warnings import logging @@ -116,18 +117,93 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=None, sampler=None, **kwargs): max_iteration = kwargs.pop('max_iteration', 0) - update_objective_interval = kwargs.pop('update_objective_interval', 1) - log_file = kwargs.pop('log_file', None) + return_all=kwargs.pop('return_all', False) + print_interval= kwargs.pop('print_interval', None) + log_file= kwargs.pop('log_file', None) + update_objective_interval = kwargs.get('update_objective_interval', 1) super(SPDHG, self).__init__(max_iteration=max_iteration, - update_objective_interval=update_objective_interval, log_file=log_file) + update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval, update_objective_interval=update_objective_interval, return_all=return_all) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, initial=initial, sampler=sampler) + + def set_up(self, f, g, operator, sigma=None, tau=None, + initial=None, sampler=None, **deprecated_kwargs): + '''set-up of the algorithm + Parameters + ---------- + f : BlockFunction + Each must be a convex function with a "simple" proximal method of its conjugate + g : Function + A convex function with a "simple" proximal + operator : BlockOperator + BlockOperator must contain Linear Operators + tau : positive float, optional, default=None + Step size parameter for Primal problem + sigma : list of positive float, optional, default=None + List of Step size parameters for Dual problem + initial : DataContainer, optional, default=None + Initial point for the SPDHG algorithm + gamma : float + parameter controlling the trade-off between the primal and dual step sizes + sampler: an instance of a `cil.optimisation.utilities.Sampler` class + Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets + ''' + logging.info("{} setting up".format(self.__class__.__name__, )) + + # algorithmic parameters + self.f = f + self.g = g + self.operator = operator + + if not isinstance(operator, BlockOperator): + raise TypeError("operator should be a BlockOperator") + + self.ndual_subsets = len(self.operator) + self._sampler = sampler + self._deprecated_kwargs(deprecated_kwargs) + + if self._sampler is None: + self._sampler = Sampler.random_with_replacement(len(operator)) + + if self._sampler.num_indices != len(operator): + raise ValueError('The `num_indices` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') + + self.norms = operator.get_norms_as_list() + + if self._sampler.prob_weights is None: + self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets + else: + self.prob_weights=self._sampler.prob_weights + + self.set_step_sizes(sigma=sigma, tau=tau) + + # initialize primal variable + if initial is None: + self.x = self.operator.domain_geometry().allocate(0) + else: + self.x = initial.copy() + + self.x_tmp = self.operator.domain_geometry().allocate(0) + + # initialize dual variable to 0 + self.y_old = operator.range_geometry().allocate(0) + + # initialize variable z corresponding to back-projected dual variable + self.z = operator.domain_geometry().allocate(0) + self.zbar = operator.domain_geometry().allocate(0) + # relaxation parameter + self.theta = 1 + self.configured = True + logging.info("{} configured".format(self.__class__.__name__, )) + def _deprecated_kwargs(self, deprecated_kwargs): """ Handle deprecated keyword arguments for backward compatibility. + TODO: test this! + Parameters ---------- deprecated_kwargs : dict @@ -152,7 +228,7 @@ def _deprecated_kwargs(self, deprecated_kwargs): if prob is not None: warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') self._sampler = Sampler.random_with_replacement( - len(operator), prob=prob) + len(self.operator), prob=prob) if deprecated_kwargs: warnings.warn("Additional keyword arguments passed but not used: {}".format( @@ -171,9 +247,9 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): Parameters ---------- - gamma : float + gamma : Positive float parameter controlling the trade-off between the primal and dual step sizes - rho : float + rho : Positive float parameter controlling the size of the product :math: \sigma\tau :math: Note @@ -195,7 +271,7 @@ def set_step_sizes_from_ratio(self, gamma=1., rho=.99): if isinstance(rho, Number): if rho <= 0: raise ValueError( - "The step-sizes of SPDHG are positive, gamma should also be positive") + "The step-sizes of SPDHG are positive, rho should also be positive") else: raise ValueError( @@ -246,15 +322,12 @@ def set_step_sizes(self, sigma=None, tau=None): rho = .99 if sigma is not None: if len(sigma) == self.ndual_subsets: - if all(isinstance(x, Number) for x in sigma): - if all(x > 0 for x in sigma): + if all(isinstance(x, Number) and x > 0 for x in sigma): pass - else: - raise ValueError( - "The values of sigma should be positive") else: raise ValueError( - "The values of sigma should be a Number") + "Sigma expected to be a positive number.") + else: raise ValueError( "Please pass a list of floats to sigma with the same number of entries as number of operators") @@ -272,13 +345,12 @@ def set_step_sizes(self, sigma=None, tau=None): self._tau = min([value for value in values if value > 1e-8]) self._tau *= (rho / gamma) else: - if isinstance(tau, Number): - if tau <= 0: - raise ValueError( - "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) + if isinstance(tau, Number) and tau > 0: + pass else: raise ValueError( - "The value of tau should be a Number") + "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) + self._tau = tau def check_convergence(self): @@ -297,69 +369,7 @@ def check_convergence(self): else: return False - def set_up(self, f, g, operator, sigma=None, tau=None, - initial=None, sampler=None, **deprecated_kwargs): - '''set-up of the algorithm - Parameters - ---------- - f : BlockFunction - Each must be a convex function with a "simple" proximal method of its conjugate - g : Function - A convex function with a "simple" proximal - operator : BlockOperator - BlockOperator must contain Linear Operators - tau : positive float, optional, default=None - Step size parameter for Primal problem - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem - initial : DataContainer, optional, default=None - Initial point for the SPDHG algorithm - gamma : float - parameter controlling the trade-off between the primal and dual step sizes - sampler: an instance of a `cil.optimisation.utilities.Sampler` class - Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets - ''' - logging.info("{} setting up".format(self.__class__.__name__, )) - - # algorithmic parameters - self.f = f - self.g = g - self.operator = operator - self.ndual_subsets = self.operator.shape[0] - self._sampler = sampler - self._deprecated_kwargs(deprecated_kwargs) - if self._sampler is None: - self._sampler = Sampler.random_with_replacement(len(operator)) - self.norms = operator.get_norms_as_list() - - # TODO: consider the case it is uniform and not saving the array - if self._sampler.prob_weights is None: - self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets - else: - self.prob_weights=self._sampler.prob_weights - - - self.set_step_sizes(sigma=sigma, tau=tau) - - # initialize primal variable - if initial is None: - self.x = self.operator.domain_geometry().allocate(0) - else: - self.x = initial.copy() - - self.x_tmp = self.operator.domain_geometry().allocate(0) - - # initialize dual variable to 0 - self.y_old = operator.range_geometry().allocate(0) - - # initialize variable z corresponding to back-projected dual variable - self.z = operator.domain_geometry().allocate(0) - self.zbar = operator.domain_geometry().allocate(0) - # relaxation parameter - self.theta = 1 - self.configured = True - logging.info("{} configured".format(self.__class__.__name__, )) - + def update(self): # Gradient descent for the primal variable # x_tmp = x - tau * zbar diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py index 6aa6db103f..a96692e1ce 100644 --- a/Wrappers/Python/cil/optimisation/utilities/__init__.py +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -19,3 +19,6 @@ from .sampler import Sampler +from .sampler import SamplerFromFunction +from .sampler import SamplerFromOrder +from .sampler import SamplerRandom diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 25dcf04d4f..20d215e82e 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -22,12 +22,11 @@ class SamplerFromFunction(): - def __init__(self, num_indices, function, sampling_type='from_function', prob_weights=None): - """ - The user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. + """ A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. + It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. Parameters ---------- @@ -37,11 +36,11 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we sampling_type:str The sampling type used. Choose from "from_function". - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + Example ------- >>> def test_function(iteration_number): @@ -51,9 +50,8 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we >>> else: >>> np.random.seed(iteration_number) >>> return(np.random.choice(50,1)[0]) - - - >>> sampler=SamplerFromFunction(50, test_function) + >>> + >>> Sampler.from_function(num_indices, function, prob_weights=None) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -70,32 +68,43 @@ def __init__(self, num_indices, function, sampling_type='from_function', prob_we 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] - Note ----- If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise - the get_samples() function may not accurately return the correct samples and may interrupt the next sample returned. - - - + the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ + + def __init__(self, num_indices, function, sampling_type='from_function', prob_weights=None): + self._type = sampling_type self._num_indices = num_indices self.function = function + if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') + if any(np.array(prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') + self._prob_weights = prob_weights self._iteration_number = 0 + @property + def prob_weights(self): + return self._prob_weights + + @property + def num_indices(self): + return self._num_indices + + def next(self): """ Returns and increments the sampler """ out = self.function(self._iteration_number) - self._iteration_number +=1 + self._iteration_number += 1 return out def __next__(self): @@ -103,18 +112,10 @@ def __next__(self): def get_samples(self, num_samples=20): """ - Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + Returns the first `num_samples` produced by the sampler as a numpy array. - TODO: change this to be relevant to this class! num_samples: int, default=20 The number of samples to return. - - Example - ------- - - >>> sampler=Sampler.random_with_replacement(5) - >>> print(sampler.get_samples()) - [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] """ save_last_index = self._iteration_number self._iteration_number = 0 @@ -127,10 +128,9 @@ class SamplerFromOrder(): def __init__(self, num_indices, order, sampling_type, prob_weights=None): """ - The user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. - A class to select from a list of indices {0, 1, …, S-1} - The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + A class to select from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. Parameters ---------- @@ -143,15 +143,58 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): order: list of indices The list of indices the method selects from using next. - prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + Example + ------- + + >>> sampler=Sampler.custom_order(12,[1,4,6,7,8,9,11]) + >>> print(sampler.get_samples(11)) + >>> for _ in range(9): + >>> print(sampler.next()) + >>> print(sampler.get_samples(5)) + [ 1 4 6 7 8 9 11 1 4 6 7] + 1 + 4 + 6 + 7 + 8 + 9 + 11 + 1 + 4 + [1 4 6 7 8] + + + >>> sampler=Sampler.staggered(21,4) + >>> print(sampler.get_samples(5)) + >>> for _ in range(15): + >>> print(sampler.next()) + >>> print(sampler.get_samples(5)) + [ 0 4 8 12 16] + 0 + 4 + 8 + 12 + 16 + 20 + 1 + 5 + 9 + 13 + 17 + 2 + 6 + 10 + 14 + [ 0 4 8 12 16] """ if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') + if any(np.array(prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') @@ -162,7 +205,17 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): self._order = order self._last_index = len(order)-1 - # TODO: add in properties for the things that need calling by SPDHG + + + @property + def prob_weights(self): + return self._prob_weights + + @property + def num_indices(self): + return self._num_indices + + def next(self): """Returns and increments the sampler """ @@ -174,7 +227,10 @@ def __next__(self): def get_samples(self, num_samples=20): """ - Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + Returns the first `num_samples` as a numpy array. + + Parameters + ---------- num_samples: int, default=20 The number of samples to return. @@ -195,12 +251,11 @@ def get_samples(self, num_samples=20): class SamplerRandom(): - r""" - The user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. A class to select from a list of indices {0, 1, …, S-1} using numpy.random.choice with and without replacement. The function next() outputs a single next index from the list {0,1,…,S-1} . To be run again and again, depending on how many iterations. + It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. Parameters ---------- @@ -221,35 +276,59 @@ class SamplerRandom(): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + Example + ------- + >>> sampler=Sampler.random_with_replacement(5) + >>> print(sampler.get_samples(10)) + [3 4 0 0 2 3 3 2 2 1] + + >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) + >>> print(sampler.get_samples(10)) + [0 1 3 0 0 3 0 0 0 0] + + >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) + >>> print(sampler.get_samples(16)) + [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] """ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): - """ - This method is the internal init for the sampler method. Most users should call the static methods e.g. Sampler.sequential or Sampler.staggered. - - """ - + self._replace = replace self._prob = prob + if prob is None: self._prob = [1/num_indices]*num_indices + if replace: self._prob_weights = self._prob else: self._prob_weights = [1/num_indices]*num_indices + if abs(sum(self._prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') + if any(np.array(self._prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') self._type = sampling_type self._num_indices = num_indices + if seed is not None: self._seed = seed else: self._seed = int(time.time()) + self._generator = np.random.RandomState(self._seed) + + @property + def prob_weights(self): + return self._prob_weights + + @property + def num_indices(self): + return self._num_indices def next(self): """ Returns and increments the sampler """ @@ -261,14 +340,13 @@ def __next__(self): def get_samples(self, num_samples=20): """ - Function that takes an index, num_samples, and returns the first num_samples as a numpy array. + Returns the first `num_samples` as a numpy array. num_samples: int, default=20 The number of samples to return. Example ------- - >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples()) [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] @@ -316,7 +394,6 @@ class Sampler(): >>> print(sampler.get_samples(5)) >>> for _ in range(11): print(sampler.next()) - [0 1 2 3 4] 0 1 @@ -336,7 +413,6 @@ class Sampler(): >>> for _ in range(12): >>> print(next(sampler)) >>> print(sampler.get_samples()) - 3 4 0 @@ -380,7 +456,6 @@ def sequential(num_indices): >>> print(sampler.get_samples(5)) >>> for _ in range(11): print(sampler.next()) - [0 1 2 3 4] 0 1 @@ -422,7 +497,6 @@ def custom_order(num_indices, custom_list, prob_weights=None): >>> for _ in range(9): >>> print(sampler.next()) >>> print(sampler.get_samples(5)) - [ 1 4 6 7 8 9 11 1 4 6 7] 1 4 @@ -436,6 +510,7 @@ def custom_order(num_indices, custom_list, prob_weights=None): [1 4 6 7 8] """ + if prob_weights is None: temp_list = [] for i in range(num_indices): @@ -463,7 +538,6 @@ def herman_meyer(num_indices): ------- >>> sampler=Sampler.herman_meyer(12) >>> print(sampler.get_samples(16)) - [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] """ @@ -472,34 +546,45 @@ def _herman_meyer_order(n): n_variable = n i = 2 factors = [] + while i * i <= n_variable: if n_variable % i: i += 1 else: n_variable //= i factors.append(i) + if n_variable > 1: factors.append(n_variable) + n_factors = len(factors) + if n_factors == 0: raise ValueError( 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') + order = [0 for _ in range(n)] value = 0 + for factor_n in range(n_factors): n_rep_value = 0 + if factor_n == 0: n_change_value = 1 else: n_change_value = math.prod(factors[:factor_n]) + for element in range(n): mapping = value n_rep_value += 1 + if n_rep_value >= n_change_value: value = value + 1 n_rep_value = 0 + if value == factors[factor_n]: value = 0 + order[element] = order[element] + \ math.prod(factors[factor_n+1:]) * mapping return order @@ -528,7 +613,6 @@ def staggered(num_indices, offset): >>> for _ in range(15): >>> print(sampler.next()) >>> print(sampler.get_samples(5)) - [ 0 4 8 12 16] 0 4 @@ -547,8 +631,10 @@ def staggered(num_indices, offset): 14 [ 0 4 8 12 16] """ + if offset >= num_indices: raise (ValueError('The offset should be less than the number of indices')) + indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] @@ -573,24 +659,19 @@ def random_with_replacement(num_indices, prob=None, seed=None): Example ------- - - >>> sampler=Sampler.random_with_replacement(5) >>> print(sampler.get_samples(10)) - [3 4 0 0 2 3 3 2 2 1] - Example - ------- - + >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) >>> print(sampler.get_samples(10)) - [0 1 3 0 0 3 0 0 0 0] """ if prob == None: prob = [1/num_indices] * num_indices + sampler = SamplerRandom( num_indices, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) return sampler @@ -600,21 +681,20 @@ def random_without_replacement(num_indices, seed=None, prob=None): """ Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. - + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - Example ------- >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) >>> print(sampler.get_samples(16)) [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] - """ sampler = SamplerRandom( @@ -645,7 +725,7 @@ def from_function(num_indices, function, prob_weights=None): Note ----- If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise - the get_samples() function may not accurately return the correct samples and may interrupt the next sample returned. + the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. Example ------- diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 576660a3d9..d7723de957 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -43,50 +43,50 @@ def test_init(self): sampler = Sampler.sequential(10) self.assertEqual(sampler.num_indices, 10) - self.assertEqual(sampler.type, 'sequential') - self.assertListEqual(sampler.order, list(range(10))) - self.assertEqual(sampler.last_index, 9) + self.assertEqual(sampler._type, 'sequential') + self.assertListEqual(sampler._order, list(range(10))) + self.assertEqual(sampler._last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) sampler = Sampler.random_without_replacement(7) self.assertEqual(sampler.num_indices, 7) - self.assertEqual(sampler.type, 'random_without_replacement') - self.assertEqual(sampler.prob, [1/7]*7) - self.assertListEqual(sampler.prob_weights, sampler.prob) + self.assertEqual(sampler._type, 'random_without_replacement') + self.assertEqual(sampler._prob, [1/7]*7) + self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.random_without_replacement(8, seed=1) self.assertEqual(sampler.num_indices, 8) - self.assertEqual(sampler.type, 'random_without_replacement') - self.assertEqual(sampler.prob, [1/8]*8) - self.assertEqual(sampler.seed, 1) - self.assertListEqual(sampler.prob_weights, sampler.prob) + self.assertEqual(sampler._type, 'random_without_replacement') + self.assertEqual(sampler._prob, [1/8]*8) + self.assertEqual(sampler._seed, 1) + self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.herman_meyer(12) self.assertEqual(sampler.num_indices, 12) - self.assertEqual(sampler.type, 'herman_meyer') - self.assertEqual(sampler.last_index, 11) + self.assertEqual(sampler._type, 'herman_meyer') + self.assertEqual(sampler._last_index, 11) self.assertListEqual( - sampler.order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) + sampler._order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.random_with_replacement(5) self.assertEqual(sampler.num_indices, 5) - self.assertEqual(sampler.type, 'random_with_replacement') - self.assertListEqual(sampler.prob, [1/5] * 5) + self.assertEqual(sampler._type, 'random_with_replacement') + self.assertListEqual(sampler._prob, [1/5] * 5) self.assertListEqual(sampler.prob_weights, [1/5] * 5) sampler = Sampler.random_with_replacement(4, [0.7, 0.1, 0.1, 0.1]) self.assertEqual(sampler.num_indices, 4) - self.assertEqual(sampler.type, 'random_with_replacement') - self.assertListEqual(sampler.prob, [0.7, 0.1, 0.1, 0.1]) + self.assertEqual(sampler._type, 'random_with_replacement') + self.assertListEqual(sampler._prob, [0.7, 0.1, 0.1, 0.1]) self.assertListEqual(sampler.prob_weights, [0.7, 0.1, 0.1, 0.1]) sampler = Sampler.staggered(21, 4) self.assertEqual(sampler.num_indices, 21) - self.assertEqual(sampler.type, 'staggered') - self.assertListEqual(sampler.order, [ + self.assertEqual(sampler._type, 'staggered') + self.assertListEqual(sampler._order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) - self.assertEqual(sampler.last_index, 20) + self.assertEqual(sampler._last_index, 20) self.assertListEqual(sampler.prob_weights, [1/21] * 21) with self.assertRaises(ValueError): @@ -95,17 +95,17 @@ def test_init(self): sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) self.assertEqual(sampler.num_indices, 12) - self.assertEqual(sampler.type, 'custom_order') - self.assertListEqual(sampler.order, [1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler.last_index, 6) + self.assertEqual(sampler._type, 'custom_order') + self.assertListEqual(sampler._order, [1, 4, 6, 7, 8, 9, 11]) + self.assertEqual(sampler._last_index, 6) self.assertListEqual(sampler.prob_weights, [ 0, 1/7, 0, 0, 1/7, 0, 1/7, 1/7, 1/7, 1/7, 0, 1/7]) sampler = Sampler.custom_order(10, [0,1, 2, 3, 4]) self.assertEqual(sampler.num_indices, 10) - self.assertEqual(sampler.type, 'custom_order') - self.assertListEqual(sampler.order, [0,1,2,3,4]) - self.assertEqual(sampler.last_index, 4) + self.assertEqual(sampler._type, 'custom_order') + self.assertListEqual(sampler._order, [0,1,2,3,4]) + self.assertEqual(sampler._last_index, 4) self.assertListEqual(sampler.prob_weights, [ 1/5,1/5,1/5,1/5,1/5,0,0,0,0,0]) @@ -122,12 +122,12 @@ def test_init(self): sampler = Sampler.from_function(50, self.example_function) self.assertListEqual(sampler.prob_weights, [1/50] * 50) self.assertEqual(sampler.num_indices, 50) - self.assertEqual(sampler.type, 'from_function') + self.assertEqual(sampler._type, 'from_function') sampler = Sampler.from_function(40, self.example_function, [1]+[0]*39) self.assertListEqual(sampler.prob_weights, [1]+[0]*39) self.assertEqual(sampler.num_indices, 40) - self.assertEqual(sampler.type, 'from_function') + self.assertEqual(sampler._type, 'from_function') #check probabilities sum to 1 and are positive with self.assertRaises(ValueError): diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 8b92feb669..90bff47aeb 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -365,6 +365,33 @@ Total variation :members: :special-members: + +Utilities +======= +Contains utilities for the CIL optimisation framework. + +Sampler +-------- +A class to select from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + +It is recommended to use the static methods in `cil.optimisation.utilities.sampler` to configure your Sampler object rather than initialising this class directly: + +.. autoclass:: cil.optimisation.utilities.Sampler + :members: + + +The static methods will call one of the following: + +.. autoclass:: cil.optimisation.utilities.SamplerRandom + :members: + +.. autoclass:: cil.optimisation.utilities.SamplerFromFunction + :members: + +.. autoclass:: cil.optimisation.utilities.SamplerFromOrder + :members: + + Block Framework *************** @@ -564,6 +591,8 @@ Which in Python would be like .. _BlockOperator: optimisation.html#cil.optimisation.operators.BlockOperators + + References ---------- From 3b41fc405bfb44a69e4e3c2dcc9abd8ebb590d90 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 27 Nov 2023 15:34:43 +0000 Subject: [PATCH 077/115] Last of Gemma's changes --- .../cil/optimisation/algorithms/SPDHG.py | 11 +- Wrappers/Python/test/test_algorithms.py | 293 +++++++++++------- 2 files changed, 184 insertions(+), 120 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index fd6baa70c1..dbda58f72a 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -120,12 +120,13 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, return_all=kwargs.pop('return_all', False) print_interval= kwargs.pop('print_interval', None) log_file= kwargs.pop('log_file', None) - update_objective_interval = kwargs.get('update_objective_interval', 1) + use_axpby=kwargs.pop('use_axpyb', None) + update_objective_interval = kwargs.pop('update_objective_interval', 1) super(SPDHG, self).__init__(max_iteration=max_iteration, - update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval, update_objective_interval=update_objective_interval, return_all=return_all) + update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval, return_all=return_all) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - initial=initial, sampler=sampler) + initial=initial, sampler=sampler, **kwargs) def set_up(self, f, g, operator, sigma=None, tau=None, initial=None, sampler=None, **deprecated_kwargs): @@ -201,8 +202,6 @@ def set_up(self, f, g, operator, sigma=None, tau=None, def _deprecated_kwargs(self, deprecated_kwargs): """ Handle deprecated keyword arguments for backward compatibility. - - TODO: test this! Parameters ---------- @@ -231,7 +230,7 @@ def _deprecated_kwargs(self, deprecated_kwargs): len(self.operator), prob=prob) if deprecated_kwargs: - warnings.warn("Additional keyword arguments passed but not used: {}".format( + raise ValueError("Additional keyword arguments passed but not used: {}".format( deprecated_kwargs)) @property diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index d9ba1d353a..8b72a4084a 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -773,108 +773,172 @@ def setUp(self): partitioned_data = sin.partition(self.subsets, 'sequential') self.A = BlockOperator( *[IdentityOperator(partitioned_data[i].geometry) for i in range(self.subsets)]) + self.A2 = BlockOperator( + *[IdentityOperator(partitioned_data[i].geometry) for i in range(self.subsets)]) # block function self.F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) - for i in range(self.subsets)]) + for i in range(self.subsets)]) alpha = 0.025 self.G = alpha * FGP_TV() def test_SPDHG_defaults_and_setters(self): - gamma=1. - rho=.99 + gamma = 1. + rho = .99 spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) - - + self.assertListEqual(spdhg.norms, [self.A.get_item(i, 0).norm() - for i in range(self.subsets)]) - self.assertListEqual(spdhg.prob_weights, [1/self.subsets] * self.subsets) - self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) + for i in range(self.subsets)]) + self.assertListEqual(spdhg.prob_weights, [ + 1/self.subsets] * self.subsets) + self.assertListEqual( + spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(0).array) + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) + self.assertNumpyArrayEqual( + spdhg.x.array, self.A.domain_geometry().allocate(0).array) self.assertEqual(spdhg.max_iteration, 0) self.assertEqual(spdhg.update_objective_interval, 1) - - - - - gamma=3.7 - rho=5.6 - spdhg.set_step_sizes_from_ratio(gamma,rho) - self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) + + gamma = 3.7 + rho = 5.6 + spdhg.set_step_sizes_from_ratio(gamma, rho) + self.assertListEqual( + spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - - gamma=1. - rho=.99 + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) + + gamma = 1. + rho = .99 spdhg.set_step_sizes() - self.assertListEqual(spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) + self.assertListEqual( + spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) - + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, 100) - + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, min([(pi / (si * ni**2))*(rho / gamma) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) + si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) spdhg.set_step_sizes(sigma=None, tau=100) - self.assertListEqual(spdhg.sigma, [gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg.norms, spdhg.prob_weights)] ) + self.assertListEqual(spdhg.sigma, [ + gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg.norms, spdhg.prob_weights)]) self.assertEqual(spdhg.tau, 100) - def test_spdhg_non_default_init(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.random_with_replacement(10, list(np.arange(1,11)/55.)), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.)), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) - - self.assertListEqual(spdhg.prob_weights, list(np.arange(1,11)/55.)) - self.assertNumpyArrayEqual(spdhg.x.array, self.A.domain_geometry().allocate(1).array) + self.assertListEqual(spdhg.prob_weights, list(np.arange(1, 11)/55.)) + self.assertNumpyArrayEqual( + spdhg.x.array, self.A.domain_geometry().allocate(1).array) self.assertEqual(spdhg.max_iteration, 1000) self.assertEqual(spdhg.update_objective_interval, 10) - + + def test_spdhg_deprecated_vargs(self): + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[ + 1]*len(self.A), prob=[1/(self.subsets-1)]*(self.subsets-1)+[0]) + + self.assertListEqual(self.A.get_norms_as_list(), [1]*len(self.A)) + self.assertListEqual(spdhg.norms, [1]*len(self.A)) + self.assertListEqual(spdhg._sampler.prob_weights, [ + 1/(self.subsets-1)]*(self.subsets-1)+[0]) + self.assertListEqual(spdhg.prob_weights, [ + 1/(self.subsets-1)]*(self.subsets-1)+[0]) + + with self.assertRaises(TypeError): + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[1]*len(self.A), prob=[1/(self.subsets-1)]*( + self.subsets-1)+[0], sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) + + with self.assertRaises(ValueError): + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sfdsdf=3, norms=[ + 1]*len(self.A), sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) + def test_spdhg_custom_sampler(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order( len(self.A), [0,0,0,0]), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A), [0, 0, 0, 0]), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) self.assertListEqual(spdhg.prob_weights, [1]+[0]*(len(self.A)-1)) - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A),[0,1,0,1]), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10 ) - self.assertListEqual(spdhg.prob_weights, [.5]+[.5]+[0]*(len(self.A)-2)) - - + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A), [0, 1, 0, 1]), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) + self.assertListEqual(spdhg.prob_weights, + [.5]+[.5]+[0]*(len(self.A)-2)) + + def test_spdhg_set_norms(self): + + self.A2.set_norms([1]*len(self.A2)) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A2) + self.assertListEqual(spdhg.norms, [1]*len(self.A2)) def test_spdhg_check_convergence(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) - + self.assertTrue(spdhg.check_convergence()) - - gamma=3.7 - rho=0.9 - spdhg.set_step_sizes_from_ratio(gamma,rho) + + gamma = 3.7 + rho = 0.9 + spdhg.set_step_sizes_from_ratio(gamma, rho) self.assertTrue(spdhg.check_convergence()) - - gamma=3.7 - rho=100 - spdhg.set_step_sizes_from_ratio(gamma,rho) + + gamma = 3.7 + rho = 100 + spdhg.set_step_sizes_from_ratio(gamma, rho) self.assertFalse(spdhg.check_convergence()) - + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) self.assertFalse(spdhg.check_convergence()) - + spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) self.assertTrue(spdhg.check_convergence()) spdhg.set_step_sizes(sigma=None, tau=100) self.assertTrue(spdhg.check_convergence()) - @unittest.skipUnless(has_astra, "cil-astra not available") - def test_SPDHG_vs_PDHG_implicit(self): + def test_SPDHG_num_subsets_1(self): + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(10, 10)) + + subsets = 1 + + ig = data.geometry + ig.voxel_size_x = 0.1 + ig.voxel_size_y = 0.1 + + detectors = ig.shape[0] + angles = np.linspace(0, np.pi, 90) + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) + # Select device + dev = 'cpu' + + Aop = ProjectionOperator(ig, ag, dev) + + sin = Aop.direct(data) + partitioned_data = sin.partition(subsets, 'sequential') + A = BlockOperator( + *[IdentityOperator(partitioned_data[i].geometry) for i in range(subsets)]) + + # block function + F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) + for i in range(subsets)]) + alpha = 0.025 + G = alpha * FGP_TV() - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(12,12)) + spdhg = SPDHG(f=F, g=G, operator=A, max_iteration=10, update_objective_interval=10, print_interval=10, log_file=None) + + spdhg.run(7) + pdhg = PDHG(f=F, g=G, operator=A, max_iteration=10, update_objective_interval=10, print_interval=10, log_file=None) + + pdhg.run(7) + self.assertNumpyArrayAlmostEqual(pdhg.solution.as_array(), spdhg.solution.as_array(), decimal=3) + + @unittest.skipUnless(has_astra, "cil-astra not available") + def test_SPDHG_vs_PDHG_implicit(self): + + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(12, 12)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -917,15 +981,18 @@ def test_SPDHG_vs_PDHG_implicit(self): # % 'implicit' PDHG, preconditioned step-sizes tau_tmp = 1. sigma_tmp = 1. - tau = sigma_tmp / operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) - sigma = tau_tmp / operator.direct(sigma_tmp * operator.domain_geometry().allocate(1.)) - + tau = sigma_tmp / \ + operator.adjoint(tau_tmp * operator.range_geometry().allocate(1.)) + sigma = tau_tmp / \ + operator.direct( + sigma_tmp * operator.domain_geometry().allocate(1.)) + # Setup and run the PDHG algorithm - pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 80, - update_objective_interval = 1000) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=80, + update_objective_interval=1000) pdhg.run(verbose=0) - + subsets = 5 size_of_subsets = int(len(angles)/subsets) # take angles and create uniform subsets in uniform+sequential setting @@ -955,12 +1022,12 @@ def test_SPDHG_vs_PDHG_implicit(self): G = alpha * TotalVariation(50, 1e-4, lower=0) prob = [1/len(A)]*len(A) - - spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 250, sampler=Sampler.random_with_replacement(len(A), seed=2), - update_objective_interval=1000) + + spdhg = SPDHG(f=F, g=G, operator=A, + max_iteration=250, sampler=Sampler.random_with_replacement(len(A), seed=2), + update_objective_interval=1000) spdhg.run(1000, verbose=0) - + qm = (mae(spdhg.get_output(), pdhg.get_output()), mse(spdhg.get_output(), pdhg.get_output()), psnr(spdhg.get_output(), pdhg.get_output()) @@ -974,7 +1041,7 @@ def test_SPDHG_vs_PDHG_implicit(self): @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_PDHG_explicit(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16, 16)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -1004,8 +1071,8 @@ def test_SPDHG_vs_PDHG_explicit(self): noisy_data = noise.gaussian(sin, var=0.1, seed=10) else: raise ValueError('Unsupported Noise ', noise) - - #%% 'explicit' SPDHG, scalar step-sizes + + # %% 'explicit' SPDHG, scalar step-sizes subsets = 5 size_of_subsets = int(len(angles)/subsets) # create Gradient operator @@ -1038,13 +1105,13 @@ def test_SPDHG_vs_PDHG_explicit(self): G = IndicatorBox(lower=0) prob = [1/(2*subsets)]*(len(A)-1) + [1/2] - spdhg = SPDHG(f=F,g=G,operator=A, - max_iteration = 300, - update_objective_interval=300, sampler=Sampler.random_with_replacement(len(A), prob=prob, seed=10)) - + spdhg = SPDHG(f=F, g=G, operator=A, + max_iteration=300, + update_objective_interval=300, sampler=Sampler.random_with_replacement(len(A), prob=prob, seed=10)) + spdhg.run(1000, verbose=0) - #%% 'explicit' PDHG, scalar step-sizes + # %% 'explicit' PDHG, scalar step-sizes op1 = GradientOperator(ig) op2 = Aop # Create BlockOperator @@ -1058,13 +1125,13 @@ def test_SPDHG_vs_PDHG_explicit(self): f1 = alpha * MixedL21Norm() f = BlockFunction(f1, f2) # Setup and run the PDHG algorithm - pdhg = PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma) + pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma) pdhg.max_iteration = 300 - pdhg.update_objective_interval =300 - + pdhg.update_objective_interval = 300 + pdhg.run(1000, verbose=0) - - #%% show diff between PDHG and SPDHG + + # %% show diff between PDHG and SPDHG # plt.imshow(spdhg.get_output().as_array() -pdhg.get_output().as_array()) # plt.colorbar() # plt.show() @@ -1079,10 +1146,11 @@ def test_SPDHG_vs_PDHG_explicit(self): np.testing.assert_almost_equal(mse(spdhg.get_output(), pdhg.get_output()), 1.68590e-05, decimal=3) - @unittest.skipUnless(has_astra, "ccpi-astra not available") +""" @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_SPDHG_vs_SPDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16), dtype=numpy.float32) - + data = dataexample.SIMPLE_PHANTOM_2D.get( + size=(16, 16), dtype=numpy.float32) + ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 @@ -1117,8 +1185,8 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): else: raise ValueError('Unsupported Noise ', noise) - - #%% 'explicit' SPDHG, scalar step-sizes + + # %% 'explicit' SPDHG, scalar step-sizes subsets = 5 size_of_subsets = int(len(angles)/subsets) # create GradientOperator operator @@ -1154,21 +1222,19 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] algos = [] - algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 220, - update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=True) - ) - + algos.append(SPDHG(f=F, g=G, operator=A, + max_iteration=220, + update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=True) + ) + algos[0].run(1000, verbose=0) - - algos.append( SPDHG(f=F,g=G,operator=A, - max_iteration = 220, - update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=False) - ) - + + algos.append(SPDHG(f=F, g=G, operator=A, + max_iteration=220, + update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=False) + ) + algos[1].run(1000, verbose=0) - - # np.testing.assert_array_almost_equal(algos[0].get_output().as_array(), algos[1].get_output().as_array()) qm = (mae(algos[0].get_output(), algos[1].get_output()), @@ -1179,10 +1245,9 @@ def test_SPDHG_vs_SPDHG_explicit_axpby(self): assert qm[0] < 0.005 assert qm[1] < 0.001 - @unittest.skipUnless(has_astra, "ccpi-astra not available") def test_PDHG_vs_PDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16,16)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16, 16)) ig = data.geometry ig.voxel_size_x = 0.1 ig.voxel_size_y = 0.1 @@ -1233,21 +1298,21 @@ def test_PDHG_vs_PDHG_explicit_axpby(self): # Setup and run the PDHG algorithm algos = [] - - algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 300, - update_objective_interval=1000, use_axpby=True) - ) - + + algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=300, + update_objective_interval=1000, use_axpby=True) + ) + algos[0].run(1000, verbose=0) - algos.append( PDHG(f=f,g=g,operator=operator, tau=tau, sigma=sigma, - max_iteration = 300, - update_objective_interval=1000, use_axpby=False) - ) - + algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, + max_iteration=300, + update_objective_interval=1000, use_axpby=False) + ) + algos[1].run(1000, verbose=0) - + qm = (mae(algos[0].get_output(), algos[1].get_output()), mse(algos[0].get_output(), algos[1].get_output()), psnr(algos[0].get_output(), algos[1].get_output()) @@ -1255,7 +1320,7 @@ def test_PDHG_vs_PDHG_explicit_axpby(self): logging.info("Quality measures {}".format(qm)) np.testing.assert_array_less(qm[0], 0.005) np.testing.assert_array_less(qm[1], 3e-05) - + """ class PrintAlgo(Algorithm): def __init__(self, **kwargs): From bab0b983eda7936401779e72cd3ed3b4988711d0 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 28 Nov 2023 13:26:46 +0000 Subject: [PATCH 078/115] Edo's comments --- .../cil/optimisation/algorithms/SPDHG.py | 33 +++++++++++++++++-- .../cil/optimisation/utilities/sampler.py | 8 +++-- 2 files changed, 36 insertions(+), 5 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index dbda58f72a..51dc2107f0 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -64,9 +64,38 @@ class SPDHG(Algorithm): Example ------- - Example of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py - + Example + ------- + >>> data = dataexample.SIMPLE_PHANTOM_2D.get(size=(20, 20)) + >>> subsets = 10 + >>> ig = data.geometry + >>> ig.voxel_size_x = 0.1 + >>> ig.voxel_size_y = 0.1 + >>> + >>> detectors = ig.shape[0] + >>> angles = np.linspace(0, np.pi, 90) + >>> ag = AcquisitionGeometry.create_Parallel2D().set_angles( + >>> angles, angle_unit='radian').set_panel(detectors, 0.1) + >>> + >>> Aop = ProjectionOperator(ig, ag, 'cpu') + >>> + >>> sin = Aop.direct(data) + >>> partitioned_data = sin.partition(subsets, 'sequential') + >>> A = BlockOperator( + *[ProjectionOperator(ig. partitioned_data[i].geometry, 'cpu') for i in range(subsets)]) + >>> + >>> F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) + for i in range(subsets)]) + >>> alpha = 0.025 + >>> G = alpha * FGP_TV() + >>> spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.custom_order(len(A), [1,3,0,4,5,8,2,3,8,4,5]), + initial=A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) + >>> spdhg.run(100) + + Example + ------- + Further examples of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py Note ----- diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 20d215e82e..19c56af4c2 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -128,7 +128,7 @@ class SamplerFromOrder(): def __init__(self, num_indices, order, sampling_type, prob_weights=None): """ - A class to select from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + This sampler will sample from a list `order` that is passed. It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. @@ -362,8 +362,10 @@ def get_samples(self, num_samples=20): class Sampler(): r""" - A class to select from a list of indices {0, 1, …, S-1} - The function next() outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. To be run again and again, depending on how many iterations. + This class follows the factory design pattern. It is not instantiated but has 7 static methods that will return instances of 7 different samplers, which require a variety of parameters. The idea of the factory is to simplify the creation of these instances with the static methods. + + Each factory method will instantiate a class to select from a list of indices `{0, 1, …, S-1}` + Common in each instatiated the class, the function `next()` outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. Each class also has a `get_samples(n)` function which will output the first `n` samples. Parameters From 41ff3b5213700d6c9c38106812116e74046baed7 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 30 Nov 2023 14:44:53 +0000 Subject: [PATCH 079/115] New __str__ functions in sampler --- .../optimisation/operators/BlockOperator.py | 4 +-- .../cil/optimisation/utilities/sampler.py | 26 +++++++++++++++++-- 2 files changed, 26 insertions(+), 4 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py index c92b3d54d4..1b13ff541a 100644 --- a/Wrappers/Python/cil/optimisation/operators/BlockOperator.py +++ b/Wrappers/Python/cil/optimisation/operators/BlockOperator.py @@ -327,7 +327,7 @@ def __rmul__(self, scalar): Parameters ------------ - + scalar: number or iterable containing numbers ''' @@ -347,7 +347,7 @@ def __rmul__(self, scalar): @property def T(self): '''Returns the transposed of self. - + Recall the input list is shaped in a row-by-row fashion''' newshape = (self.shape[1], self.shape[0]) oplist = [] diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 19c56af4c2..7bbed4a076 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -123,7 +123,14 @@ def get_samples(self, num_samples=20): self._iteration_number = save_last_index return np.array(output) - + def __str__(self): + repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" + repres += "Type : {} \n".format(self._type) + repres += "Current iteration number : {} \n".format(self._iteration_number) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Probability weights : {} \n".format(self._prob_weights) + return repres + class SamplerFromOrder(): def __init__(self, num_indices, order, sampling_type, prob_weights=None): @@ -249,6 +256,14 @@ def get_samples(self, num_samples=20): self._last_index = save_last_index return np.array(output) + def __str__(self): + repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the number of indices. \n" + repres += "Type : {} \n".format(self._type) + repres += "Order : {} \n".format(self._order) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Current iteration number (modulo the Number of indices) : {} \n".format(self._last_index) + repres += "Probability weights : {} \n".format(self._prob_weights) + return repres class SamplerRandom(): r""" @@ -359,13 +374,20 @@ def get_samples(self, num_samples=20): return np.array(output) + def __str__(self): + repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the number of indices." + repres += "Type : {} \n".format(self._type) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Probability weights : {} \n".format(self._prob_weights) + return repres + class Sampler(): r""" This class follows the factory design pattern. It is not instantiated but has 7 static methods that will return instances of 7 different samplers, which require a variety of parameters. The idea of the factory is to simplify the creation of these instances with the static methods. Each factory method will instantiate a class to select from a list of indices `{0, 1, …, S-1}` - Common in each instatiated the class, the function `next()` outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. Each class also has a `get_samples(n)` function which will output the first `n` samples. + Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. Each class also has a `get_samples(n)` function which will output the first `n` samples. Parameters From aaa720085e346870d65a65c5c838678ec84ad961 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 30 Nov 2023 15:06:55 +0000 Subject: [PATCH 080/115] Documentation changes --- .../cil/optimisation/utilities/sampler.py | 71 +++++-------------- 1 file changed, 18 insertions(+), 53 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 7bbed4a076..714ba35b7d 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -236,19 +236,8 @@ def get_samples(self, num_samples=20): """ Returns the first `num_samples` as a numpy array. - Parameters - ---------- - num_samples: int, default=20 The number of samples to return. - - Example - ------- - - >>> sampler=Sampler.random_with_replacement(5) - >>> print(sampler.get_samples()) - [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] - """ save_last_index = self._last_index self._last_index = len(self._order)-1 @@ -360,12 +349,6 @@ def get_samples(self, num_samples=20): num_samples: int, default=20 The number of samples to return. - Example - ------- - >>> sampler=Sampler.random_with_replacement(5) - >>> print(sampler.get_samples()) - [2 4 2 4 1 3 2 2 1 2 4 4 2 3 2 1 0 4 2 3] - """ save_generator = self._generator self._generator = np.random.RandomState(self._seed) @@ -384,36 +367,14 @@ def __str__(self): class Sampler(): r""" - This class follows the factory design pattern. It is not instantiated but has 7 static methods that will return instances of 7 different samplers, which require a variety of parameters. The idea of the factory is to simplify the creation of these instances with the static methods. + This class follows the factory design pattern. It is not instantiated but has 7 static methods that will return instances of 7 different samplers, which require a variety of parameters. - Each factory method will instantiate a class to select from a list of indices `{0, 1, …, S-1}` - Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1} . Different orders are possible including with and without replacement. Each class also has a `get_samples(n)` function which will output the first `n` samples. - - - Parameters - ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - - sampling_type:str - The sampling type used. Choose from "from_function", "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement", "random_without_replacement" and "from_function". - - order: list of indices - The list of indices the method selects from using next. - - prob: list of floats of length num_indices that sum to 1. - For random sampling with replacement, this is the probability for each index to be called by next. - - seed:int, default=None - Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. - - prob_weights: list of floats of length num_indices that sum to 1. - Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - + Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. + + Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. Example ------- - >>> sampler=Sampler.sequential(10) >>> print(sampler.get_samples(5)) >>> for _ in range(11): @@ -466,7 +427,7 @@ class Sampler(): @staticmethod def sequential(num_indices): """ - Function that outputs a sampler that outputs sequentially. + Instantiates a sampler that outputs sequentially. Parameters ---------- @@ -549,8 +510,10 @@ def custom_order(num_indices, custom_list, prob_weights=None): @staticmethod def herman_meyer(num_indices): """ - Function that takes a number of indices and returns a sampler which outputs a Herman Meyer order - + Instantiates a sampler which outputs in a Herman Meyer order. + + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. @@ -621,8 +584,10 @@ def _herman_meyer_order(n): @staticmethod def staggered(num_indices, offset): """ - Function that takes a number of indices and returns a sampler which outputs in a staggered order. - + Instantiates a sampler which outputs in a staggered order. + + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -669,8 +634,10 @@ def staggered(num_indices, offset): @staticmethod def random_with_replacement(num_indices, prob=None, seed=None): """ - Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices with given probability and with replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, with given probability and with replacement. + Parameters + ---------- num_indices: int The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. @@ -703,7 +670,7 @@ def random_with_replacement(num_indices, prob=None, seed=None): @staticmethod def random_without_replacement(num_indices, seed=None, prob=None): """ - Function that takes a number of indices and returns a sampler which outputs from a list of indices {0, 1, …, S-1} with S=num_indices uniformly randomly without replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, uniformly randomly without replacement. Parameters ---------- @@ -728,9 +695,7 @@ def random_without_replacement(num_indices, seed=None, prob=None): @staticmethod def from_function(num_indices, function, prob_weights=None): """ - A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. - The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. - + Instantiates a sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. Parameters ---------- From b9bb04d598e9f636f0fb59a746a84114f6d246af Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 30 Nov 2023 15:20:32 +0000 Subject: [PATCH 081/115] Documentation changes x2 --- .../cil/optimisation/algorithms/SPDHG.py | 28 +++++++++++-------- 1 file changed, 16 insertions(+), 12 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 51dc2107f0..d0c6804545 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -75,36 +75,36 @@ class SPDHG(Algorithm): >>> >>> detectors = ig.shape[0] >>> angles = np.linspace(0, np.pi, 90) - >>> ag = AcquisitionGeometry.create_Parallel2D().set_angles( - >>> angles, angle_unit='radian').set_panel(detectors, 0.1) + >>> ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles, angle_unit='radian').set_panel(detectors, 0.1) >>> >>> Aop = ProjectionOperator(ig, ag, 'cpu') >>> >>> sin = Aop.direct(data) >>> partitioned_data = sin.partition(subsets, 'sequential') - >>> A = BlockOperator( - *[ProjectionOperator(ig. partitioned_data[i].geometry, 'cpu') for i in range(subsets)]) + >>> A = BlockOperator(*[ProjectionOperator(ig. partitioned_data[i].geometry, 'cpu') for i in range(subsets)]) >>> >>> F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) for i in range(subsets)]) + >>> alpha = 0.025 - >>> G = alpha * FGP_TV() + >>> G = alpha * TotalVariation() >>> spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.custom_order(len(A), [1,3,0,4,5,8,2,3,8,4,5]), initial=A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) >>> spdhg.run(100) Example ------- - Further examples of usage: See https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py + Further examples of usage see the [CIL demos.](https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py) Note ----- When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: + .. math:: + \sigma_i=0.99 / (\|K_i\|**2) - \sigma_i=0.99 / (\|K_i\|**2) and `tau` is set as per case 2 @@ -127,6 +127,7 @@ class SPDHG(Algorithm): Convergence is guaranteed provided that [2, eq. (12)]: .. math:: + \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i References @@ -160,6 +161,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, def set_up(self, f, g, operator, sigma=None, tau=None, initial=None, sampler=None, **deprecated_kwargs): '''set-up of the algorithm + Parameters ---------- f : BlockFunction @@ -325,22 +327,24 @@ def set_step_sizes(self, sigma=None, tau=None): Note ----- - There are 4 possible cases considered by this function: + When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: - .. math:: + + .. math:: \sigma_i=0.99 / (\|K_i\|**2) - and `tau` is set as per case 2 + + and `tau` is set as per case 2 - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula - .. math:: + .. math:: \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula - .. math:: + .. math:: \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - Case 4: Both `sigma` and `tau` are provided. From ef2542525d3b9e77eba45ed4211b12002a9e770a Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 5 Dec 2023 09:58:57 +0000 Subject: [PATCH 082/115] Moved custom order to an example of a function --- .../cil/optimisation/algorithms/SPDHG.py | 6 +- .../cil/optimisation/utilities/sampler.py | 343 ++++++++++-------- Wrappers/Python/test/test_algorithms.py | 8 - Wrappers/Python/test/test_sampler.py | 52 +-- 4 files changed, 198 insertions(+), 211 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index d0c6804545..92bf47a28f 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -88,7 +88,7 @@ class SPDHG(Algorithm): >>> alpha = 0.025 >>> G = alpha * TotalVariation() - >>> spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.custom_order(len(A), [1,3,0,4,5,8,2,3,8,4,5]), + >>> spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.sequential(len(A)), initial=A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) >>> spdhg.run(100) @@ -198,8 +198,8 @@ def set_up(self, f, g, operator, sigma=None, tau=None, if self._sampler is None: self._sampler = Sampler.random_with_replacement(len(operator)) - if self._sampler.num_indices != len(operator): - raise ValueError('The `num_indices` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') + if self._sampler.max_index_number != len(operator): + raise ValueError('The `max_index_number` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') self.norms = operator.get_norms_as_list() diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 714ba35b7d..bac12289e8 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -26,19 +26,20 @@ class SamplerFromFunction(): A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. - It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. + It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(max_index_number, function, prob_weights) from cil.optimisation.utilities.sampler. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=max_index_number. + + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. sampling_type:str - The sampling type used. Choose from "from_function". + The sampling type used. This is set to the default "from_function". - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - - prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices + prob_weights: list of floats of length max_index_number that sum to 1. Default is [1/max_index_number]*max_index_number Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example @@ -51,7 +52,7 @@ class SamplerFromFunction(): >>> np.random.seed(iteration_number) >>> return(np.random.choice(50,1)[0]) >>> - >>> Sampler.from_function(num_indices, function, prob_weights=None) + >>> Sampler.from_function(max_index_number, function, prob_weights=None) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -68,16 +69,56 @@ class SamplerFromFunction(): 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] + + Example + ------- + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] + >>> max_index_number=13 + >>> + >>> def test_function(iteration_number, custom_list=custom_list): + return(custom_list[iteration_number%len(custom_list)]) + >>> + >>> #calculate prob weights + >>> temp_list = [] + >>> for i in range(max_index_number): + >>> temp_list.append(custom_list.count(i)) + >>> total = sum(temp_list) + >>> prob_weights = [x/total for x in temp_list] + >>> + >>> sampler=Sampler.from_function(max_index_number=max_index_number, function=test_function, prob_weights=prob_weights) + >>> for _ in range(11): + >>> print(sampler.next()) + >>> print(list(sampler.get_samples(25))) + >>> print(sampler) + 1 + 1 + 1 + 0 + 0 + 11 + 5 + 9 + 8 + 3 + 1 + [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] + Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. + Type : from_function + Current iteration number : 11 + Max index number : 13 + Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] + + Note ----- - If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise + If your function involves a random number generator, then the seed should also depend on the iteration number, see the first example in the documentation, otherwise the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ - def __init__(self, num_indices, function, sampling_type='from_function', prob_weights=None): + def __init__(self, function, max_index_number, sampling_type='from_function', prob_weights=None): self._type = sampling_type - self._num_indices = num_indices + self._max_index_number = max_index_number self.function = function if abs(sum(prob_weights)-1) > 1e-6: @@ -95,8 +136,8 @@ def prob_weights(self): return self._prob_weights @property - def num_indices(self): - return self._num_indices + def max_index_number(self): + return self._max_index_number def next(self): @@ -124,16 +165,16 @@ def get_samples(self, num_samples=20): return np.array(output) def __str__(self): - repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" + repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. \n" repres += "Type : {} \n".format(self._type) repres += "Current iteration number : {} \n".format(self._iteration_number) - repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Max index number : {} \n".format(self._max_index_number) repres += "Probability weights : {} \n".format(self._prob_weights) return repres class SamplerFromOrder(): - def __init__(self, num_indices, order, sampling_type, prob_weights=None): + def __init__(self, order, max_index_number, sampling_type, prob_weights=None): """ This sampler will sample from a list `order` that is passed. @@ -141,39 +182,21 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - - sampling_type:str - The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", and "staggered" - order: list of indices The list of indices the method selects from using next. + + max_index_number: int + The elements in `order` should be chosen from {0, 1, …, S-1} with S=max_index_number. - prob_weights: list of floats of length num_indices that sum to 1. + sampling_type:str + The sampling type used. Choose from "sequential", "herman_meyer", and "staggered" + + prob_weights: list of floats of length max_index_number that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example ------- - - >>> sampler=Sampler.custom_order(12,[1,4,6,7,8,9,11]) - >>> print(sampler.get_samples(11)) - >>> for _ in range(9): - >>> print(sampler.next()) - >>> print(sampler.get_samples(5)) - - [ 1 4 6 7 8 9 11 1 4 6 7] - 1 - 4 - 6 - 7 - 8 - 9 - 11 - 1 - 4 - [1 4 6 7 8] - + >>> sampler=Sampler.staggered(21,4) >>> print(sampler.get_samples(5)) @@ -199,28 +222,33 @@ def __init__(self, num_indices, order, sampling_type, prob_weights=None): 14 [ 0 4 8 12 16] """ + + + if prob_weights is None: + prob_weights= max_index_number*[1/max_index_number] + if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') if any(np.array(prob_weights) < 0): raise ValueError( 'The provided prob_weights must be greater than or equal to zero') - + + self._prob_weights = prob_weights self._type = sampling_type - self._num_indices = num_indices + self._max_index_number = max_index_number self._order = order self._last_index = len(order)-1 - @property def prob_weights(self): return self._prob_weights @property - def num_indices(self): - return self._num_indices + def max_index_number(self): + return self._max_index_number def next(self): @@ -246,25 +274,25 @@ def get_samples(self, num_samples=20): return np.array(output) def __str__(self): - repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the number of indices. \n" + repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the max index number. \n" repres += "Type : {} \n".format(self._type) repres += "Order : {} \n".format(self._order) - repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Current iteration number (modulo the Number of indices) : {} \n".format(self._last_index) + repres += "Max index number : {} \n".format(self._max_index_number) + repres += "Current iteration number (modulo the max index number) : {} \n".format(self._last_index) repres += "Probability weights : {} \n".format(self._prob_weights) return repres class SamplerRandom(): r""" A class to select from a list of indices {0, 1, …, S-1} using numpy.random.choice with and without replacement. - The function next() outputs a single next index from the list {0,1,…,S-1} . To be run again and again, depending on how many iterations. + The function next() outputs a single next index from the list {0,1,…,S-1} . It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. sampling_type:str The sampling type used. Choose from "random_with_replacement" and "random_without_replacement" @@ -272,13 +300,13 @@ class SamplerRandom(): replace= bool If True, sample with replace, otherwise sample without replacement - prob: list of floats of length num_indices that sum to 1. + prob: list of floats of length max_index_number that sum to 1. For random sampling with replacement, this is the probability for each index to be called by next. seed:int, default=None Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. - prob_weights: list of floats of length num_indices that sum to 1. + prob_weights: list of floats of length max_index_number that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example @@ -296,18 +324,18 @@ class SamplerRandom(): [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] """ - def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): + def __init__(self, max_index_number, replace, sampling_type, prob=None, seed=None): self._replace = replace self._prob = prob if prob is None: - self._prob = [1/num_indices]*num_indices + self._prob = [1/max_index_number]*max_index_number if replace: self._prob_weights = self._prob else: - self._prob_weights = [1/num_indices]*num_indices + self._prob_weights = [1/max_index_number]*max_index_number if abs(sum(self._prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') @@ -317,7 +345,7 @@ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): 'The provided prob_weights must be greater than or equal to zero') self._type = sampling_type - self._num_indices = num_indices + self._max_index_number = max_index_number if seed is not None: self._seed = seed @@ -331,13 +359,13 @@ def prob_weights(self): return self._prob_weights @property - def num_indices(self): - return self._num_indices + def max_index_number(self): + return self._max_index_number def next(self): """ Returns and increments the sampler """ - return int(self._generator.choice(self._num_indices, 1, p=self._prob, replace=self._replace)) + return int(self._generator.choice(self._max_index_number, 1, p=self._prob, replace=self._replace)) def __next__(self): return self.next() @@ -358,18 +386,18 @@ def get_samples(self, num_samples=20): def __str__(self): - repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the number of indices." + repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the max index number." repres += "Type : {} \n".format(self._type) - repres += "Number of indices : {} \n".format(self._num_indices) + repres += "max index number : {} \n".format(self._max_index_number) repres += "Probability weights : {} \n".format(self._prob_weights) return repres class Sampler(): r""" - This class follows the factory design pattern. It is not instantiated but has 7 static methods that will return instances of 7 different samplers, which require a variety of parameters. + This class follows the factory design pattern. It is not instantiated but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. - Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. + Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the max index number.`. Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. @@ -417,22 +445,22 @@ class Sampler(): The optimal choice of sampler depends on the data and the number of calls to the sampler. For random sampling with replacement, there is the possibility, with a small number of calls to the sampler that some indices will not have been selected. For the case of uniform probabilities, the default, the number of - iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `num_indices`. + iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `max_index_number`. For example, to be 99% certain that you have seen all indices, for `n=20` you should take at least 152 samples, `n=50` at least 426 samples. To be more likely than not, for `n=20` you should take 78 samples and `n=50` you should take 228 samples. - In general, we note that for a large number of samples (e.g. `>20*num_indices`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_indices`) the user may wish to consider - another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. + In general, we note that for a large number of samples (e.g. `>20*max_index_number`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*max_index_number`) the user may wish to consider + another sampling method e.g. random without replacement, which, when calling `max_index_number` samples is guaranteed to draw each index exactly once. """ @staticmethod - def sequential(num_indices): + def sequential(max_index_number): """ Instantiates a sampler that outputs sequentially. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. Example ------- @@ -454,68 +482,22 @@ def sequential(num_indices): 9 0 """ - order = list(range(num_indices)) - sampler = SamplerFromOrder(num_indices, sampling_type='sequential', order=order, prob_weights=[ - 1/num_indices]*num_indices) + order = list(range(max_index_number)) + sampler = SamplerFromOrder(max_index_number=max_index_number, sampling_type='sequential', order=order, prob_weights=[ + 1/max_index_number]*max_index_number) return sampler - @staticmethod - def custom_order(num_indices, custom_list, prob_weights=None): - """ - Function that outputs a sampler that outputs from a list, one entry at a time before cycling back to the beginning. - - Parameters - ---------- - num_indices: `int` - The sampler will select indices for `{1,....,n}` according to the order in `custom_list` where `n` is `num_indices`. - custom_list: `list` of `int` - The list that will be sampled from in order. - - prob_weights: list of floats of length num_indices that sum to 1. Default is None and the prob_weights are calculated automatically. - Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - Example - -------- - - >>> sampler=Sampler.custom_order(12,[1,4,6,7,8,9,11]) - >>> print(sampler.get_samples(11)) - >>> for _ in range(9): - >>> print(sampler.next()) - >>> print(sampler.get_samples(5)) - [ 1 4 6 7 8 9 11 1 4 6 7] - 1 - 4 - 6 - 7 - 8 - 9 - 11 - 1 - 4 - [1 4 6 7 8] - - """ - - if prob_weights is None: - temp_list = [] - for i in range(num_indices): - temp_list.append(custom_list.count(i)) - total = sum(temp_list) - prob_weights = [x/total for x in temp_list] - - sampler = SamplerFromOrder( - num_indices, sampling_type='custom_order', order=custom_list, prob_weights=prob_weights) - return sampler + @staticmethod - def herman_meyer(num_indices): + def herman_meyer(max_index_number): """ Instantiates a sampler which outputs in a Herman Meyer order. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. For Herman-Meyer sampling this number should not be prime. Reference ---------- @@ -548,7 +530,7 @@ def _herman_meyer_order(n): if n_factors == 0: raise ValueError( - 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') + 'Herman Meyer sampling defaults to sequential ordering if the max index number is prime. Please use an alternative sampling method or change the max index number. ') order = [0 for _ in range(n)] value = 0 @@ -576,24 +558,24 @@ def _herman_meyer_order(n): math.prod(factors[factor_n+1:]) * mapping return order - order = _herman_meyer_order(num_indices) + order = _herman_meyer_order(max_index_number) sampler = SamplerFromOrder( - num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) + max_index_number=max_index_number, sampling_type='herman_meyer', order=order, prob_weights=[1/max_index_number]*max_index_number) return sampler @staticmethod - def staggered(num_indices, offset): + def staggered(max_index_number, offset): """ Instantiates a sampler which outputs in a staggered order. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. - The offset should be less than the num_indices + The offset should be less than the max_index_number Example ------- @@ -621,27 +603,27 @@ def staggered(num_indices, offset): [ 0 4 8 12 16] """ - if offset >= num_indices: - raise (ValueError('The offset should be less than the number of indices')) + if offset >= max_index_number: + raise (ValueError('The offset should be less than the max index number')) - indices = list(range(num_indices)) + indices = list(range(max_index_number)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = SamplerFromOrder(num_indices, sampling_type='staggered', order=order, prob_weights=[ - 1/num_indices]*num_indices) + sampler = SamplerFromOrder(max_index_number=max_index_number, sampling_type='staggered', order=order, prob_weights=[ + 1/max_index_number]*max_index_number) return sampler @staticmethod - def random_with_replacement(num_indices, prob=None, seed=None): + def random_with_replacement(max_index_number, prob=None, seed=None): """ - Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, with given probability and with replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=max_index_number, with given probability and with replacement. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. - prob: list of floats of length num_indices that sum to 1. default=None + prob: list of floats of length max_index_number that sum to 1. default=None This is the probability for each index to be called by next. If None, then the indices will be sampled uniformly. seed:int, default=None @@ -661,21 +643,21 @@ def random_with_replacement(num_indices, prob=None, seed=None): """ if prob == None: - prob = [1/num_indices] * num_indices + prob = [1/max_index_number] * max_index_number sampler = SamplerRandom( - num_indices, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) + max_index_number=max_index_number, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) return sampler @staticmethod - def random_without_replacement(num_indices, seed=None, prob=None): + def random_without_replacement(max_index_number, seed=None, prob=None): """ - Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, uniformly randomly without replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=max_index_number, uniformly randomly without replacement. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. @@ -689,25 +671,22 @@ def random_without_replacement(num_indices, seed=None, prob=None): """ sampler = SamplerRandom( - num_indices, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob) + max_index_number=max_index_number, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob) return sampler @staticmethod - def from_function(num_indices, function, prob_weights=None): + def from_function(max_index_number, function, prob_weights=None): """ Instantiates a sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. Parameters ---------- - num_indices: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - - sampling_type:str - The sampling type used. Choose from "sequential", "custom_order", "herman_meyer", "staggered", "random_with_replacement" and "random_without_replacement". + max_index_number: int + The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=max_index_number. - prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices + prob_weights: list of floats of length max_index_number that sum to 1. Default is [1/max_index_number]*max_index_number Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. @@ -743,11 +722,55 @@ def from_function(num_indices, function, prob_weights=None): 28 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] - + + Example + ------- + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] + >>> max_index_number=13 + >>> + >>> def test_function(iteration_number, custom_list=custom_list): + return(custom_list[iteration_number%len(custom_list)]) + >>> + >>> #calculate prob weights + >>> temp_list = [] + >>> for i in range(max_index_number): + >>> temp_list.append(custom_list.count(i)) + >>> total = sum(temp_list) + >>> prob_weights = [x/total for x in temp_list] + >>> + >>> sampler=Sampler.from_function(max_index_number=max_index_number, function=test_function, prob_weights=prob_weights) + >>> for _ in range(11): + >>> print(sampler.next()) + >>> print(list(sampler.get_samples(25))) + >>> print(sampler) + 1 + 1 + 1 + 0 + 0 + 11 + 5 + 9 + 8 + 3 + 1 + [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] + Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. + Type : from_function + Current iteration number : 11 + Max index number : 13 + Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] + + + Note + ----- + If your function involves a random number generator, then the seed should also depend on the iteration number, see the first example in the documentation, otherwise + the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ + if prob_weights is None: - prob_weights = [1/num_indices]*num_indices + prob_weights = [1/max_index_number]*max_index_number sampler = SamplerFromFunction( - num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) + max_index_number=max_index_number, sampling_type='from_function', function=function, prob_weights=prob_weights) return sampler diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 8b72a4084a..32a658bead 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -859,14 +859,6 @@ def test_spdhg_deprecated_vargs(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sfdsdf=3, norms=[ 1]*len(self.A), sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) - def test_spdhg_custom_sampler(self): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A), [0, 0, 0, 0]), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) - self.assertListEqual(spdhg.prob_weights, [1]+[0]*(len(self.A)-1)) - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.custom_order(len(self.A), [0, 1, 0, 1]), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) - self.assertListEqual(spdhg.prob_weights, - [.5]+[.5]+[0]*(len(self.A)-2)) def test_spdhg_set_norms(self): diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index d7723de957..84eb912688 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -42,27 +42,27 @@ def example_function(self, iteration_number): def test_init(self): sampler = Sampler.sequential(10) - self.assertEqual(sampler.num_indices, 10) + self.assertEqual(sampler.max_index_number, 10) self.assertEqual(sampler._type, 'sequential') self.assertListEqual(sampler._order, list(range(10))) self.assertEqual(sampler._last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) sampler = Sampler.random_without_replacement(7) - self.assertEqual(sampler.num_indices, 7) + self.assertEqual(sampler.max_index_number, 7) self.assertEqual(sampler._type, 'random_without_replacement') self.assertEqual(sampler._prob, [1/7]*7) self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.random_without_replacement(8, seed=1) - self.assertEqual(sampler.num_indices, 8) + self.assertEqual(sampler.max_index_number, 8) self.assertEqual(sampler._type, 'random_without_replacement') self.assertEqual(sampler._prob, [1/8]*8) self.assertEqual(sampler._seed, 1) self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.herman_meyer(12) - self.assertEqual(sampler.num_indices, 12) + self.assertEqual(sampler.max_index_number, 12) self.assertEqual(sampler._type, 'herman_meyer') self.assertEqual(sampler._last_index, 11) self.assertListEqual( @@ -70,19 +70,19 @@ def test_init(self): self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.random_with_replacement(5) - self.assertEqual(sampler.num_indices, 5) + self.assertEqual(sampler.max_index_number, 5) self.assertEqual(sampler._type, 'random_with_replacement') self.assertListEqual(sampler._prob, [1/5] * 5) self.assertListEqual(sampler.prob_weights, [1/5] * 5) sampler = Sampler.random_with_replacement(4, [0.7, 0.1, 0.1, 0.1]) - self.assertEqual(sampler.num_indices, 4) + self.assertEqual(sampler.max_index_number, 4) self.assertEqual(sampler._type, 'random_with_replacement') self.assertListEqual(sampler._prob, [0.7, 0.1, 0.1, 0.1]) self.assertListEqual(sampler.prob_weights, [0.7, 0.1, 0.1, 0.1]) sampler = Sampler.staggered(21, 4) - self.assertEqual(sampler.num_indices, 21) + self.assertEqual(sampler.max_index_number, 21) self.assertEqual(sampler._type, 'staggered') self.assertListEqual(sampler._order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) @@ -92,41 +92,22 @@ def test_init(self): with self.assertRaises(ValueError): Sampler.staggered(22, 25) - - sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler.num_indices, 12) - self.assertEqual(sampler._type, 'custom_order') - self.assertListEqual(sampler._order, [1, 4, 6, 7, 8, 9, 11]) - self.assertEqual(sampler._last_index, 6) - self.assertListEqual(sampler.prob_weights, [ - 0, 1/7, 0, 0, 1/7, 0, 1/7, 1/7, 1/7, 1/7, 0, 1/7]) - - sampler = Sampler.custom_order(10, [0,1, 2, 3, 4]) - self.assertEqual(sampler.num_indices, 10) - self.assertEqual(sampler._type, 'custom_order') - self.assertListEqual(sampler._order, [0,1,2,3,4]) - self.assertEqual(sampler._last_index, 4) - self.assertListEqual(sampler.prob_weights, [ - 1/5,1/5,1/5,1/5,1/5,0,0,0,0,0]) - - sampler = Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[1/10]*10) - self.assertListEqual(sampler.prob_weights, [1/10]*10) #Check probabilities sum to one and are positive with self.assertRaises(ValueError): - Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[1/11]*10) + Sampler.from_function(10, self.example_function, prob_weights=[1/11]*10) with self.assertRaises(ValueError): - Sampler.custom_order(10, [0,1, 2, 3, 4], prob_weights=[-1]+[2]+[0]*8) + Sampler.from_function(10, self.example_function, prob_weights=[-1]+[2]+[0]*8) sampler = Sampler.from_function(50, self.example_function) self.assertListEqual(sampler.prob_weights, [1/50] * 50) - self.assertEqual(sampler.num_indices, 50) + self.assertEqual(sampler.max_index_number, 50) self.assertEqual(sampler._type, 'from_function') sampler = Sampler.from_function(40, self.example_function, [1]+[0]*39) self.assertListEqual(sampler.prob_weights, [1]+[0]*39) - self.assertEqual(sampler.num_indices, 40) + self.assertEqual(sampler.max_index_number, 40) self.assertEqual(sampler._type, 'from_function') #check probabilities sum to 1 and are positive @@ -217,13 +198,4 @@ def test_staggered_iterator_and_get_samples(self): self.assertNumpyArrayEqual( sampler.get_samples(10), np.array(order[:10])) - def test_custom_order_iterator_and_get_samples(self): - # Test the custom order sampler - sampler = Sampler.custom_order(12, [1, 4, 6, 7, 8, 9, 11]) - order = [1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, - 11, 1, 4, 6, 7, 8, 9, 11, 1, 4, 6, 7, 8, 9, 11] - for i in range(25): - self.assertEqual(sampler.next(), order[i % 7]) - if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual( - sampler.get_samples(10), np.array(order[:10])) + From 0948e39943f9b2f381ea9fecc9609f6583ef60e9 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 5 Dec 2023 15:52:33 +0000 Subject: [PATCH 083/115] Back to num_indices and more explanation for custom function examples --- .../cil/optimisation/algorithms/SPDHG.py | 4 +- .../cil/optimisation/utilities/sampler.py | 203 +++++++++--------- Wrappers/Python/test/test_sampler.py | 18 +- 3 files changed, 115 insertions(+), 110 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 92bf47a28f..8ddd2ec0e6 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -198,8 +198,8 @@ def set_up(self, f, g, operator, sigma=None, tau=None, if self._sampler is None: self._sampler = Sampler.random_with_replacement(len(operator)) - if self._sampler.max_index_number != len(operator): - raise ValueError('The `max_index_number` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') + if self._sampler.num_indices != len(operator): + raise ValueError('The `num_indices` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') self.norms = operator.get_norms_as_list() diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index bac12289e8..24651388e8 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -26,24 +26,26 @@ class SamplerFromFunction(): A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. - It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(max_index_number, function, prob_weights) from cil.optimisation.utilities.sampler. + It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. Parameters ---------- - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=max_index_number. + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str The sampling type used. This is set to the default "from_function". - prob_weights: list of floats of length max_index_number that sum to 1. Default is [1/max_index_number]*max_index_number + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example ------- + This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. + For the next 500 iterations it uniformly randomly with replacement samples from {0,...,49}. The num_indices is 50 and the prob_weights are left as default because in the limit all indices will be seen with equal probability. >>> def test_function(iteration_number): >>> if iteration_number<500: >>> np.random.seed(iteration_number) @@ -52,7 +54,7 @@ class SamplerFromFunction(): >>> np.random.seed(iteration_number) >>> return(np.random.choice(50,1)[0]) >>> - >>> Sampler.from_function(max_index_number, function, prob_weights=None) + >>> Sampler.from_function(num_indices, function, prob_weights=None) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -72,20 +74,23 @@ class SamplerFromFunction(): Example ------- + This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. + The probability weights are calculated and passed to the sampler as they are not uniform. + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] - >>> max_index_number=13 + >>> num_indices=13 >>> >>> def test_function(iteration_number, custom_list=custom_list): return(custom_list[iteration_number%len(custom_list)]) >>> >>> #calculate prob weights >>> temp_list = [] - >>> for i in range(max_index_number): + >>> for i in range(num_indices): >>> temp_list.append(custom_list.count(i)) >>> total = sum(temp_list) >>> prob_weights = [x/total for x in temp_list] >>> - >>> sampler=Sampler.from_function(max_index_number=max_index_number, function=test_function, prob_weights=prob_weights) + >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -102,10 +107,10 @@ class SamplerFromFunction(): 3 1 [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] - Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. + Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. Type : from_function Current iteration number : 11 - Max index number : 13 + number of indices : 13 Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] @@ -115,10 +120,10 @@ class SamplerFromFunction(): the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ - def __init__(self, function, max_index_number, sampling_type='from_function', prob_weights=None): + def __init__(self, function, num_indices, sampling_type='from_function', prob_weights=None): self._type = sampling_type - self._max_index_number = max_index_number + self._num_indices = num_indices self.function = function if abs(sum(prob_weights)-1) > 1e-6: @@ -136,8 +141,8 @@ def prob_weights(self): return self._prob_weights @property - def max_index_number(self): - return self._max_index_number + def num_indices(self): + return self._num_indices def next(self): @@ -165,16 +170,16 @@ def get_samples(self, num_samples=20): return np.array(output) def __str__(self): - repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. \n" + repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" repres += "Type : {} \n".format(self._type) repres += "Current iteration number : {} \n".format(self._iteration_number) - repres += "Max index number : {} \n".format(self._max_index_number) + repres += "Number of indices : {} \n".format(self._num_indices) repres += "Probability weights : {} \n".format(self._prob_weights) return repres class SamplerFromOrder(): - def __init__(self, order, max_index_number, sampling_type, prob_weights=None): + def __init__(self, order, num_indices, sampling_type, prob_weights=None): """ This sampler will sample from a list `order` that is passed. @@ -185,13 +190,13 @@ def __init__(self, order, max_index_number, sampling_type, prob_weights=None): order: list of indices The list of indices the method selects from using next. - max_index_number: int - The elements in `order` should be chosen from {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The elements in `order` should be chosen from {0, 1, …, S-1} with S=num_indices. sampling_type:str The sampling type used. Choose from "sequential", "herman_meyer", and "staggered" - prob_weights: list of floats of length max_index_number that sum to 1. + prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example @@ -225,7 +230,7 @@ def __init__(self, order, max_index_number, sampling_type, prob_weights=None): if prob_weights is None: - prob_weights= max_index_number*[1/max_index_number] + prob_weights= num_indices*[1/num_indices] if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') @@ -237,7 +242,7 @@ def __init__(self, order, max_index_number, sampling_type, prob_weights=None): self._prob_weights = prob_weights self._type = sampling_type - self._max_index_number = max_index_number + self._num_indices = num_indices self._order = order self._last_index = len(order)-1 @@ -247,8 +252,8 @@ def prob_weights(self): return self._prob_weights @property - def max_index_number(self): - return self._max_index_number + def num_indices(self): + return self._num_indices def next(self): @@ -274,11 +279,11 @@ def get_samples(self, num_samples=20): return np.array(output) def __str__(self): - repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the max index number. \n" + repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the number of indices. \n" repres += "Type : {} \n".format(self._type) repres += "Order : {} \n".format(self._order) - repres += "Max index number : {} \n".format(self._max_index_number) - repres += "Current iteration number (modulo the max index number) : {} \n".format(self._last_index) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Current iteration number (modulo the number of indices) : {} \n".format(self._last_index) repres += "Probability weights : {} \n".format(self._prob_weights) return repres @@ -291,8 +296,8 @@ class SamplerRandom(): Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. sampling_type:str The sampling type used. Choose from "random_with_replacement" and "random_without_replacement" @@ -300,13 +305,13 @@ class SamplerRandom(): replace= bool If True, sample with replace, otherwise sample without replacement - prob: list of floats of length max_index_number that sum to 1. + prob: list of floats of length num_indices that sum to 1. For random sampling with replacement, this is the probability for each index to be called by next. seed:int, default=None Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. - prob_weights: list of floats of length max_index_number that sum to 1. + prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Example @@ -324,18 +329,18 @@ class SamplerRandom(): [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] """ - def __init__(self, max_index_number, replace, sampling_type, prob=None, seed=None): + def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): self._replace = replace self._prob = prob if prob is None: - self._prob = [1/max_index_number]*max_index_number + self._prob = [1/num_indices]*num_indices if replace: self._prob_weights = self._prob else: - self._prob_weights = [1/max_index_number]*max_index_number + self._prob_weights = [1/num_indices]*num_indices if abs(sum(self._prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') @@ -345,7 +350,7 @@ def __init__(self, max_index_number, replace, sampling_type, prob=None, seed=N 'The provided prob_weights must be greater than or equal to zero') self._type = sampling_type - self._max_index_number = max_index_number + self._num_indices = num_indices if seed is not None: self._seed = seed @@ -359,13 +364,13 @@ def prob_weights(self): return self._prob_weights @property - def max_index_number(self): - return self._max_index_number + def num_indices(self): + return self._num_indices def next(self): """ Returns and increments the sampler """ - return int(self._generator.choice(self._max_index_number, 1, p=self._prob, replace=self._replace)) + return int(self._generator.choice(self._num_indices, 1, p=self._prob, replace=self._replace)) def __next__(self): return self.next() @@ -386,9 +391,9 @@ def get_samples(self, num_samples=20): def __str__(self): - repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the max index number." + repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the number of indices." repres += "Type : {} \n".format(self._type) - repres += "max index number : {} \n".format(self._max_index_number) + repres += "Number of indices : {} \n".format(self._num_indices) repres += "Probability weights : {} \n".format(self._prob_weights) return repres @@ -397,7 +402,7 @@ class Sampler(): r""" This class follows the factory design pattern. It is not instantiated but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. - Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the max index number.`. + Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. @@ -445,22 +450,22 @@ class Sampler(): The optimal choice of sampler depends on the data and the number of calls to the sampler. For random sampling with replacement, there is the possibility, with a small number of calls to the sampler that some indices will not have been selected. For the case of uniform probabilities, the default, the number of - iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `max_index_number`. + iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `num_indices`. For example, to be 99% certain that you have seen all indices, for `n=20` you should take at least 152 samples, `n=50` at least 426 samples. To be more likely than not, for `n=20` you should take 78 samples and `n=50` you should take 228 samples. - In general, we note that for a large number of samples (e.g. `>20*max_index_number`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*max_index_number`) the user may wish to consider - another sampling method e.g. random without replacement, which, when calling `max_index_number` samples is guaranteed to draw each index exactly once. + In general, we note that for a large number of samples (e.g. `>20*num_indices`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_indices`) the user may wish to consider + another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. """ @staticmethod - def sequential(max_index_number): + def sequential(num_indices): """ Instantiates a sampler that outputs sequentially. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. Example ------- @@ -482,22 +487,22 @@ def sequential(max_index_number): 9 0 """ - order = list(range(max_index_number)) - sampler = SamplerFromOrder(max_index_number=max_index_number, sampling_type='sequential', order=order, prob_weights=[ - 1/max_index_number]*max_index_number) + order = list(range(num_indices)) + sampler = SamplerFromOrder(num_indices=num_indices, sampling_type='sequential', order=order, prob_weights=[ + 1/num_indices]*num_indices) return sampler @staticmethod - def herman_meyer(max_index_number): + def herman_meyer(num_indices): """ Instantiates a sampler which outputs in a Herman Meyer order. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. For Herman-Meyer sampling this number should not be prime. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. Reference ---------- @@ -530,7 +535,7 @@ def _herman_meyer_order(n): if n_factors == 0: raise ValueError( - 'Herman Meyer sampling defaults to sequential ordering if the max index number is prime. Please use an alternative sampling method or change the max index number. ') + 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') order = [0 for _ in range(n)] value = 0 @@ -558,24 +563,24 @@ def _herman_meyer_order(n): math.prod(factors[factor_n+1:]) * mapping return order - order = _herman_meyer_order(max_index_number) + order = _herman_meyer_order(num_indices) sampler = SamplerFromOrder( - max_index_number=max_index_number, sampling_type='herman_meyer', order=order, prob_weights=[1/max_index_number]*max_index_number) + num_indices=num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @staticmethod - def staggered(max_index_number, offset): + def staggered(num_indices, offset): """ Instantiates a sampler which outputs in a staggered order. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. - The offset should be less than the max_index_number + The offset should be less than the num_indices Example ------- @@ -603,27 +608,27 @@ def staggered(max_index_number, offset): [ 0 4 8 12 16] """ - if offset >= max_index_number: - raise (ValueError('The offset should be less than the max index number')) + if offset >= num_indices: + raise (ValueError('The offset should be less than the number of indices')) - indices = list(range(max_index_number)) + indices = list(range(num_indices)) order = [] [order.extend(indices[i::offset]) for i in range(offset)] - sampler = SamplerFromOrder(max_index_number=max_index_number, sampling_type='staggered', order=order, prob_weights=[ - 1/max_index_number]*max_index_number) + sampler = SamplerFromOrder(num_indices=num_indices, sampling_type='staggered', order=order, prob_weights=[ + 1/num_indices]*num_indices) return sampler @staticmethod - def random_with_replacement(max_index_number, prob=None, seed=None): + def random_with_replacement(num_indices, prob=None, seed=None): """ - Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=max_index_number, with given probability and with replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, with given probability and with replacement. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - prob: list of floats of length max_index_number that sum to 1. default=None + prob: list of floats of length num_indices that sum to 1. default=None This is the probability for each index to be called by next. If None, then the indices will be sampled uniformly. seed:int, default=None @@ -643,21 +648,21 @@ def random_with_replacement(max_index_number, prob=None, seed=None): """ if prob == None: - prob = [1/max_index_number] * max_index_number + prob = [1/num_indices] * num_indices sampler = SamplerRandom( - max_index_number=max_index_number, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) + num_indices=num_indices, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) return sampler @staticmethod - def random_without_replacement(max_index_number, seed=None, prob=None): + def random_without_replacement(num_indices, seed=None, prob=None): """ - Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=max_index_number, uniformly randomly without replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, uniformly randomly without replacement. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. @@ -671,22 +676,22 @@ def random_without_replacement(max_index_number, seed=None, prob=None): """ sampler = SamplerRandom( - max_index_number=max_index_number, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob) + num_indices=num_indices, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob) return sampler @staticmethod - def from_function(max_index_number, function, prob_weights=None): + def from_function(num_indices, function, prob_weights=None): """ Instantiates a sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. Parameters ---------- - max_index_number: int - The sampler will select from a list of indices {0, 1, …, S-1} with S=max_index_number. + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=max_index_number. + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - prob_weights: list of floats of length max_index_number that sum to 1. Default is [1/max_index_number]*max_index_number + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. @@ -697,6 +702,8 @@ def from_function(max_index_number, function, prob_weights=None): Example ------- + This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. + For the next 500 iterations it uniformly randomly with replacement samples from {0,...,49}. The num_indices is 50 and the prob_weights are left as default because in the limit all indices will be seen with equal probability. >>> def test_function(iteration_number): >>> if iteration_number<500: >>> np.random.seed(iteration_number) @@ -704,9 +711,8 @@ def from_function(max_index_number, function, prob_weights=None): >>> else: >>> np.random.seed(iteration_number) >>> return(np.random.choice(50,1)[0]) - - - >>> sampler=Sampler.from_function(50, test_function) + >>> + >>> Sampler.from_function(num_indices, function, prob_weights=None) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -722,23 +728,27 @@ def from_function(max_index_number, function, prob_weights=None): 28 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] - + + Example ------- + This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. + The probability weights are calculated and passed to the sampler as they are not uniform. + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] - >>> max_index_number=13 + >>> num_indices=13 >>> >>> def test_function(iteration_number, custom_list=custom_list): return(custom_list[iteration_number%len(custom_list)]) >>> >>> #calculate prob weights >>> temp_list = [] - >>> for i in range(max_index_number): + >>> for i in range(num_indices): >>> temp_list.append(custom_list.count(i)) >>> total = sum(temp_list) >>> prob_weights = [x/total for x in temp_list] >>> - >>> sampler=Sampler.from_function(max_index_number=max_index_number, function=test_function, prob_weights=prob_weights) + >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) >>> for _ in range(11): >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) @@ -755,22 +765,17 @@ def from_function(max_index_number, function, prob_weights=None): 3 1 [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] - Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the max index number. + Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. Type : from_function Current iteration number : 11 - Max index number : 13 + number of indices : 13 Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] - - Note - ----- - If your function involves a random number generator, then the seed should also depend on the iteration number, see the first example in the documentation, otherwise - the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ if prob_weights is None: - prob_weights = [1/max_index_number]*max_index_number + prob_weights = [1/num_indices]*num_indices sampler = SamplerFromFunction( - max_index_number=max_index_number, sampling_type='from_function', function=function, prob_weights=prob_weights) + num_indices=num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) return sampler diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 84eb912688..0c16f7420e 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -42,27 +42,27 @@ def example_function(self, iteration_number): def test_init(self): sampler = Sampler.sequential(10) - self.assertEqual(sampler.max_index_number, 10) + self.assertEqual(sampler.num_indices, 10) self.assertEqual(sampler._type, 'sequential') self.assertListEqual(sampler._order, list(range(10))) self.assertEqual(sampler._last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) sampler = Sampler.random_without_replacement(7) - self.assertEqual(sampler.max_index_number, 7) + self.assertEqual(sampler.num_indices, 7) self.assertEqual(sampler._type, 'random_without_replacement') self.assertEqual(sampler._prob, [1/7]*7) self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.random_without_replacement(8, seed=1) - self.assertEqual(sampler.max_index_number, 8) + self.assertEqual(sampler.num_indices, 8) self.assertEqual(sampler._type, 'random_without_replacement') self.assertEqual(sampler._prob, [1/8]*8) self.assertEqual(sampler._seed, 1) self.assertListEqual(sampler.prob_weights, sampler._prob) sampler = Sampler.herman_meyer(12) - self.assertEqual(sampler.max_index_number, 12) + self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler._type, 'herman_meyer') self.assertEqual(sampler._last_index, 11) self.assertListEqual( @@ -70,19 +70,19 @@ def test_init(self): self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.random_with_replacement(5) - self.assertEqual(sampler.max_index_number, 5) + self.assertEqual(sampler.num_indices, 5) self.assertEqual(sampler._type, 'random_with_replacement') self.assertListEqual(sampler._prob, [1/5] * 5) self.assertListEqual(sampler.prob_weights, [1/5] * 5) sampler = Sampler.random_with_replacement(4, [0.7, 0.1, 0.1, 0.1]) - self.assertEqual(sampler.max_index_number, 4) + self.assertEqual(sampler.num_indices, 4) self.assertEqual(sampler._type, 'random_with_replacement') self.assertListEqual(sampler._prob, [0.7, 0.1, 0.1, 0.1]) self.assertListEqual(sampler.prob_weights, [0.7, 0.1, 0.1, 0.1]) sampler = Sampler.staggered(21, 4) - self.assertEqual(sampler.max_index_number, 21) + self.assertEqual(sampler.num_indices, 21) self.assertEqual(sampler._type, 'staggered') self.assertListEqual(sampler._order, [ 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) @@ -102,12 +102,12 @@ def test_init(self): sampler = Sampler.from_function(50, self.example_function) self.assertListEqual(sampler.prob_weights, [1/50] * 50) - self.assertEqual(sampler.max_index_number, 50) + self.assertEqual(sampler.num_indices, 50) self.assertEqual(sampler._type, 'from_function') sampler = Sampler.from_function(40, self.example_function, [1]+[0]*39) self.assertListEqual(sampler.prob_weights, [1]+[0]*39) - self.assertEqual(sampler.max_index_number, 40) + self.assertEqual(sampler.num_indices, 40) self.assertEqual(sampler._type, 'from_function') #check probabilities sum to 1 and are positive From 5804f7d91f33c2b51747e9d93c3367a25ab01f75 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 7 Dec 2023 17:08:42 +0000 Subject: [PATCH 084/115] Updates from chat with Gemma --- .../cil/optimisation/utilities/sampler.py | 279 ++++++------------ 1 file changed, 88 insertions(+), 191 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 24651388e8..60eb994e4c 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -42,6 +42,10 @@ class SamplerFromFunction(): prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + Returns + ------- + A Sampler wrapping a function that can be called with Sampler.next() or next(Sampler) + Example ------- This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. @@ -55,20 +59,7 @@ class SamplerFromFunction(): >>> return(np.random.choice(50,1)[0]) >>> >>> Sampler.from_function(num_indices, function, prob_weights=None) - >>> for _ in range(11): - >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) - 44 - 37 - 40 - 42 - 46 - 35 - 10 - 47 - 3 - 28 - 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] @@ -91,22 +82,9 @@ class SamplerFromFunction(): >>> prob_weights = [x/total for x in temp_list] >>> >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) - >>> for _ in range(11): - >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) - >>> print(sampler) - 1 - 1 - 1 - 0 - 0 - 11 - 5 - 9 - 8 - 3 - 1 [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] + >>> print(sampler) Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. Type : from_function Current iteration number : 11 @@ -144,6 +122,12 @@ def prob_weights(self): def num_indices(self): return self._num_indices + @property + def current_iter_number(self): + return self._iteration_number + + + def next(self): """ @@ -198,33 +182,15 @@ def __init__(self, order, num_indices, sampling_type, prob_weights=None): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - Example + + Returns ------- - + A Sampler outputting in order from an list that can be called with Sampler.next() or next(Sampler) + Example + ------- >>> sampler=Sampler.staggered(21,4) >>> print(sampler.get_samples(5)) - >>> for _ in range(15): - >>> print(sampler.next()) - >>> print(sampler.get_samples(5)) - - [ 0 4 8 12 16] - 0 - 4 - 8 - 12 - 16 - 20 - 1 - 5 - 9 - 13 - 17 - 2 - 6 - 10 - 14 [ 0 4 8 12 16] """ @@ -255,6 +221,11 @@ def prob_weights(self): def num_indices(self): return self._num_indices + @property + def current_index_number(self): + return self._iteration_number + + def next(self): """Returns and increments the sampler """ @@ -283,7 +254,7 @@ def __str__(self): repres += "Type : {} \n".format(self._type) repres += "Order : {} \n".format(self._order) repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Current iteration number (modulo the number of indices) : {} \n".format(self._last_index) + repres += "Current index number : {} \n".format(self._last_index) repres += "Probability weights : {} \n".format(self._prob_weights) return repres @@ -314,6 +285,11 @@ class SamplerRandom(): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + Returns + ------- + A Sampler wrapping numpy.random.choice that can be called with Sampler.next() or next(Sampler) + Example ------- >>> sampler=Sampler.random_with_replacement(5) @@ -410,39 +386,13 @@ class Sampler(): ------- >>> sampler=Sampler.sequential(10) >>> print(sampler.get_samples(5)) - >>> for _ in range(11): - print(sampler.next()) [0 1 2 3 4] - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 0 + Example ------- >>> sampler=Sampler.random_with_replacement(5) - >>> for _ in range(12): - >>> print(next(sampler)) >>> print(sampler.get_samples()) - 3 - 4 - 0 - 0 - 2 - 3 - 3 - 2 - 2 - 1 - 1 - 4 [3 4 0 0 2 3 3 2 2 1 1 4 4 3 0 2 4 4 2 4] Note @@ -466,26 +416,16 @@ def sequential(num_indices): ---------- num_indices: int One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) and outputs sequentially + Example ------- >>> sampler=Sampler.sequential(10) >>> print(sampler.get_samples(5)) - >>> for _ in range(11): - print(sampler.next()) [0 1 2 3 4] - 0 - 1 - 2 - 3 - 4 - 5 - 6 - 7 - 8 - 9 - 0 """ order = list(range(num_indices)) sampler = SamplerFromOrder(num_indices=num_indices, sampling_type='sequential', order=order, prob_weights=[ @@ -507,63 +447,52 @@ def herman_meyer(num_indices): Reference ---------- Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. - + + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a Herman Meyer ordering + Example ------- >>> sampler=Sampler.herman_meyer(12) >>> print(sampler.get_samples(16)) [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] - """ - def _herman_meyer_order(n): - # Assuming that the indices are in geometrical order - n_variable = n - i = 2 - factors = [] - while i * i <= n_variable: - if n_variable % i: - i += 1 - else: - n_variable //= i - factors.append(i) - - if n_variable > 1: - factors.append(n_variable) - - n_factors = len(factors) - - if n_factors == 0: - raise ValueError( - 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') - - order = [0 for _ in range(n)] - value = 0 - - for factor_n in range(n_factors): - n_rep_value = 0 - - if factor_n == 0: - n_change_value = 1 - else: - n_change_value = math.prod(factors[:factor_n]) - - for element in range(n): - mapping = value - n_rep_value += 1 - - if n_rep_value >= n_change_value: - value = value + 1 - n_rep_value = 0 - - if value == factors[factor_n]: - value = 0 + + n_variable = num_indices + i = 2 + factors = [] + + #Prime factorisation + while i * i <= n_variable: + if n_variable % i: + i += 1 + else: + n_variable //= i + factors.append(i) + if n_variable > 1: + factors.append(n_variable) + + n_factors = len(factors) + + if n_factors == 1: + raise ValueError( + 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') + + #Build the sampling order + order = np.zeros(num_indices, dtype=np.int8) + for factor_n in range(n_factors): + if factor_n == 0: + block_length= 1 + else: + block_length= math.prod(factors[:factor_n]) + + addition=np.tile(np.repeat( math.prod(factors[factor_n+1:])*range(num_indices//(addition*block_length)), block_length), addition) + order += addition + order=list(order) - order[element] = order[element] + \ - math.prod(factors[factor_n+1:]) * mapping - return order - order = _herman_meyer_order(num_indices) sampler = SamplerFromOrder( num_indices=num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) return sampler @@ -581,30 +510,15 @@ def staggered(num_indices, offset): offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. The offset should be less than the num_indices - + + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a staggered ordering + Example ------- >>> sampler=Sampler.staggered(21,4) >>> print(sampler.get_samples(5)) - >>> for _ in range(15): - >>> print(sampler.next()) - >>> print(sampler.get_samples(5)) - [ 0 4 8 12 16] - 0 - 4 - 8 - 12 - 16 - 20 - 1 - 5 - 9 - 13 - 17 - 2 - 6 - 10 - 14 [ 0 4 8 12 16] """ @@ -633,7 +547,11 @@ def random_with_replacement(num_indices, prob=None, seed=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) that samples randomly with replacement + Example ------- @@ -666,7 +584,10 @@ def random_without_replacement(num_indices, seed=None, prob=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) that samples randomly without replacement Example ------- >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) @@ -699,8 +620,10 @@ def from_function(num_indices, function, prob_weights=None): ----- If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. - - Example + + Returns + ------- + A Sampler that wraps a function and can be called with Sampler.next() or next(Sampler) ------- This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. For the next 500 iterations it uniformly randomly with replacement samples from {0,...,49}. The num_indices is 50 and the prob_weights are left as default because in the limit all indices will be seen with equal probability. @@ -713,20 +636,7 @@ def from_function(num_indices, function, prob_weights=None): >>> return(np.random.choice(50,1)[0]) >>> >>> Sampler.from_function(num_indices, function, prob_weights=None) - >>> for _ in range(11): - >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) - 44 - 37 - 40 - 42 - 46 - 35 - 10 - 47 - 3 - 28 - 9 [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] @@ -749,22 +659,9 @@ def from_function(num_indices, function, prob_weights=None): >>> prob_weights = [x/total for x in temp_list] >>> >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) - >>> for _ in range(11): - >>> print(sampler.next()) >>> print(list(sampler.get_samples(25))) - >>> print(sampler) - 1 - 1 - 1 - 0 - 0 - 11 - 5 - 9 - 8 - 3 - 1 [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] + >>> print(sampler) Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. Type : from_function Current iteration number : 11 From fca94f487d59580ee09eca320aaabce753672a29 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 7 Dec 2023 17:20:17 +0000 Subject: [PATCH 085/115] Updates from chat with Gemma --- .../cil/optimisation/utilities/sampler.py | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 60eb994e4c..52aa565e3a 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -470,29 +470,28 @@ def herman_meyer(num_indices): i += 1 else: n_variable //= i - factors.append(i) + factors.append(i) if n_variable > 1: factors.append(n_variable) n_factors = len(factors) - if n_factors == 1: raise ValueError( 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') - #Build the sampling order + #Build up the sampling order iteratively using the prime factors order = np.zeros(num_indices, dtype=np.int8) for factor_n in range(n_factors): if factor_n == 0: - block_length= 1 + repeat_length= 1 else: - block_length= math.prod(factors[:factor_n]) - - addition=np.tile(np.repeat( math.prod(factors[factor_n+1:])*range(num_indices//(addition*block_length)), block_length), addition) - order += addition + repeat_length= math.prod(factors[:factor_n]) + addition=math.prod(factors[factor_n+1:]) + mult=np.tile(np.repeat( range(num_indices//(addition*repeat_length)), repeat_length), addition) + order += addition* mult order=list(order) - + #define the sampler sampler = SamplerFromOrder( num_indices=num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) return sampler From 7d4ffe634c1d63ef0be810ef67d97cac9cbc8715 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 8 Dec 2023 08:52:05 +0000 Subject: [PATCH 086/115] Pulled prime factorisation code out of the Herman Meyer function --- .../cil/optimisation/utilities/sampler.py | 38 +++++++++++-------- 1 file changed, 22 insertions(+), 16 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 52aa565e3a..3f641f25dc 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -432,7 +432,25 @@ def sequential(num_indices): 1/num_indices]*num_indices) return sampler - + @staticmethod + def _prime_factorisation(n): + factors = [] + + while n % 2 == 0: + n//=2 + factors.append(2) + + i = 3 + while i*i <= n: + while n % i == 0: + n //= i; + factors.append(i) + i += 2 + + if n > 1: + factors.append(n) + + return factors @staticmethod def herman_meyer(num_indices): @@ -459,27 +477,15 @@ def herman_meyer(num_indices): [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] """ - - n_variable = num_indices - i = 2 - factors = [] - - #Prime factorisation - while i * i <= n_variable: - if n_variable % i: - i += 1 - else: - n_variable //= i - factors.append(i) - if n_variable > 1: - factors.append(n_variable) + factors=Sampler._prime_factorisation(num_indices) n_factors = len(factors) if n_factors == 1: raise ValueError( 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') - #Build up the sampling order iteratively using the prime factors + #Build up the sampling order iteratively using the prime factors + #In each iteration add on [ [0]*repeat_length, [addition]*repeat_length, ... ] tiled to fill the length of the list order = np.zeros(num_indices, dtype=np.int8) for factor_n in range(n_factors): if factor_n == 0: From 2dba9d7708cf9aea440660eba5201654a8a7c80a Mon Sep 17 00:00:00 2001 From: gfardell Date: Fri, 8 Dec 2023 16:08:42 +0000 Subject: [PATCH 087/115] created herman_meyer sampling as a fucntion of iteration number --- .../cil/optimisation/utilities/sampler.py | 183 +++++++++++++----- Wrappers/Python/test/test_sampler.py | 5 +- 2 files changed, 132 insertions(+), 56 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 3f641f25dc..bd07192ef0 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -19,7 +19,7 @@ import numpy as np import math import time - +from functools import partial class SamplerFromFunction(): """ @@ -126,9 +126,6 @@ def num_indices(self): def current_iter_number(self): return self._iteration_number - - - def next(self): """ Returns and increments the sampler @@ -452,55 +449,6 @@ def _prime_factorisation(n): return factors - @staticmethod - def herman_meyer(num_indices): - """ - Instantiates a sampler which outputs in a Herman Meyer order. - - Parameters - ---------- - num_indices: int - One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. - - Reference - ---------- - Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. - - Returns - ------- - A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a Herman Meyer ordering - - Example - ------- - >>> sampler=Sampler.herman_meyer(12) - >>> print(sampler.get_samples(16)) - [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] - """ - - factors=Sampler._prime_factorisation(num_indices) - - n_factors = len(factors) - if n_factors == 1: - raise ValueError( - 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') - - #Build up the sampling order iteratively using the prime factors - #In each iteration add on [ [0]*repeat_length, [addition]*repeat_length, ... ] tiled to fill the length of the list - order = np.zeros(num_indices, dtype=np.int8) - for factor_n in range(n_factors): - if factor_n == 0: - repeat_length= 1 - else: - repeat_length= math.prod(factors[:factor_n]) - addition=math.prod(factors[factor_n+1:]) - mult=np.tile(np.repeat( range(num_indices//(addition*repeat_length)), repeat_length), addition) - order += addition* mult - order=list(order) - - #define the sampler - sampler = SamplerFromOrder( - num_indices=num_indices, sampling_type='herman_meyer', order=order, prob_weights=[1/num_indices]*num_indices) - return sampler @staticmethod def staggered(num_indices, offset): @@ -681,3 +629,132 @@ def from_function(num_indices, function, prob_weights=None): sampler = SamplerFromFunction( num_indices=num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) return sampler + + @staticmethod + def _prime_factorisation(n): + """ + Parameters + ---------- + + n: int + The number to be factorised. + + Returns + ------- + + factors: list of ints + The prime factors of n. + + """ + factors = [] + + while n % 2 == 0: + n//=2 + factors.append(2) + + i = 3 + while i*i <= n: + while n % i == 0: + n //= i; + factors.append(i) + i += 2 + + if n > 1: + factors.append(n) + + return factors + + + @staticmethod + def _herman_meyer_function(num_indices, factors, addition_arr, repeat_length_arr, iteration_number): + """ + Parameters + ---------- + num_indices: int + The number of indices to be sampled from. + + factors: list of ints + The prime factors of num_indices. + + addition_arr: list of ints + The product of all factors at indices greater than the current factor. + + repeat_length_arr: list of ints + The product of all factors at indices less than the current factor. + + iteration_number: int + The current iteration number. + + Returns + ------- + index: int + The index to be sampled from. + + """ + + index = 0 + for n in range(len(factors)): + addition = addition_arr[n] + repeat_length = repeat_length_arr[n] + + length = num_indices//(addition*repeat_length) + arr = np.arange(length) * addition + + ind = math.floor(iteration_number/repeat_length) % length + index += arr[ind] + + return index + + + @staticmethod + def herman_meyer(num_indices): + """ + Instantiates a sampler which outputs in a Herman Meyer order. + + Parameters + ---------- + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. For Herman-Meyer sampling this number should not be prime. + + Reference + ---------- + Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. + + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a Herman Meyer ordering + + Example + ------- + >>> sampler=Sampler.herman_meyer(12) + >>> print(sampler.get_samples(16)) + [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] + """ + + factors = Sampler._prime_factorisation(num_indices) + + n_factors = len(factors) + if n_factors == 1: + raise ValueError( + 'Herman Meyer sampling defaults to sequential ordering if the number of indices is prime. Please use an alternative sampling method or change the number of indices. ') + + addition_arr = np.empty(n_factors, dtype=np.int64) + repeat_length_arr = np.empty(n_factors, dtype=np.int64) + + repeat_length = 1 + addition = num_indices + for i in range(n_factors): + addition //= factors[i] + addition_arr[i] = addition + + repeat_length_arr[i] = repeat_length + repeat_length *= factors[i] + + hmf_call = partial(Sampler._herman_meyer_function, num_indices, factors, addition_arr, repeat_length_arr) + + #define the sampler + sampler = SamplerFromFunction(function=hmf_call, + num_indices=num_indices, sampling_type='herman_meyer', prob_weights=[1/num_indices]*num_indices) + + return sampler + \ No newline at end of file diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 0c16f7420e..2f8cba39b4 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -64,9 +64,8 @@ def test_init(self): sampler = Sampler.herman_meyer(12) self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler._type, 'herman_meyer') - self.assertEqual(sampler._last_index, 11) - self.assertListEqual( - sampler._order, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) + out = [sampler.next() for _ in range(12)] + self.assertListEqual(out, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) self.assertListEqual(sampler.prob_weights, [1/12] * 12) sampler = Sampler.random_with_replacement(5) From f5c2d96050fc10ae9a05a0e21591fb94e154ce93 Mon Sep 17 00:00:00 2001 From: Margaret Duff <43645617+MargaretDuff@users.noreply.github.com> Date: Mon, 11 Dec 2023 14:35:15 +0000 Subject: [PATCH 088/115] Update Wrappers/Python/cil/optimisation/algorithms/SPDHG.py Co-authored-by: Edoardo Pasca Signed-off-by: Margaret Duff <43645617+MargaretDuff@users.noreply.github.com> --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 8ddd2ec0e6..0b2ad74f57 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -153,7 +153,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, use_axpby=kwargs.pop('use_axpyb', None) update_objective_interval = kwargs.pop('update_objective_interval', 1) super(SPDHG, self).__init__(max_iteration=max_iteration, - update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval, return_all=return_all) + update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, initial=initial, sampler=sampler, **kwargs) From 188000fe9540affddde4f44b3254df77f01617b3 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 11 Dec 2023 14:37:32 +0000 Subject: [PATCH 089/115] Changes from Edo review --- .../cil/optimisation/algorithms/SPDHG.py | 2 +- Wrappers/Python/test/test_algorithms.py | 175 ------------------ 2 files changed, 1 insertion(+), 176 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 8ddd2ec0e6..ad830f1a3e 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -147,7 +147,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=None, sampler=None, **kwargs): max_iteration = kwargs.pop('max_iteration', 0) - return_all=kwargs.pop('return_all', False) + print_interval= kwargs.pop('print_interval', None) log_file= kwargs.pop('log_file', None) use_axpby=kwargs.pop('use_axpyb', None) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 32a658bead..0bccf53207 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -1138,181 +1138,6 @@ def test_SPDHG_vs_PDHG_explicit(self): np.testing.assert_almost_equal(mse(spdhg.get_output(), pdhg.get_output()), 1.68590e-05, decimal=3) -""" @unittest.skipUnless(has_astra, "ccpi-astra not available") - def test_SPDHG_vs_SPDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get( - size=(16, 16), dtype=numpy.float32) - - ig = data.geometry - ig.voxel_size_x = 0.1 - ig.voxel_size_y = 0.1 - - detectors = ig.shape[0] - angles = np.linspace(0, np.pi, 180) - ag = AcquisitionGeometry.create_Parallel2D().set_angles( - angles, angle_unit='radian').set_panel(detectors, 0.1) - dev = 'cpu' - - Aop = ProjectionOperator(ig, ag, dev) - - sin = Aop.direct(data) - # Create noisy data. Apply Gaussian noise - noises = ['gaussian', 'poisson'] - noise = noises[1] - if noise == 'poisson': - np.random.seed(10) - scale = 5 - eta = 0 - noisy_data = AcquisitionData(np.asarray( - np.random.poisson(scale * (eta + sin.as_array()))/scale, - dtype=np.float32 - ), - geometry=ag - ) - elif noise == 'gaussian': - np.random.seed(10) - n1 = np.asarray(np.random.normal( - 0, 0.1, size=ag.shape), dtype=np.float32) - noisy_data = AcquisitionData(n1 + sin.as_array(), geometry=ag) - - else: - raise ValueError('Unsupported Noise ', noise) - - # %% 'explicit' SPDHG, scalar step-sizes - subsets = 5 - size_of_subsets = int(len(angles)/subsets) - # create GradientOperator operator - op1 = GradientOperator(ig) - # take angles and create uniform subsets in uniform+sequential setting - list_angles = [angles[i:i+size_of_subsets] - for i in range(0, len(angles), size_of_subsets)] - # create acquisitioin geometries for each the interval of splitting angles - list_geoms = [AcquisitionGeometry.create_Parallel2D().set_angles(list_angles[i], angle_unit='radian').set_panel(detectors, 0.1) - for i in range(len(list_angles))] - # create with operators as many as the subsets - A = BlockOperator(*[ProjectionOperator(ig, list_geoms[i], dev) - for i in range(subsets)] + [op1]) - # number of subsets - # (sub2ind, ind2sub) = divide_1Darray_equally(range(len(A)), subsets) - # - # acquisisiton data - # acquisisiton data - AD_list = [] - for sub_num in range(subsets): - for i in range(0, len(angles), size_of_subsets): - arr = noisy_data.as_array()[i:i+size_of_subsets, :] - AD_list.append(AcquisitionData( - arr, geometry=list_geoms[sub_num])) - - g = BlockDataContainer(*AD_list) - - alpha = 0.5 - # block function - F = BlockFunction(*[*[KullbackLeibler(b=g[i]) - for i in range(subsets)] + [alpha * MixedL21Norm()]]) - G = IndicatorBox(lower=0) - - prob = [1/(2*subsets)]*(len(A)-1) + [1/2] - algos = [] - algos.append(SPDHG(f=F, g=G, operator=A, - max_iteration=220, - update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=True) - ) - - algos[0].run(1000, verbose=0) - - algos.append(SPDHG(f=F, g=G, operator=A, - max_iteration=220, - update_objective_interval=250, sampler=Sampler.random_with_replacement(len(A), seed=2, prob=prob.copy()), use_axpby=False) - ) - - algos[1].run(1000, verbose=0) - - # np.testing.assert_array_almost_equal(algos[0].get_output().as_array(), algos[1].get_output().as_array()) - qm = (mae(algos[0].get_output(), algos[1].get_output()), - mse(algos[0].get_output(), algos[1].get_output()), - psnr(algos[0].get_output(), algos[1].get_output()) - ) - logging.info("Quality measures {}".format(qm)) - assert qm[0] < 0.005 - assert qm[1] < 0.001 - - @unittest.skipUnless(has_astra, "ccpi-astra not available") - def test_PDHG_vs_PDHG_explicit_axpby(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16, 16)) - ig = data.geometry - ig.voxel_size_x = 0.1 - ig.voxel_size_y = 0.1 - - detectors = ig.shape[0] - angles = np.linspace(0, np.pi, 180) - ag = AcquisitionGeometry.create_Parallel2D().set_angles( - angles, angle_unit='radian').set_panel(detectors, 0.1) - - dev = 'cpu' - - Aop = ProjectionOperator(ig, ag, dev) - - sin = Aop.direct(data) - - # Create noisy data. Apply Gaussian noise - noises = ['gaussian', 'poisson'] - noise = noises[1] - if noise == 'poisson': - np.random.seed(10) - scale = 5 - eta = 0 - noisy_data = AcquisitionData(numpy.asarray(np.random.poisson( - scale * (eta + sin.as_array())), dtype=numpy.float32)/scale, geometry=ag) - - elif noise == 'gaussian': - np.random.seed(10) - n1 = np.random.normal(0, 0.1, size=ag.shape) - noisy_data = AcquisitionData(numpy.asarray( - n1 + sin.as_array(), dtype=numpy.float32), geometry=ag) - - else: - raise ValueError('Unsupported Noise ', noise) - - alpha = 0.5 - op1 = GradientOperator(ig) - op2 = Aop - # Create BlockOperator - operator = BlockOperator(op1, op2, shape=(2, 1)) - f2 = KullbackLeibler(b=noisy_data) - g = IndicatorBox(lower=0) - normK = operator.norm() - sigma = 1./normK - tau = 1./normK - - f1 = alpha * MixedL21Norm() - f = BlockFunction(f1, f2) - # Setup and run the PDHG algorithm - - algos = [] - - algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - max_iteration=300, - update_objective_interval=1000, use_axpby=True) - ) - - algos[0].run(1000, verbose=0) - - algos.append(PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - max_iteration=300, - update_objective_interval=1000, use_axpby=False) - ) - - algos[1].run(1000, verbose=0) - - qm = (mae(algos[0].get_output(), algos[1].get_output()), - mse(algos[0].get_output(), algos[1].get_output()), - psnr(algos[0].get_output(), algos[1].get_output()) - ) - logging.info("Quality measures {}".format(qm)) - np.testing.assert_array_less(qm[0], 0.005) - np.testing.assert_array_less(qm[1], 3e-05) - """ class PrintAlgo(Algorithm): def __init__(self, **kwargs): From 86c1e3e1c6872694308b14d35092611b3088446d Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 11 Dec 2023 16:22:31 +0000 Subject: [PATCH 090/115] Removed from_order to replace with functions --- .../cil/optimisation/utilities/sampler.py | 312 +++++++----------- Wrappers/Python/test/test_sampler.py | 7 +- docs/source/optimisation.rst | 2 - 3 files changed, 125 insertions(+), 196 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index bd07192ef0..b8f6ea7445 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -21,31 +21,52 @@ import time from functools import partial + class SamplerFromFunction(): """ A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. + The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. Parameters ---------- - + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - + num_indices: int One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - sampling_type:str - The sampling type used. This is set to the default "from_function". + sampling_type:strm default='from_function" + The sampling type used. Choose from "sequential", "staggered", "herman_meyer" and "from_function". prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - + Returns ------- A Sampler wrapping a function that can be called with Sampler.next() or next(Sampler) - + + Example + ------- + >>> sampler=Sampler.staggered(21,4) + >>> print(sampler.get_samples(5)) + [ 0 4 8 12 16] + + Example + ------- + >>> sampler=Sampler.sequential(10) + >>> print(sampler.get_samples(5)) + [0 1 2 3 4] + + Example + ------- + >>> sampler=Sampler.herman_meyer(12) + >>> print(sampler.get_samples(16)) + [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] + + Example ------- This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. @@ -67,7 +88,7 @@ class SamplerFromFunction(): ------- This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. The probability weights are calculated and passed to the sampler as they are not uniform. - + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] >>> num_indices=13 >>> @@ -90,16 +111,16 @@ class SamplerFromFunction(): Current iteration number : 11 number of indices : 13 Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] - - + + Note ----- If your function involves a random number generator, then the seed should also depend on the iteration number, see the first example in the documentation, otherwise the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. """ - + def __init__(self, function, num_indices, sampling_type='from_function', prob_weights=None): - + self._type = sampling_type self._num_indices = num_indices self.function = function @@ -117,15 +138,15 @@ def __init__(self, function, num_indices, sampling_type='from_function', prob_w @property def prob_weights(self): return self._prob_weights - + @property def num_indices(self): - return self._num_indices - + return self._num_indices + @property def current_iter_number(self): return self._iteration_number - + def next(self): """ Returns and increments the sampler @@ -151,109 +172,14 @@ def get_samples(self, num_samples=20): return np.array(output) def __str__(self): - repres = "Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" + repres = "Deterministic sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" repres += "Type : {} \n".format(self._type) - repres += "Current iteration number : {} \n".format(self._iteration_number) + repres += "Current iteration number : {} \n".format( + self._iteration_number) repres += "Number of indices : {} \n".format(self._num_indices) repres += "Probability weights : {} \n".format(self._prob_weights) return repres - -class SamplerFromOrder(): - - def __init__(self, order, num_indices, sampling_type, prob_weights=None): - """ - This sampler will sample from a list `order` that is passed. - - It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. - - Parameters - ---------- - order: list of indices - The list of indices the method selects from using next. - - num_indices: int - One above the largest integer that could be drawn by the sampler. The elements in `order` should be chosen from {0, 1, …, S-1} with S=num_indices. - - sampling_type:str - The sampling type used. Choose from "sequential", "herman_meyer", and "staggered" - - prob_weights: list of floats of length num_indices that sum to 1. - Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - Returns - ------- - A Sampler outputting in order from an list that can be called with Sampler.next() or next(Sampler) - - Example - ------- - >>> sampler=Sampler.staggered(21,4) - >>> print(sampler.get_samples(5)) - [ 0 4 8 12 16] - """ - - - if prob_weights is None: - prob_weights= num_indices*[1/num_indices] - - if abs(sum(prob_weights)-1) > 1e-6: - raise ValueError('The provided prob_weights must sum to one') - - if any(np.array(prob_weights) < 0): - raise ValueError( - 'The provided prob_weights must be greater than or equal to zero') - - - self._prob_weights = prob_weights - self._type = sampling_type - self._num_indices = num_indices - self._order = order - self._last_index = len(order)-1 - - - @property - def prob_weights(self): - return self._prob_weights - - @property - def num_indices(self): - return self._num_indices - - @property - def current_index_number(self): - return self._iteration_number - - - - def next(self): - """Returns and increments the sampler """ - - self._last_index = (self._last_index+1) % len(self._order) - return self._order[self._last_index] - def __next__(self): - return self.next() - - def get_samples(self, num_samples=20): - """ - Returns the first `num_samples` as a numpy array. - - num_samples: int, default=20 - The number of samples to return. - """ - save_last_index = self._last_index - self._last_index = len(self._order)-1 - output = [self.next() for _ in range(num_samples)] - self._last_index = save_last_index - return np.array(output) - - def __str__(self): - repres = "Sampler that outputs in order from a list of integers taken from {0, 1, …, S-1}, where S is the number of indices. \n" - repres += "Type : {} \n".format(self._type) - repres += "Order : {} \n".format(self._order) - repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Current index number : {} \n".format(self._last_index) - repres += "Probability weights : {} \n".format(self._prob_weights) - return repres class SamplerRandom(): r""" @@ -281,12 +207,12 @@ class SamplerRandom(): prob_weights: list of floats of length num_indices that sum to 1. Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - + + Returns ------- A Sampler wrapping numpy.random.choice that can be called with Sampler.next() or next(Sampler) - + Example ------- >>> sampler=Sampler.random_with_replacement(5) @@ -296,14 +222,14 @@ class SamplerRandom(): >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) >>> print(sampler.get_samples(10)) [0 1 3 0 0 3 0 0 0 0] - + >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) >>> print(sampler.get_samples(16)) [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] """ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): - + self._replace = replace self._prob = prob @@ -331,11 +257,11 @@ def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): self._seed = int(time.time()) self._generator = np.random.RandomState(self._seed) - + @property def prob_weights(self): return self._prob_weights - + @property def num_indices(self): return self._num_indices @@ -362,21 +288,21 @@ def get_samples(self, num_samples=20): self._generator = save_generator return np.array(output) - def __str__(self): - repres = "Sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the number of indices." - repres += "Type : {} \n".format(self._type) - repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Probability weights : {} \n".format(self._prob_weights) - return repres + repres = "Random sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the number of indices." + repres += "Type : {} \n".format(self._type) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Probability weights : {} \n".format(self._prob_weights) + return repres + class Sampler(): r""" This class follows the factory design pattern. It is not instantiated but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. - + Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. - + Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. Example @@ -416,7 +342,7 @@ def sequential(num_indices): Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) and outputs sequentially - + Example ------- @@ -424,9 +350,9 @@ def sequential(num_indices): >>> print(sampler.get_samples(5)) [0 1 2 3 4] """ - order = list(range(num_indices)) - sampler = SamplerFromOrder(num_indices=num_indices, sampling_type='sequential', order=order, prob_weights=[ - 1/num_indices]*num_indices) + def function(x): return x % num_indices + sampler = SamplerFromFunction(function=function, num_indices=num_indices, sampling_type='sequential', prob_weights=[ + 1/num_indices]*num_indices) return sampler @staticmethod @@ -434,13 +360,13 @@ def _prime_factorisation(n): factors = [] while n % 2 == 0: - n//=2 + n //= 2 factors.append(2) i = 3 while i*i <= n: while n % i == 0: - n //= i; + n //= i factors.append(i) i += 2 @@ -449,12 +375,27 @@ def _prime_factorisation(n): return factors + @staticmethod + def _staggered_function(num_indices, offset, iter_number): + """Function that takes in an iteration number and outputs an index number based on the staggered ordering. """ + iter_number_mod = iter_number % num_indices + floor = num_indices//offset + mod = mod + + if iter_number_mod < (floor + 1)*mod: + row_number = iter_number_mod // (floor + 1) + column_number = (iter_number_mod % (floor + 1)) + else: + row_number = mod + (iter_number_mod-(floor+1)*mod)//floor + column_number = (iter_number_mod-(floor+1)*mod) % floor + + return row_number+offset*column_number @staticmethod def staggered(num_indices, offset): """ Instantiates a sampler which outputs in a staggered order. - + Parameters ---------- num_indices: int @@ -463,11 +404,11 @@ def staggered(num_indices, offset): offset: int The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. The offset should be less than the num_indices - + Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a staggered ordering - + Example ------- >>> sampler=Sampler.staggered(21,4) @@ -478,11 +419,9 @@ def staggered(num_indices, offset): if offset >= num_indices: raise (ValueError('The offset should be less than the number of indices')) - indices = list(range(num_indices)) - order = [] - [order.extend(indices[i::offset]) for i in range(offset)] - sampler = SamplerFromOrder(num_indices=num_indices, sampling_type='staggered', order=order, prob_weights=[ - 1/num_indices]*num_indices) + sampler = SamplerFromFunction(function=partial(Sampler._staggered_function, num_indices, offset), num_indices=num_indices, sampling_type='staggered', prob_weights=[ + 1/num_indices]*num_indices) + return sampler @staticmethod @@ -500,11 +439,11 @@ def random_with_replacement(num_indices, prob=None, seed=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) that samples randomly with replacement - + Example ------- @@ -512,7 +451,7 @@ def random_with_replacement(num_indices, prob=None, seed=None): >>> print(sampler.get_samples(10)) [3 4 0 0 2 3 3 2 2 1] - + >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) >>> print(sampler.get_samples(10)) [0 1 3 0 0 3 0 0 0 0] @@ -537,7 +476,7 @@ def random_without_replacement(num_indices, seed=None, prob=None): seed:int, default=None Random seed for the random number generator. If set to None, the seed will be set using the current time. - + Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) that samples randomly without replacement @@ -573,7 +512,7 @@ def from_function(num_indices, function, prob_weights=None): ----- If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. - + Returns ------- A Sampler that wraps a function and can be called with Sampler.next() or next(Sampler) @@ -597,7 +536,7 @@ def from_function(num_indices, function, prob_weights=None): ------- This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. The probability weights are calculated and passed to the sampler as they are not uniform. - + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] >>> num_indices=13 >>> @@ -620,9 +559,9 @@ def from_function(num_indices, function, prob_weights=None): Current iteration number : 11 number of indices : 13 Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] - + """ - + if prob_weights is None: prob_weights = [1/num_indices]*num_indices @@ -632,50 +571,46 @@ def from_function(num_indices, function, prob_weights=None): @staticmethod def _prime_factorisation(n): - """ - Parameters - ---------- - - n: int - The number to be factorised. + """ + Parameters + ---------- - Returns - ------- + n: int + The number to be factorised. - factors: list of ints - The prime factors of n. + Returns + ------- - """ - factors = [] + factors: list of ints + The prime factors of n. - while n % 2 == 0: - n//=2 - factors.append(2) + """ + factors = [] - i = 3 - while i*i <= n: - while n % i == 0: - n //= i; - factors.append(i) - i += 2 + while n % 2 == 0: + n //= 2 + factors.append(2) - if n > 1: - factors.append(n) + i = 3 + while i*i <= n: + while n % i == 0: + n //= i + factors.append(i) + i += 2 - return factors + if n > 1: + factors.append(n) + return factors @staticmethod - def _herman_meyer_function(num_indices, factors, addition_arr, repeat_length_arr, iteration_number): + def _herman_meyer_function(num_indices, addition_arr, repeat_length_arr, iteration_number): """ Parameters ---------- num_indices: int The number of indices to be sampled from. - factors: list of ints - The prime factors of num_indices. - addition_arr: list of ints The product of all factors at indices greater than the current factor. @@ -693,24 +628,23 @@ def _herman_meyer_function(num_indices, factors, addition_arr, repeat_length_arr """ index = 0 - for n in range(len(factors)): + for n in range(len(addition_arr)): addition = addition_arr[n] repeat_length = repeat_length_arr[n] length = num_indices//(addition*repeat_length) arr = np.arange(length) * addition - ind = math.floor(iteration_number/repeat_length) % length - index += arr[ind] + ind = math.floor(iteration_number/repeat_length) % length + index += arr[ind] return index - @staticmethod def herman_meyer(num_indices): """ Instantiates a sampler which outputs in a Herman Meyer order. - + Parameters ---------- num_indices: int @@ -719,11 +653,11 @@ def herman_meyer(num_indices): Reference ---------- Herman GT, Meyer LB. Algebraic reconstruction techniques can be made computationally efficient. IEEE Trans Med Imaging. doi: 10.1109/42.241889. - + Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) and outputs in a Herman Meyer ordering - + Example ------- >>> sampler=Sampler.herman_meyer(12) @@ -750,11 +684,11 @@ def herman_meyer(num_indices): repeat_length_arr[i] = repeat_length repeat_length *= factors[i] - hmf_call = partial(Sampler._herman_meyer_function, num_indices, factors, addition_arr, repeat_length_arr) + hmf_call = partial(Sampler._herman_meyer_function, + num_indices, factors, addition_arr, repeat_length_arr) - #define the sampler + # define the sampler sampler = SamplerFromFunction(function=hmf_call, - num_indices=num_indices, sampling_type='herman_meyer', prob_weights=[1/num_indices]*num_indices) + num_indices=num_indices, sampling_type='herman_meyer', prob_weights=[1/num_indices]*num_indices) return sampler - \ No newline at end of file diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 2f8cba39b4..381acf9883 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -44,8 +44,6 @@ def test_init(self): sampler = Sampler.sequential(10) self.assertEqual(sampler.num_indices, 10) self.assertEqual(sampler._type, 'sequential') - self.assertListEqual(sampler._order, list(range(10))) - self.assertEqual(sampler._last_index, 9) self.assertListEqual(sampler.prob_weights, [1/10]*10) sampler = Sampler.random_without_replacement(7) @@ -83,9 +81,8 @@ def test_init(self): sampler = Sampler.staggered(21, 4) self.assertEqual(sampler.num_indices, 21) self.assertEqual(sampler._type, 'staggered') - self.assertListEqual(sampler._order, [ - 0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) - self.assertEqual(sampler._last_index, 20) + out = [sampler.next() for _ in range(21)] + self.assertListEqual(out, [0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19]) self.assertListEqual(sampler.prob_weights, [1/21] * 21) with self.assertRaises(ValueError): diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 90bff47aeb..d17048594e 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -388,8 +388,6 @@ The static methods will call one of the following: .. autoclass:: cil.optimisation.utilities.SamplerFromFunction :members: -.. autoclass:: cil.optimisation.utilities.SamplerFromOrder - :members: Block Framework From 47542a575526e316416f724ea50616b61b51ddc2 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 12 Dec 2023 09:16:02 +0000 Subject: [PATCH 091/115] fix failing tests --- Wrappers/Python/cil/optimisation/utilities/__init__.py | 1 - 1 file changed, 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py index a96692e1ce..ff81329840 100644 --- a/Wrappers/Python/cil/optimisation/utilities/__init__.py +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -20,5 +20,4 @@ from .sampler import Sampler from .sampler import SamplerFromFunction -from .sampler import SamplerFromOrder from .sampler import SamplerRandom From ddbdbb3c5d96211fa8b60e86879b824300da0502 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 12 Dec 2023 09:49:54 +0000 Subject: [PATCH 092/115] Test fix...again --- Wrappers/Python/cil/optimisation/utilities/sampler.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index b8f6ea7445..89d17df959 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -380,7 +380,7 @@ def _staggered_function(num_indices, offset, iter_number): """Function that takes in an iteration number and outputs an index number based on the staggered ordering. """ iter_number_mod = iter_number % num_indices floor = num_indices//offset - mod = mod + mod = num_indices%offset if iter_number_mod < (floor + 1)*mod: row_number = iter_number_mod // (floor + 1) @@ -685,7 +685,7 @@ def herman_meyer(num_indices): repeat_length *= factors[i] hmf_call = partial(Sampler._herman_meyer_function, - num_indices, factors, addition_arr, repeat_length_arr) + num_indices, addition_arr, repeat_length_arr) # define the sampler sampler = SamplerFromFunction(function=hmf_call, From d896594a25265c6b11851f69d17b1b4679c49e85 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 19 Dec 2023 15:58:32 +0000 Subject: [PATCH 093/115] Move back to one class --- .../cil/optimisation/utilities/__init__.py | 3 +- .../cil/optimisation/utilities/sampler.py | 492 +++++++----------- Wrappers/Python/test/test_sampler.py | 85 +-- 3 files changed, 244 insertions(+), 336 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py index ff81329840..729f4acc0a 100644 --- a/Wrappers/Python/cil/optimisation/utilities/__init__.py +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -19,5 +19,4 @@ from .sampler import Sampler -from .sampler import SamplerFromFunction -from .sampler import SamplerRandom + diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 89d17df959..f0ee5b3bba 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -22,288 +22,52 @@ from functools import partial -class SamplerFromFunction(): +class Sampler(): """ - A class that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}. - - The function next() outputs a single next index from the list {0,1,…,S-1}.To be run again and again, depending on how many iterations. - - It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through Sampler.from_function(num_indices, function, prob_weights) from cil.optimisation.utilities.sampler. - - Parameters - ---------- - - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - - num_indices: int - One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - - sampling_type:strm default='from_function" - The sampling type used. Choose from "sequential", "staggered", "herman_meyer" and "from_function". - - prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices - Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - Returns - ------- - A Sampler wrapping a function that can be called with Sampler.next() or next(Sampler) - - Example - ------- - >>> sampler=Sampler.staggered(21,4) - >>> print(sampler.get_samples(5)) - [ 0 4 8 12 16] - - Example - ------- - >>> sampler=Sampler.sequential(10) - >>> print(sampler.get_samples(5)) - [0 1 2 3 4] - - Example - ------- - >>> sampler=Sampler.herman_meyer(12) - >>> print(sampler.get_samples(16)) - [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] - - - Example - ------- - This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. - For the next 500 iterations it uniformly randomly with replacement samples from {0,...,49}. The num_indices is 50 and the prob_weights are left as default because in the limit all indices will be seen with equal probability. - >>> def test_function(iteration_number): - >>> if iteration_number<500: - >>> np.random.seed(iteration_number) - >>> return(np.random.choice(49,1)[0]) - >>> else: - >>> np.random.seed(iteration_number) - >>> return(np.random.choice(50,1)[0]) - >>> - >>> Sampler.from_function(num_indices, function, prob_weights=None) - >>> print(list(sampler.get_samples(25))) - [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] - - - Example - ------- - This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. - The probability weights are calculated and passed to the sampler as they are not uniform. - - >>> custom_list=[1,1,1,0,0,11,5,9,8,3] - >>> num_indices=13 - >>> - >>> def test_function(iteration_number, custom_list=custom_list): - return(custom_list[iteration_number%len(custom_list)]) - >>> - >>> #calculate prob weights - >>> temp_list = [] - >>> for i in range(num_indices): - >>> temp_list.append(custom_list.count(i)) - >>> total = sum(temp_list) - >>> prob_weights = [x/total for x in temp_list] - >>> - >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) - >>> print(list(sampler.get_samples(25))) - [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] - >>> print(sampler) - Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. - Type : from_function - Current iteration number : 11 - number of indices : 13 - Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] - - - Note - ----- - If your function involves a random number generator, then the seed should also depend on the iteration number, see the first example in the documentation, otherwise - the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. - """ - - def __init__(self, function, num_indices, sampling_type='from_function', prob_weights=None): - - self._type = sampling_type - self._num_indices = num_indices - self.function = function - - if abs(sum(prob_weights)-1) > 1e-6: - raise ValueError('The provided prob_weights must sum to one') - - if any(np.array(prob_weights) < 0): - raise ValueError( - 'The provided prob_weights must be greater than or equal to zero') - - self._prob_weights = prob_weights - self._iteration_number = 0 - - @property - def prob_weights(self): - return self._prob_weights - - @property - def num_indices(self): - return self._num_indices - - @property - def current_iter_number(self): - return self._iteration_number - - def next(self): - """ - Returns and increments the sampler - """ - out = self.function(self._iteration_number) - self._iteration_number += 1 - return out - - def __next__(self): - return self.next() - - def get_samples(self, num_samples=20): - """ - Returns the first `num_samples` produced by the sampler as a numpy array. - - num_samples: int, default=20 - The number of samples to return. - """ - save_last_index = self._iteration_number - self._iteration_number = 0 - output = [self.next() for _ in range(num_samples)] - self._iteration_number = save_last_index - return np.array(output) - - def __str__(self): - repres = "Deterministic sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" - repres += "Type : {} \n".format(self._type) - repres += "Current iteration number : {} \n".format( - self._iteration_number) - repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Probability weights : {} \n".format(self._prob_weights) - return repres + This class follows the factory design pattern. It is not instantiated directly but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. + Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. -class SamplerRandom(): - r""" - A class to select from a list of indices {0, 1, …, S-1} using numpy.random.choice with and without replacement. - The function next() outputs a single next index from the list {0,1,…,S-1} . + Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. - It is recommended to use the static methods to configure your Sampler object rather than initialising this class directly: the user should call this through cil.optimisation.utilities.sampler and choose the desired static method from the Sampler class. + Parameters ---------- + + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. + num_indices: int One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - sampling_type:str - The sampling type used. Choose from "random_with_replacement" and "random_without_replacement" + sampling_type:str default='from_function" + The sampling type used. Choose from "random_with_replacement", "random_without_replacement", "sequential", "staggered", "herman_meyer" and "from_function". - replace= bool + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + replace: bool If True, sample with replace, otherwise sample without replacement - - prob: list of floats of length num_indices that sum to 1. - For random sampling with replacement, this is the probability for each index to be called by next. - + seed:int, default=None - Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. - - prob_weights: list of floats of length num_indices that sum to 1. - Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - + Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. + Returns ------- - A Sampler wrapping numpy.random.choice that can be called with Sampler.next() or next(Sampler) + A Sampler that can be called with Sampler.next() or next(Sampler) Example ------- >>> sampler=Sampler.random_with_replacement(5) - >>> print(sampler.get_samples(10)) - [3 4 0 0 2 3 3 2 2 1] - - >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) - >>> print(sampler.get_samples(10)) - [0 1 3 0 0 3 0 0 0 0] - - >>> sampler=Sampler.randomWithoutReplacement(7, seed=1) - >>> print(sampler.get_samples(16)) - [6 2 1 0 4 3 5 1 0 4 2 5 6 3 3 2] - """ - - def __init__(self, num_indices, replace, sampling_type, prob=None, seed=None): - - self._replace = replace - self._prob = prob - - if prob is None: - self._prob = [1/num_indices]*num_indices - - if replace: - self._prob_weights = self._prob - else: - self._prob_weights = [1/num_indices]*num_indices - - if abs(sum(self._prob_weights)-1) > 1e-6: - raise ValueError('The provided prob_weights must sum to one') - - if any(np.array(self._prob_weights) < 0): - raise ValueError( - 'The provided prob_weights must be greater than or equal to zero') - - self._type = sampling_type - self._num_indices = num_indices - - if seed is not None: - self._seed = seed - else: - self._seed = int(time.time()) - - self._generator = np.random.RandomState(self._seed) - - @property - def prob_weights(self): - return self._prob_weights - - @property - def num_indices(self): - return self._num_indices - - def next(self): - """ Returns and increments the sampler """ - - return int(self._generator.choice(self._num_indices, 1, p=self._prob, replace=self._replace)) - - def __next__(self): - return self.next() - - def get_samples(self, num_samples=20): - """ - Returns the first `num_samples` as a numpy array. - - num_samples: int, default=20 - The number of samples to return. - - """ - save_generator = self._generator - self._generator = np.random.RandomState(self._seed) - output = [self.next() for _ in range(num_samples)] - self._generator = save_generator - return np.array(output) - - def __str__(self): - repres = "Random sampler that wraps numpy.random.choice to sample from {0, 1, …, S-1}, where S is the number of indices." - repres += "Type : {} \n".format(self._type) - repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Probability weights : {} \n".format(self._prob_weights) - return repres - - -class Sampler(): - - r""" - This class follows the factory design pattern. It is not instantiated but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. + >>> print(sampler.get_samples()) + [3 4 0 0 2 3 3 2 2 1 1 4 4 3 0 2 4 4 2 4] - Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. - Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. + Example + ------- + >>> sampler=Sampler.staggered(21,4) + >>> print(sampler.get_samples(5)) + [ 0 4 8 12 16] Example ------- @@ -311,12 +75,65 @@ class Sampler(): >>> print(sampler.get_samples(5)) [0 1 2 3 4] + Example + ------- + >>> sampler=Sampler.herman_meyer(12) + >>> print(sampler.get_samples(16)) + [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] + + + Example TODO: + ------- + This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. + For the next 500 iterations it uniformly randomly with replacement samples from {0,...,49}. The num_indices is 50 and the prob_weights are left as default because in the limit all indices will be seen with equal probability. + >>> def test_function(iteration_number): + >>> if iteration_number<500: + >>> np.random.seed(iteration_number) + >>> return(np.random.choice(49,1)[0]) + >>> else: + >>> np.random.seed(iteration_number) + >>> return(np.random.choice(50,1)[0]) + >>> + >>> Sampler.from_function(num_indices, function, prob_weights=None) + >>> print(list(sampler.get_samples(25))) + [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] + + + Note TODO: + ----- + If your function involves a random number generator, then the seed should also depend on the iteration number otherwise + the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. + Example ------- - >>> sampler=Sampler.random_with_replacement(5) - >>> print(sampler.get_samples()) - [3 4 0 0 2 3 3 2 2 1 1 4 4 3 0 2 4 4 2 4] + This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. + The probability weights are calculated and passed to the sampler as they are not uniform. + + >>> custom_list=[1,1,1,0,0,11,5,9,8,3] + >>> num_indices=13 + >>> + >>> def test_function(iteration_number, custom_list=custom_list): + return(custom_list[iteration_number%len(custom_list)]) + >>> + >>> #calculate prob weights + >>> temp_list = [] + >>> for i in range(num_indices): + >>> temp_list.append(custom_list.count(i)) + >>> total = sum(temp_list) + >>> prob_weights = [x/total for x in temp_list] + >>> + >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) + >>> print(list(sampler.get_samples(25))) + [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] + >>> print(sampler) + Sampler that wraps a function that takes an iteration number and selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. + Type : from_function + Current iteration number : 11 + number of indices : 13 + Probability weights : [0.2, 0.3, 0.0, 0.1, 0.0, 0.1, 0.0, 0.0, 0.1, 0.1, 0.0, 0.1, 0.0] + + Note ----- @@ -327,9 +144,7 @@ class Sampler(): For example, to be 99% certain that you have seen all indices, for `n=20` you should take at least 152 samples, `n=50` at least 426 samples. To be more likely than not, for `n=20` you should take 78 samples and `n=50` you should take 228 samples. In general, we note that for a large number of samples (e.g. `>20*num_indices`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_indices`) the user may wish to consider another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. - - """ - + """ @staticmethod def sequential(num_indices): """ @@ -351,29 +166,10 @@ def sequential(num_indices): [0 1 2 3 4] """ def function(x): return x % num_indices - sampler = SamplerFromFunction(function=function, num_indices=num_indices, sampling_type='sequential', prob_weights=[ + sampler = Sampler(function=function, num_indices=num_indices, sampling_type='sequential', prob_weights=[ 1/num_indices]*num_indices) return sampler - @staticmethod - def _prime_factorisation(n): - factors = [] - - while n % 2 == 0: - n //= 2 - factors.append(2) - - i = 3 - while i*i <= n: - while n % i == 0: - n //= i - factors.append(i) - i += 2 - - if n > 1: - factors.append(n) - - return factors @staticmethod def _staggered_function(num_indices, offset, iter_number): @@ -419,10 +215,12 @@ def staggered(num_indices, offset): if offset >= num_indices: raise (ValueError('The offset should be less than the number of indices')) - sampler = SamplerFromFunction(function=partial(Sampler._staggered_function, num_indices, offset), num_indices=num_indices, sampling_type='staggered', prob_weights=[ + sampler = Sampler(function=partial(Sampler._staggered_function, num_indices, offset), num_indices=num_indices, sampling_type='staggered', prob_weights=[ 1/num_indices]*num_indices) return sampler + + @staticmethod def random_with_replacement(num_indices, prob=None, seed=None): @@ -459,13 +257,15 @@ def random_with_replacement(num_indices, prob=None, seed=None): if prob == None: prob = [1/num_indices] * num_indices + + - sampler = SamplerRandom( - num_indices=num_indices, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) + sampler = Sampler( + num_indices=num_indices, sampling_type='random_with_replacement', replace=True, prob_weights=prob, seed=seed) return sampler @staticmethod - def random_without_replacement(num_indices, seed=None, prob=None): + def random_without_replacement(num_indices, seed=None): """ Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, uniformly randomly without replacement. @@ -488,8 +288,8 @@ def random_without_replacement(num_indices, seed=None, prob=None): """ - sampler = SamplerRandom( - num_indices=num_indices, sampling_type='random_without_replacement', replace=False, seed=seed, prob=prob) + sampler = Sampler( + num_indices=num_indices, sampling_type='random_without_replacement', replace=False, seed=seed) return sampler @staticmethod @@ -565,7 +365,7 @@ def from_function(num_indices, function, prob_weights=None): if prob_weights is None: prob_weights = [1/num_indices]*num_indices - sampler = SamplerFromFunction( + sampler = Sampler( num_indices=num_indices, sampling_type='from_function', function=function, prob_weights=prob_weights) return sampler @@ -688,7 +488,109 @@ def herman_meyer(num_indices): num_indices, addition_arr, repeat_length_arr) # define the sampler - sampler = SamplerFromFunction(function=hmf_call, + sampler = Sampler(function=hmf_call, num_indices=num_indices, sampling_type='herman_meyer', prob_weights=[1/num_indices]*num_indices) return sampler + + def __init__(self, num_indices, function=None, seed=None, replace='True', sampling_type='random_with_replacement', prob_weights=None): + + self._type = sampling_type + self._num_indices = num_indices + self.function = function + + if prob_weights is None: + prob_weights=[1/num_indices]*num_indices + else: + if abs(sum(prob_weights)-1) > 1e-6: + raise ValueError('The provided prob_weights must sum to one') + + if any(np.array(prob_weights) < 0): + raise ValueError( + 'The provided prob_weights must be greater than or equal to zero') + + self._prob_weights = prob_weights + self._iteration_number = 0 + + if function is not None: + self.next=self.next_function + self.deterministic=True + else: + if seed is not None: + self._seed = seed + else: + self._seed = int(time.time()) + self.next=self.next_random + self._generator = np.random.RandomState(self._seed) + self._sampling_list=None + self.deterministic=False + self._replace=replace + + + @property + def prob_weights(self): + return self._prob_weights + + @property + def num_indices(self): + return self._num_indices + + @property + def current_iter_number(self): + return self._iteration_number + + def next_function(self): + """ + Returns and increments the sampler + """ + + out = self.function(self._iteration_number) + + self._iteration_number += 1 + return out + + def next_random(self): + """ Returns and increments the sampler """ + if self._iteration_number% self._num_indices==0: + self._sampling_list=self._generator.choice(self._num_indices, self._num_indices, p=self._prob_weights, replace=self._replace) + out=self._sampling_list[self._iteration_number % self._num_indices] + self._iteration_number+=1 + return out + + def __next__(self): + return self.next() + + def get_samples(self, num_samples=20): + """ + Returns the first `num_samples` produced by the sampler as a numpy array. + + Parameters + ---------- + num_samples: int, default=20 + The number of samples to return. + """ + save_last_index = self._iteration_number + self._iteration_number = 0 + if not self.deterministic: + save_generator = self._generator + self._generator = np.random.RandomState(self._seed) + save_sampling_list=self._sampling_list + output = [self.next() for _ in range(num_samples)] + self._iteration_number = save_last_index + if not self.deterministic: + self._generator = save_generator + self._sampling_list=save_sampling_list + return np.array(output) + + def __str__(self): + repres = "Sampler that selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" + repres += "Type : {} \n".format(self._type) + repres += "Current iteration number : {} \n".format( + self._iteration_number) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Probability weights : {} \n".format(self._prob_weights) + return repres + + + + diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index 381acf9883..c5ce947b10 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -49,15 +49,15 @@ def test_init(self): sampler = Sampler.random_without_replacement(7) self.assertEqual(sampler.num_indices, 7) self.assertEqual(sampler._type, 'random_without_replacement') - self.assertEqual(sampler._prob, [1/7]*7) - self.assertListEqual(sampler.prob_weights, sampler._prob) + self.assertEqual(sampler._prob_weights, [1/7]*7) + self.assertListEqual(sampler.prob_weights, sampler._prob_weights) sampler = Sampler.random_without_replacement(8, seed=1) self.assertEqual(sampler.num_indices, 8) self.assertEqual(sampler._type, 'random_without_replacement') - self.assertEqual(sampler._prob, [1/8]*8) + self.assertEqual(sampler._prob_weights, [1/8]*8) self.assertEqual(sampler._seed, 1) - self.assertListEqual(sampler.prob_weights, sampler._prob) + self.assertListEqual(sampler.prob_weights, sampler._prob_weights) sampler = Sampler.herman_meyer(12) self.assertEqual(sampler.num_indices, 12) @@ -69,13 +69,12 @@ def test_init(self): sampler = Sampler.random_with_replacement(5) self.assertEqual(sampler.num_indices, 5) self.assertEqual(sampler._type, 'random_with_replacement') - self.assertListEqual(sampler._prob, [1/5] * 5) + self.assertListEqual(sampler._prob_weights, [1/5] * 5) self.assertListEqual(sampler.prob_weights, [1/5] * 5) sampler = Sampler.random_with_replacement(4, [0.7, 0.1, 0.1, 0.1]) self.assertEqual(sampler.num_indices, 4) self.assertEqual(sampler._type, 'random_with_replacement') - self.assertListEqual(sampler._prob, [0.7, 0.1, 0.1, 0.1]) self.assertListEqual(sampler.prob_weights, [0.7, 0.1, 0.1, 0.1]) sampler = Sampler.staggered(21, 4) @@ -117,81 +116,89 @@ def test_from_function(self): sampler = Sampler.from_function(50, self.example_function) order = [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] + self.assertNumpyArrayEqual(sampler.get_samples(), np.array( + order)[:20]) + for i in range(25): self.assertEqual(next(sampler), order[i]) - if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(), np.array( - order)[:20]) + + self.assertEqual(sampler.get_samples(550)[519], self.example_function(519)) + def test_sequential_iterator_and_get_samples(self): # Test the squential sampler sampler = Sampler.sequential(10) - for i in range(25): - self.assertEqual(next(sampler), i % 10) - if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual(sampler.get_samples(), np.array( + self.assertNumpyArrayEqual(sampler.get_samples(), np.array( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) - - sampler = Sampler.sequential(10) - for i in range(25): - # Repeat the test for .next() - self.assertEqual(sampler.next(), i % 10) - if i % 5 == 0: - self.assertNumpyArrayEqual(sampler.get_samples(), np.array( + + for i in range(337): + self.assertEqual(next(sampler), i % 10) + + self.assertNumpyArrayEqual(sampler.get_samples(), np.array( [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9])) - + + + def test_random_without_replacement_iterator_and_get_samples(self): # Test the random without replacement sampler sampler = Sampler.random_without_replacement(7, seed=1) - order = [2, 5, 0, 2, 1, 0, 1, 2, 2, 3, 2, 4, - 1, 6, 0, 4, 2, 3, 0, 1, 5, 6, 2, 4, 6] + order = [2, 5, 0, 1, 4, 3, 6, 1, 6, 0, 4, 2, 3, 5, 5, 6, 2, 4, 0, 1, 3, 0, + 2, 6, 3] + self.assertNumpyArrayEqual(sampler.get_samples(25), np.array(order[:25])) + for i in range(25): self.assertEqual(next(sampler), order[i]) - if i % 4 == 0: # Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual( - sampler.get_samples(6), np.array(order[:6])) + self.assertNumpyArrayEqual(sampler.get_samples(25), np.array(order[:25])) + + def test_herman_meyer_iterator_and_get_samples(self): # Test the Herman Meyer sampler sampler = Sampler.herman_meyer(12) order = [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11, 0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11] + self.assertNumpyArrayEqual( + sampler.get_samples(14), np.array(order[:14])) + for i in range(25): self.assertEqual(sampler.next(), order[i % 12]) - if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual( - sampler.get_samples(14), np.array(order[:14])) + + self.assertNumpyArrayEqual( + sampler.get_samples(14), np.array(order[:14])) def test_random_with_replacement_iterator_and_get_samples(self): # Test the Random with replacement sampler sampler = Sampler.random_with_replacement(5, seed=5) order = [1, 4, 1, 4, 2, 3, 3, 2, 1, 0, 0, 3, 2, 0, 4, 1, 2, 1, 3, 2, 2, 1, 1, 1, 1] + self.assertNumpyArrayEqual( + sampler.get_samples(14), np.array(order[:14])) + for i in range(25): self.assertEqual(next(sampler), order[i]) - if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual( - sampler.get_samples(14), np.array(order[:14])) + self.assertNumpyArrayEqual( + sampler.get_samples(14), np.array(order[:14])) + + sampler = Sampler.random_with_replacement( 4, [0.7, 0.1, 0.1, 0.1], seed=5) order = [0, 2, 0, 3, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + for i in range(25): self.assertEqual(sampler.next(), order[i]) - if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual( - sampler.get_samples(14), np.array(order[:14])) + self.assertNumpyArrayEqual(sampler.get_samples(14), np.array(order[:14])) + def test_staggered_iterator_and_get_samples(self): # Test the staggered sampler sampler = Sampler.staggered(21, 4) order = [0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] + self.assertNumpyArrayEqual(sampler.get_samples(10), np.array(order[:10])) for i in range(25): self.assertEqual(next(sampler), order[i % 21]) - if i % 5 == 0: # Check both that get samples works and doesn't interrupt the sampler - self.assertNumpyArrayEqual( - sampler.get_samples(10), np.array(order[:10])) - + self.assertNumpyArrayEqual(sampler.get_samples(10), np.array(order[:10])) From d6e986ae8a5da3f15745c561f7e737e2755b07fc Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 19 Dec 2023 16:01:14 +0000 Subject: [PATCH 094/115] Remove axpyb --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 1 - 1 file changed, 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 7ea32ff451..76e9e82866 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -150,7 +150,6 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, print_interval= kwargs.pop('print_interval', None) log_file= kwargs.pop('log_file', None) - use_axpby=kwargs.pop('use_axpyb', None) update_objective_interval = kwargs.pop('update_objective_interval', 1) super(SPDHG, self).__init__(max_iteration=max_iteration, update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval) From ca05199b5b4310747ee0028ca2278ea391fb11eb Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Dec 2023 11:40:32 +0000 Subject: [PATCH 095/115] Split into two classes --- .../cil/optimisation/utilities/__init__.py | 2 + .../cil/optimisation/utilities/sampler.py | 221 +++++++++++++----- 2 files changed, 166 insertions(+), 57 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py index 729f4acc0a..399973030b 100644 --- a/Wrappers/Python/cil/optimisation/utilities/__init__.py +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -19,4 +19,6 @@ from .sampler import Sampler +from .sampler import SamplerRandom +from .sampler import MantidSampler diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index f0ee5b3bba..abeee2c0e6 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -25,6 +25,7 @@ class Sampler(): """ This class follows the factory design pattern. It is not instantiated directly but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. + Custom samplers can be created by subclassing the sampler class. Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. @@ -40,17 +41,13 @@ class Sampler(): num_indices: int One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - sampling_type:str default='from_function" - The sampling type used. Choose from "random_with_replacement", "random_without_replacement", "sequential", "staggered", "herman_meyer" and "from_function". + sampling_type:str default is None + The sampling type used. Choose from "sequential", "staggered", "herman_meyer" and "from_function". prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - replace: bool - If True, sample with replace, otherwise sample without replacement - - seed:int, default=None - Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. + Returns ------- @@ -260,8 +257,8 @@ def random_with_replacement(num_indices, prob=None, seed=None): - sampler = Sampler( - num_indices=num_indices, sampling_type='random_with_replacement', replace=True, prob_weights=prob, seed=seed) + sampler = SamplerRandom( + num_indices=num_indices, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) return sampler @staticmethod @@ -288,7 +285,7 @@ def random_without_replacement(num_indices, seed=None): """ - sampler = Sampler( + sampler = SamplerRandom( num_indices=num_indices, sampling_type='random_without_replacement', replace=False, seed=seed) return sampler @@ -310,27 +307,12 @@ def from_function(num_indices, function, prob_weights=None): Note ----- - If your function involves a random number generator, then the seed should also depend on the iteration number, see the example in the documentation, otherwise - the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. + If your function involves a random number generator, then it may be easier to subclass the SamplerRandom class instead. Returns ------- A Sampler that wraps a function and can be called with Sampler.next() or next(Sampler) - ------- - This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. - For the next 500 iterations it uniformly randomly with replacement samples from {0,...,49}. The num_indices is 50 and the prob_weights are left as default because in the limit all indices will be seen with equal probability. - >>> def test_function(iteration_number): - >>> if iteration_number<500: - >>> np.random.seed(iteration_number) - >>> return(np.random.choice(49,1)[0]) - >>> else: - >>> np.random.seed(iteration_number) - >>> return(np.random.choice(50,1)[0]) - >>> - >>> Sampler.from_function(num_indices, function, prob_weights=None) - >>> print(list(sampler.get_samples(25))) - [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] - + Example ------- @@ -493,7 +475,7 @@ def herman_meyer(num_indices): return sampler - def __init__(self, num_indices, function=None, seed=None, replace='True', sampling_type='random_with_replacement', prob_weights=None): + def __init__(self, num_indices, function, sampling_type=None, prob_weights=None): self._type = sampling_type self._num_indices = num_indices @@ -512,20 +494,7 @@ def __init__(self, num_indices, function=None, seed=None, replace='True', sampl self._prob_weights = prob_weights self._iteration_number = 0 - if function is not None: - self.next=self.next_function - self.deterministic=True - else: - if seed is not None: - self._seed = seed - else: - self._seed = int(time.time()) - self.next=self.next_random - self._generator = np.random.RandomState(self._seed) - self._sampling_list=None - self.deterministic=False - self._replace=replace - + @property def prob_weights(self): @@ -539,7 +508,7 @@ def num_indices(self): def current_iter_number(self): return self._iteration_number - def next_function(self): + def next(self): """ Returns and increments the sampler """ @@ -549,13 +518,7 @@ def next_function(self): self._iteration_number += 1 return out - def next_random(self): - """ Returns and increments the sampler """ - if self._iteration_number% self._num_indices==0: - self._sampling_list=self._generator.choice(self._num_indices, self._num_indices, p=self._prob_weights, replace=self._replace) - out=self._sampling_list[self._iteration_number % self._num_indices] - self._iteration_number+=1 - return out + def __next__(self): return self.next() @@ -571,15 +534,13 @@ def get_samples(self, num_samples=20): """ save_last_index = self._iteration_number self._iteration_number = 0 - if not self.deterministic: - save_generator = self._generator - self._generator = np.random.RandomState(self._seed) - save_sampling_list=self._sampling_list + output = [self.next() for _ in range(num_samples)] + self._iteration_number = save_last_index - if not self.deterministic: - self._generator = save_generator - self._sampling_list=save_sampling_list + + + return np.array(output) def __str__(self): @@ -593,4 +554,150 @@ def __str__(self): +class SamplerRandom(Sampler): + """ + This class follows the factory design pattern. It is not instantiated directly but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. + Custom samplers can be created by subclassing the sampler class. + + Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. + + Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. + + + + Parameters + ---------- + + function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. + + num_indices: int + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + + sampling_type:str default='from_function" + The sampling type used. Choose from "random_with_replacement", "random_without_replacement", "sequential", "staggered", "herman_meyer" and "from_function". + + prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. + + replace: bool + If True, sample with replace, otherwise sample without replacement + + seed:int, default=None + Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. + Returns + ------- + A Sampler that can be called with Sampler.next() or next(Sampler) + + Example + ------- + >>> sampler=Sampler.random_with_replacement(5) + >>> print(sampler.get_samples()) + [3 4 0 0 2 3 3 2 2 1 1 4 4 3 0 2 4 4 2 4] + + + + + Note + ----- + The optimal choice of sampler depends on the data and the number of calls to the sampler. + + For random sampling with replacement, there is the possibility, with a small number of calls to the sampler that some indices will not have been selected. For the case of uniform probabilities, the default, the number of + iterations required such that the probability that all indices have been selected at least once is greater than :math:`p` grows as :math:`nlog(n/p)` where `n` is `num_indices`. + For example, to be 99% certain that you have seen all indices, for `n=20` you should take at least 152 samples, `n=50` at least 426 samples. To be more likely than not, for `n=20` you should take 78 samples and `n=50` you should take 228 samples. + In general, we note that for a large number of samples (e.g. `>20*num_indices`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_indices`) the user may wish to consider + another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. + """ + + + def __init__(self, num_indices, seed=None, replace='True', prob=None, sampling_type='random_with_replacement'): + + if seed is not None: + self._seed = seed + else: + self._seed = int(time.time()) + self._generator = np.random.RandomState(self._seed) + self._sampling_list = None + self._replace = replace + + super(SamplerRandom,self).__init__( num_indices, self.function, sampling_type=sampling_type, prob_weights=prob ) + + + @property + def seed(self): + return self._seed + + @property + def replace(self): + return self._replace + + + def function(self, iteration_number): + """ Returns and increments the sampler """ #TODO: explain what happens in this piece of code + location=iteration_number % self._num_indices + if location==0: + self._sampling_list = self._generator.choice(self._num_indices, self._num_indices, p=self._prob_weights, replace=self._replace) + out=self._sampling_list[location] + return out + + + def get_samples(self, num_samples=20): + """ + Returns the first `num_samples` produced by the sampler as a numpy array. + + Parameters + ---------- + num_samples: int, default=20 + The number of samples to return. + """ + save_last_index = self._iteration_number + self._iteration_number = 0 + + save_generator = self._generator + self._generator = np.random.RandomState(self._seed) + save_sampling_list=self._sampling_list + + output = [self.next() for _ in range(num_samples)] + + self._iteration_number = save_last_index + + + self._generator = save_generator + self._sampling_list=save_sampling_list + + return np.array(output) + + def __str__(self): + repres = "Sampler that selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" + repres += "Type : {} \n".format(self._type) + repres += "Current iteration number : {} \n".format( + self._iteration_number) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Probability weights : {} \n".format(self._prob_weights) + repres += "Seed : {} \n".format(self._seed) + return repres + + + + + + + + + +class MantidSampler(SamplerRandom): + def function(self, iteration_number): + """ Returns and increments the sampler """ #TODO: explain what happens in this piece of code + location=iteration_number%self.num_indices + if location==0: + if iteration_number<500: + self._sampling_list = self._generator.choice(self.num_indices-1, self.num_indices, p=[1/(self.num_indices-1)]*(self.num_indices-1), replace=self.replace) + if iteration_number>=500: + self._sampling_list = self._generator.choice(self.num_indices, self.num_indices, p=self.prob_weights, replace=self.replace) + out=self._sampling_list[location] + return out + def __init__(self, num_indices, seed=None, replace='True', prob=None, sampling_type='Mantid Sampler '): + super(MantidSampler,self).__init__( num_indices, seed, replace, prob, sampling_type ) + + + \ No newline at end of file From 46d6dadc7f5d2846ed6a4d4365416c4c0678406c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Dec 2023 11:47:56 +0000 Subject: [PATCH 096/115] Tidy up the docstrings --- .../cil/optimisation/utilities/sampler.py | 49 ++++++------------- 1 file changed, 15 insertions(+), 34 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index abeee2c0e6..71a940175f 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -31,7 +31,6 @@ class Sampler(): Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. - Parameters ---------- @@ -79,27 +78,10 @@ class Sampler(): [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] - Example TODO: - ------- - This example creates a sampler that uniformly randomly with replacement samples from the numbers {0,1,...,48} for the first 500 iterations. - For the next 500 iterations it uniformly randomly with replacement samples from {0,...,49}. The num_indices is 50 and the prob_weights are left as default because in the limit all indices will be seen with equal probability. - >>> def test_function(iteration_number): - >>> if iteration_number<500: - >>> np.random.seed(iteration_number) - >>> return(np.random.choice(49,1)[0]) - >>> else: - >>> np.random.seed(iteration_number) - >>> return(np.random.choice(50,1)[0]) - >>> - >>> Sampler.from_function(num_indices, function, prob_weights=None) - >>> print(list(sampler.get_samples(25))) - [44, 37, 40, 42, 46, 35, 10, 47, 3, 28, 9, 25, 11, 18, 43, 8, 41, 47, 42, 29, 35, 9, 4, 19, 34] - - - Note TODO: + + Note ----- - If your function involves a random number generator, then the seed should also depend on the iteration number otherwise - the `get_samples()` function may not accurately return the correct samples and may interrupt the next sample returned. + If your function involves a random number generator, then it may be easier to subclass the SamplerRandom class instead. Example @@ -142,6 +124,7 @@ class Sampler(): In general, we note that for a large number of samples (e.g. `>20*num_indices`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_indices`) the user may wish to consider another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. """ + @staticmethod def sequential(num_indices): """ @@ -179,10 +162,10 @@ def _staggered_function(num_indices, offset, iter_number): row_number = iter_number_mod // (floor + 1) column_number = (iter_number_mod % (floor + 1)) else: - row_number = mod + (iter_number_mod-(floor+1)*mod)//floor - column_number = (iter_number_mod-(floor+1)*mod) % floor + row_number = mod + (iter_number_mod - (floor+1)*mod) // floor + column_number = (iter_number_mod - (floor+1)*mod) % floor - return row_number+offset*column_number + return row_number + offset*column_number @staticmethod def staggered(num_indices, offset): @@ -414,7 +397,7 @@ def _herman_meyer_function(num_indices, addition_arr, repeat_length_arr, iterat addition = addition_arr[n] repeat_length = repeat_length_arr[n] - length = num_indices//(addition*repeat_length) + length = num_indices // (addition*repeat_length) arr = np.arange(length) * addition ind = math.floor(iteration_number/repeat_length) % length @@ -482,7 +465,7 @@ def __init__(self, num_indices, function, sampling_type=None, prob_weights=None self.function = function if prob_weights is None: - prob_weights=[1/num_indices]*num_indices + prob_weights = [1/num_indices]*num_indices else: if abs(sum(prob_weights)-1) > 1e-6: raise ValueError('The provided prob_weights must sum to one') @@ -556,7 +539,7 @@ def __str__(self): class SamplerRandom(Sampler): """ - This class follows the factory design pattern. It is not instantiated directly but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. + This class follows the factory design pattern. It is not designed to be instantiated directly but instead can be called from the 6 static methods in the parent Sampler class. Custom samplers can be created by subclassing the sampler class. Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. @@ -568,18 +551,16 @@ class SamplerRandom(Sampler): Parameters ---------- - function: A function that takes an in integer iteration number and returns an integer from {0, 1, …, S-1} with S=num_indices. - num_indices: int One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - sampling_type:str default='from_function" - The sampling type used. Choose from "random_with_replacement", "random_without_replacement", "sequential", "staggered", "herman_meyer" and "from_function". + sampling_type:str default='random_with_replacement" + The sampling type used. Choose from "random_with_replacement" and "random_without_replacement" prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - replace: bool + replace: bool, defualt is True If True, sample with replace, otherwise sample without replacement seed:int, default=None @@ -615,7 +596,7 @@ def __init__(self, num_indices, seed=None, replace='True', prob=None, sampling if seed is not None: self._seed = seed else: - self._seed = int(time.time()) + self._seed = int(time.time()) #TODO: check the seed self._generator = np.random.RandomState(self._seed) self._sampling_list = None self._replace = replace @@ -687,7 +668,7 @@ def __str__(self): class MantidSampler(SamplerRandom): def function(self, iteration_number): - """ Returns and increments the sampler """ #TODO: explain what happens in this piece of code + """ Returns and increments the sampler """ location=iteration_number%self.num_indices if location==0: if iteration_number<500: From 2b6b5c7f25c9c0f1f8827b7f0d3de0389afc7379 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Dec 2023 12:40:54 +0000 Subject: [PATCH 097/115] Some formating things --- .../cil/optimisation/utilities/sampler.py | 178 ++++++++---------- Wrappers/Python/test/test_sampler.py | 5 +- 2 files changed, 83 insertions(+), 100 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 71a940175f..fba79d75dc 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -31,7 +31,7 @@ class Sampler(): Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. - + Parameters ---------- @@ -45,40 +45,40 @@ class Sampler(): prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - + + Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) Example ------- - >>> sampler=Sampler.random_with_replacement(5) + >>> sampler = Sampler.random_with_replacement(5) >>> print(sampler.get_samples()) [3 4 0 0 2 3 3 2 2 1 1 4 4 3 0 2 4 4 2 4] Example ------- - >>> sampler=Sampler.staggered(21,4) + >>> sampler = Sampler.staggered(21,4) >>> print(sampler.get_samples(5)) [ 0 4 8 12 16] Example ------- - >>> sampler=Sampler.sequential(10) + >>> sampler = Sampler.sequential(10) >>> print(sampler.get_samples(5)) [0 1 2 3 4] Example ------- - >>> sampler=Sampler.herman_meyer(12) + >>> sampler = Sampler.herman_meyer(12) >>> print(sampler.get_samples(16)) [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] - + Note ----- If your function involves a random number generator, then it may be easier to subclass the SamplerRandom class instead. @@ -89,8 +89,8 @@ class Sampler(): This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. The probability weights are calculated and passed to the sampler as they are not uniform. - >>> custom_list=[1,1,1,0,0,11,5,9,8,3] - >>> num_indices=13 + >>> custom_list = [1,1,1,0,0,11,5,9,8,3] + >>> num_indices = 13 >>> >>> def test_function(iteration_number, custom_list=custom_list): return(custom_list[iteration_number%len(custom_list)]) @@ -102,7 +102,7 @@ class Sampler(): >>> total = sum(temp_list) >>> prob_weights = [x/total for x in temp_list] >>> - >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) + >>> sampler = Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) >>> print(list(sampler.get_samples(25))) [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] >>> print(sampler) @@ -124,7 +124,7 @@ class Sampler(): In general, we note that for a large number of samples (e.g. `>20*num_indices`), the density of the outputted samples looks more and more uniform. For a small number of samples (e.g. `<5*num_indices`) the user may wish to consider another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. """ - + @staticmethod def sequential(num_indices): """ @@ -145,18 +145,19 @@ def sequential(num_indices): >>> print(sampler.get_samples(5)) [0 1 2 3 4] """ - def function(x): return x % num_indices + def function(x): + return x % num_indices + sampler = Sampler(function=function, num_indices=num_indices, sampling_type='sequential', prob_weights=[ 1/num_indices]*num_indices) return sampler - @staticmethod - def _staggered_function(num_indices, offset, iter_number): + def _staggered_function(num_indices, stride, iter_number): """Function that takes in an iteration number and outputs an index number based on the staggered ordering. """ iter_number_mod = iter_number % num_indices - floor = num_indices//offset - mod = num_indices%offset + floor = num_indices // stride + mod = num_indices % stride if iter_number_mod < (floor + 1)*mod: row_number = iter_number_mod // (floor + 1) @@ -165,10 +166,10 @@ def _staggered_function(num_indices, offset, iter_number): row_number = mod + (iter_number_mod - (floor+1)*mod) // floor column_number = (iter_number_mod - (floor+1)*mod) % floor - return row_number + offset*column_number + return row_number + stride*column_number @staticmethod - def staggered(num_indices, offset): + def staggered(num_indices, stride): """ Instantiates a sampler which outputs in a staggered order. @@ -177,9 +178,9 @@ def staggered(num_indices, offset): num_indices: int One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - offset: int - The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=offset. - The offset should be less than the num_indices + stride: int + The sampler will output in the order {0, a, 2a, 3a, ...., 1, 1+a, 1+2a, 1+3a,...., 2, 2+a, 2+2a, 2+3a,...} where a=stride. + The stride should be less than the num_indices Returns ------- @@ -192,30 +193,28 @@ def staggered(num_indices, offset): [ 0 4 8 12 16] """ - if offset >= num_indices: - raise (ValueError('The offset should be less than the number of indices')) + if stride >= num_indices: + raise (ValueError('The stride should be less than the number of indices')) - sampler = Sampler(function=partial(Sampler._staggered_function, num_indices, offset), num_indices=num_indices, sampling_type='staggered', prob_weights=[ + sampler = Sampler(function=partial(Sampler._staggered_function, num_indices, stride), num_indices=num_indices, sampling_type='staggered', prob_weights=[ 1/num_indices]*num_indices) return sampler - - @staticmethod def random_with_replacement(num_indices, prob=None, seed=None): """ - Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S=num_indices, with given probability and with replacement. + Instantiates a sampler which outputs from a list of indices {0, 1, …, S-1}, with S = num_indices, with given probability and with replacement. Parameters ---------- num_indices: int - One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S = num_indices. - prob: list of floats of length num_indices that sum to 1. default=None + prob: list of floats of length num_indices that sum to 1. default is None This is the probability for each index to be called by next. If None, then the indices will be sampled uniformly. - seed:int, default=None + seed:int, default is None Random seed for the random number generator. If set to None, the seed will be set using the current time. Returns @@ -225,20 +224,17 @@ def random_with_replacement(num_indices, prob=None, seed=None): Example ------- - >>> sampler=Sampler.random_with_replacement(5) + >>> sampler = Sampler.random_with_replacement(5) >>> print(sampler.get_samples(10)) [3 4 0 0 2 3 3 2 2 1] - - >>> sampler=Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) + >>> sampler = Sampler.random_with_replacement(4, [0.7,0.1,0.1,0.1]) >>> print(sampler.get_samples(10)) [0 1 3 0 0 3 0 0 0 0] """ if prob == None: prob = [1/num_indices] * num_indices - - sampler = SamplerRandom( num_indices=num_indices, sampling_type='random_with_replacement', replace=True, prob=prob, seed=seed) @@ -295,15 +291,15 @@ def from_function(num_indices, function, prob_weights=None): Returns ------- A Sampler that wraps a function and can be called with Sampler.next() or next(Sampler) - + Example ------- This example creates a sampler that samples in order from a custom list. The num_indices is 13, although note that the index 12 is never called by the sampler. The number of indices must be at least one greater than any of the elements in the custom_list. The probability weights are calculated and passed to the sampler as they are not uniform. - >>> custom_list=[1,1,1,0,0,11,5,9,8,3] - >>> num_indices=13 + >>> custom_list = [1,1,1,0,0,11,5,9,8,3] + >>> num_indices = 13 >>> >>> def test_function(iteration_number, custom_list=custom_list): return(custom_list[iteration_number%len(custom_list)]) @@ -315,7 +311,7 @@ def from_function(num_indices, function, prob_weights=None): >>> total = sum(temp_list) >>> prob_weights = [x/total for x in temp_list] >>> - >>> sampler=Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) + >>> sampler = Sampler.from_function(num_indices=num_indices, function=test_function, prob_weights=prob_weights) >>> print(list(sampler.get_samples(25))) [1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0, 11, 5, 9, 8, 3, 1, 1, 1, 0, 0] >>> print(sampler) @@ -454,7 +450,7 @@ def herman_meyer(num_indices): # define the sampler sampler = Sampler(function=hmf_call, - num_indices=num_indices, sampling_type='herman_meyer', prob_weights=[1/num_indices]*num_indices) + num_indices=num_indices, sampling_type='herman_meyer', prob_weights=[1/num_indices]*num_indices) return sampler @@ -463,7 +459,7 @@ def __init__(self, num_indices, function, sampling_type=None, prob_weights=None self._type = sampling_type self._num_indices = num_indices self.function = function - + if prob_weights is None: prob_weights = [1/num_indices]*num_indices else: @@ -476,8 +472,6 @@ def __init__(self, num_indices, function, sampling_type=None, prob_weights=None self._prob_weights = prob_weights self._iteration_number = 0 - - @property def prob_weights(self): @@ -501,8 +495,6 @@ def next(self): self._iteration_number += 1 return out - - def __next__(self): return self.next() @@ -512,21 +504,19 @@ def get_samples(self, num_samples=20): Parameters ---------- - num_samples: int, default=20 + num_samples: int, default = 20 The number of samples to return. """ save_last_index = self._iteration_number self._iteration_number = 0 - + output = [self.next() for _ in range(num_samples)] - + self._iteration_number = save_last_index - - return np.array(output) - def __str__(self): + def __str__(self): repres = "Sampler that selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" repres += "Type : {} \n".format(self._type) repres += "Current iteration number : {} \n".format( @@ -536,7 +526,6 @@ def __str__(self): return repres - class SamplerRandom(Sampler): """ This class follows the factory design pattern. It is not designed to be instantiated directly but instead can be called from the 6 static methods in the parent Sampler class. @@ -547,32 +536,32 @@ class SamplerRandom(Sampler): Common in each instantiated class, the function `next()` outputs a single next index from the list {0,1,…,S-1}. Each class also has a `get_samples(n)` function which will output the first `n` samples. - + Parameters ---------- num_indices: int One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. - sampling_type:str default='random_with_replacement" + sampling_type:str default = 'random_with_replacement" The sampling type used. Choose from "random_with_replacement" and "random_without_replacement" prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - + replace: bool, defualt is True If True, sample with replace, otherwise sample without replacement - - seed:int, default=None + + seed:int, default = None Random seed for the methods that use a numpy random number generator. If set to None, the seed will be set using the current time. - + Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) Example ------- - >>> sampler=Sampler.random_with_replacement(5) + >>> sampler = Sampler.random_with_replacement(5) >>> print(sampler.get_samples()) [3 4 0 0 2 3 3 2 2 1 1 4 4 3 0 2 4 4 2 4] @@ -590,19 +579,18 @@ class SamplerRandom(Sampler): another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. """ - def __init__(self, num_indices, seed=None, replace='True', prob=None, sampling_type='random_with_replacement'): if seed is not None: self._seed = seed else: - self._seed = int(time.time()) #TODO: check the seed + self._seed = int(time.time()) # TODO: check the seed self._generator = np.random.RandomState(self._seed) self._sampling_list = None self._replace = replace - super(SamplerRandom,self).__init__( num_indices, self.function, sampling_type=sampling_type, prob_weights=prob ) - + super(SamplerRandom, self).__init__(num_indices, self.function, + sampling_type=sampling_type, prob_weights=prob) @property def seed(self): @@ -612,15 +600,14 @@ def seed(self): def replace(self): return self._replace - def function(self, iteration_number): - """ Returns and increments the sampler """ #TODO: explain what happens in this piece of code - location=iteration_number % self._num_indices - if location==0: - self._sampling_list = self._generator.choice(self._num_indices, self._num_indices, p=self._prob_weights, replace=self._replace) - out=self._sampling_list[location] + """ Returns and increments the sampler """ # TODO: explain what happens in this piece of code + location = iteration_number % self._num_indices + if location == 0: + self._sampling_list = self._generator.choice( + self._num_indices, self._num_indices, p=self._prob_weights, replace=self._replace) + out = self._sampling_list[location] return out - def get_samples(self, num_samples=20): """ @@ -628,27 +615,26 @@ def get_samples(self, num_samples=20): Parameters ---------- - num_samples: int, default=20 + num_samples: int, default = 20 The number of samples to return. """ save_last_index = self._iteration_number self._iteration_number = 0 - + save_generator = self._generator self._generator = np.random.RandomState(self._seed) - save_sampling_list=self._sampling_list - + save_sampling_list = self._sampling_list + output = [self.next() for _ in range(num_samples)] - + self._iteration_number = save_last_index - self._generator = save_generator - self._sampling_list=save_sampling_list - + self._sampling_list = save_sampling_list + return np.array(output) - def __str__(self): + def __str__(self): repres = "Sampler that selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" repres += "Type : {} \n".format(self._type) repres += "Current iteration number : {} \n".format( @@ -659,26 +645,20 @@ def __str__(self): return repres - - - - - - - class MantidSampler(SamplerRandom): def function(self, iteration_number): - """ Returns and increments the sampler """ - location=iteration_number%self.num_indices - if location==0: - if iteration_number<500: - self._sampling_list = self._generator.choice(self.num_indices-1, self.num_indices, p=[1/(self.num_indices-1)]*(self.num_indices-1), replace=self.replace) - if iteration_number>=500: - self._sampling_list = self._generator.choice(self.num_indices, self.num_indices, p=self.prob_weights, replace=self.replace) - out=self._sampling_list[location] + """ Returns and increments the sampler """ + location = iteration_number % self.num_indices + if location == 0: + if iteration_number < 500: + self._sampling_list = self._generator.choice(self.num_indices-1, self.num_indices, p=[ + 1/(self.num_indices-1)]*(self.num_indices-1), replace=self.replace) + if iteration_number >= 500: + self._sampling_list = self._generator.choice( + self.num_indices, self.num_indices, p=self.prob_weights, replace=self.replace) + out = self._sampling_list[location] return out + def __init__(self, num_indices, seed=None, replace='True', prob=None, sampling_type='Mantid Sampler '): - super(MantidSampler,self).__init__( num_indices, seed, replace, prob, sampling_type ) - - - \ No newline at end of file + super(MantidSampler, self).__init__( + num_indices, seed, replace, prob, sampling_type) diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index c5ce947b10..314722a83e 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -62,9 +62,10 @@ def test_init(self): sampler = Sampler.herman_meyer(12) self.assertEqual(sampler.num_indices, 12) self.assertEqual(sampler._type, 'herman_meyer') + self.assertListEqual(sampler.prob_weights, [1/12] * 12) out = [sampler.next() for _ in range(12)] self.assertListEqual(out, [0, 6, 3, 9, 1, 7, 4, 10, 2, 8, 5, 11]) - self.assertListEqual(sampler.prob_weights, [1/12] * 12) + sampler = Sampler.random_with_replacement(5) self.assertEqual(sampler.num_indices, 5) @@ -108,6 +109,7 @@ def test_init(self): #check probabilities sum to 1 and are positive with self.assertRaises(ValueError): Sampler.from_function(40, self.example_function, [0.9]+[0]*39) + with self.assertRaises(ValueError): Sampler.from_function(40, self.example_function, [-1]+[2]+[0]*38) @@ -198,6 +200,7 @@ def test_staggered_iterator_and_get_samples(self): order = [0, 4, 8, 12, 16, 20, 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19] self.assertNumpyArrayEqual(sampler.get_samples(10), np.array(order[:10])) + for i in range(25): self.assertEqual(next(sampler), order[i % 21]) From 235d26ca6088ffb30ad72c21b5abaa458d10958c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 21 Dec 2023 12:58:53 +0000 Subject: [PATCH 098/115] Example subclass --- .../cil/optimisation/utilities/sampler.py | 24 ++++++++++--------- 1 file changed, 13 insertions(+), 11 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index fba79d75dc..dd7f0658b2 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -549,7 +549,7 @@ class SamplerRandom(Sampler): prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - replace: bool, defualt is True + replace: bool, default is True If True, sample with replace, otherwise sample without replacement seed:int, default = None @@ -579,12 +579,12 @@ class SamplerRandom(Sampler): another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. """ - def __init__(self, num_indices, seed=None, replace='True', prob=None, sampling_type='random_with_replacement'): + def __init__(self, num_indices, seed=None, replace=True, prob=None, sampling_type='random_with_replacement'): if seed is not None: self._seed = seed else: - self._seed = int(time.time()) # TODO: check the seed + self._seed = int(time.time()) self._generator = np.random.RandomState(self._seed) self._sampling_list = None self._replace = replace @@ -601,7 +601,7 @@ def replace(self): return self._replace def function(self, iteration_number): - """ Returns and increments the sampler """ # TODO: explain what happens in this piece of code + """ For each iteration number this function samples from a randomly generated list in order. Every num_indices the list is re-created. """ location = iteration_number % self._num_indices if location == 0: self._sampling_list = self._generator.choice( @@ -647,18 +647,20 @@ def __str__(self): class MantidSampler(SamplerRandom): def function(self, iteration_number): - """ Returns and increments the sampler """ - location = iteration_number % self.num_indices - if location == 0: - if iteration_number < 500: - self._sampling_list = self._generator.choice(self.num_indices-1, self.num_indices, p=[ + """ For each iteration number this function samples from a randomly generated list in order. Every num_indices the list is re-created. For the first aproximately 50*(num_indices -1) iterations the last index is never called. """ + if iteration_number < 50*(self.num_indices -1): + location = iteration_number % (self.num_indices -1) + if location == 0: + self._sampling_list = self._generator.choice(self.num_indices-1, self.num_indices -1, p=[ 1/(self.num_indices-1)]*(self.num_indices-1), replace=self.replace) - if iteration_number >= 500: + else: + location = iteration_number % self.num_indices + if location == 0: self._sampling_list = self._generator.choice( self.num_indices, self.num_indices, p=self.prob_weights, replace=self.replace) out = self._sampling_list[location] return out - def __init__(self, num_indices, seed=None, replace='True', prob=None, sampling_type='Mantid Sampler '): + def __init__(self, num_indices, seed=None, replace=False, prob=None, sampling_type='Mantid Sampler '): super(MantidSampler, self).__init__( num_indices, seed, replace, prob, sampling_type) From e107b7208cf84b5cd1cc80a3b30ddad99e217579 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 9 Jan 2024 16:06:47 +0000 Subject: [PATCH 099/115] Changes from meeting with Edo and Gemma --- .../cil/optimisation/algorithms/SPDHG.py | 57 +++--- .../cil/optimisation/utilities/sampler.py | 170 +++++++++--------- Wrappers/Python/test/test_algorithms.py | 25 ++- 3 files changed, 141 insertions(+), 111 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 76e9e82866..6f6d0a6468 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -158,7 +158,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=initial, sampler=sampler, **kwargs) def set_up(self, f, g, operator, sigma=None, tau=None, - initial=None, sampler=None, **deprecated_kwargs): + initial=None, sampler=None, prob_weights=None, **deprecated_kwargs): '''set-up of the algorithm Parameters @@ -177,8 +177,11 @@ def set_up(self, f, g, operator, sigma=None, tau=None, Initial point for the SPDHG algorithm gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: an instance of a `cil.optimisation.utilities.Sampler` class - Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets + sampler: an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting t a sample from {1,...,len(operator)}. + Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/number of subsets + prob_weights: (Optional) list of floats of length num_indices that sum to 1. Defaults to [1/len(operator)]*len(operator) + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Note that this should not be passed if the provided sampler has it as an attribute. + ''' logging.info("{} setting up".format(self.__class__.__name__, )) @@ -192,20 +195,25 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self.ndual_subsets = len(self.operator) self._sampler = sampler + + self.prob_weights=getattr(self._sampler, 'prob_weights', None) + if prob_weights is not None: + if self.prob_weights is None: + self.prob_weights = prob_weights + else: + raise ValueError( + ' You passed a `prob_weights`argument and a sampler with attribute `prob_weights`, please remove the `prob_weights` argument.') + self._deprecated_kwargs(deprecated_kwargs) - if self._sampler is None: - self._sampler = Sampler.random_with_replacement(len(operator)) + if self.prob_weights is None: + self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets - if self._sampler.num_indices != len(operator): - raise ValueError('The `num_indices` the sampler outputs from should be equal to the number of opertors in the BlockOperator `operator`') + if self._sampler is None: + self._sampler = Sampler.random_with_replacement(len(operator), prob=self.prob_weights) self.norms = operator.get_norms_as_list() - if self._sampler.prob_weights is None: - self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets - else: - self.prob_weights=self._sampler.prob_weights self.set_step_sizes(sigma=sigma, tau=tau) @@ -244,20 +252,22 @@ def _deprecated_kwargs(self, deprecated_kwargs): """ norms = deprecated_kwargs.pop('norms', None) prob = deprecated_kwargs.pop('prob', None) + + if prob is not None: + if self.prob_weights is None: + warnings.warn('`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). To pass probabilites to the calculation for `sigma` and `tau` please use `prob_weights`. ') + self.prob_weights=prob + else: + + raise ValueError( + '`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. You passed a `prob` argument, and either a `prob_weights` argument or a sampler with a `prob_weights` property. Please give only one of the three. ') + + if norms is not None: self.operator.set_norms(norms) warnings.warn( ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') - if self._sampler is not None: - if prob is not None: - raise TypeError( - '`prob` is being deprecated to be replaced with a sampler class. You passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - else: - if prob is not None: - warnings.warn('`prob` is being deprecated to be replaced with a sampler class. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). Note that if you passed a `sampler` and a `prob` argument this `prob` argument will be ignored.') - self._sampler = Sampler.random_with_replacement( - len(self.operator), prob=prob) if deprecated_kwargs: raise ValueError("Additional keyword arguments passed but not used: {}".format( @@ -271,7 +281,7 @@ def sigma(self): def tau(self): return self._tau - def set_step_sizes_from_ratio(self, gamma=1., rho=.99): + def set_step_sizes_from_ratio(self, gamma=1.0, rho=0.99): r""" Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. Parameters @@ -413,7 +423,10 @@ def update(self): # Gradient ascent for the dual variable # y_k = y_old[i] + sigma[i] * K[i] x - y_k = self.operator[i].direct(self.x) + try: + y_k = self.operator[i].direct(self.x) + except IndexError: + raise IndexError('The sampler has outputted an index larger than the number of operators to sample from. Please ensure your sampler samples from {1,2,...,len(operator)} only.') y_k.sapyb(self.sigma[i], self.y_old[i], 1., out=y_k) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index dd7f0658b2..6c0e7c15f7 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -24,7 +24,7 @@ class Sampler(): """ - This class follows the factory design pattern. It is not instantiated directly but has 6 static methods that will return instances of 6 different samplers, which require a variety of parameters. + This class follows the factory design pattern. It is not instantiated directly but has static methods that will return instances of different samplers, which require a variety of parameters. Custom samplers can be created by subclassing the sampler class. Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. @@ -46,8 +46,6 @@ class Sampler(): prob_weights: list of floats of length num_indices that sum to 1. Default is [1/num_indices]*num_indices Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. - - Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) @@ -125,6 +123,77 @@ class Sampler(): another sampling method e.g. random without replacement, which, when calling `num_indices` samples is guaranteed to draw each index exactly once. """ + def __init__(self, num_indices, function, sampling_type=None, prob_weights=None): + + self._type = sampling_type + self._num_indices = num_indices + self.function = function + + if prob_weights is None: + prob_weights = [1/num_indices]*num_indices + else: + if abs(sum(prob_weights)-1) > 1e-6: + raise ValueError('The provided prob_weights must sum to one') + + if any(np.array(prob_weights) < 0): + raise ValueError( + 'The provided prob_weights must be greater than or equal to zero') + + self._prob_weights = prob_weights + self._iteration_number = 0 + + @property + def prob_weights(self): + return self._prob_weights + + @property + def num_indices(self): + return self._num_indices + + @property + def current_iter_number(self): + return self._iteration_number + + def next(self): + """ + Returns a sample from the list of indices `{0, 1, …, S-1}, where S is the number of indices and increments the sampler. + """ + + out = self.function(self._iteration_number) + + self._iteration_number += 1 + return out + + def __next__(self): + return self.next() + + def get_samples(self, num_samples=20): + """ + Returns the first `num_samples` produced by the sampler as a numpy array. + + Parameters + ---------- + num_samples: int, default = 20 + The number of samples to return. + """ + save_last_index = self._iteration_number + self._iteration_number = 0 + + output = [self.next() for _ in range(num_samples)] + + self._iteration_number = save_last_index + + return np.array(output) + + def __str__(self): + repres = "Sampler that selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" + repres += "Type : {} \n".format(self._type) + repres += "Current iteration number : {} \n".format( + self._iteration_number) + repres += "Number of indices : {} \n".format(self._num_indices) + repres += "Probability weights : {} \n".format(self._prob_weights) + return repres + @staticmethod def sequential(num_indices): """ @@ -134,6 +203,7 @@ def sequential(num_indices): ---------- num_indices: int One above the largest integer that could be drawn by the sampler. The sampler will select from a list of indices {0, 1, …, S-1} with S=num_indices. + Returns ------- A Sampler that can be called with Sampler.next() or next(Sampler) and outputs sequentially @@ -341,7 +411,7 @@ def _prime_factorisation(n): Returns ------- - + factors: list of ints The prime factors of n. @@ -454,81 +524,10 @@ def herman_meyer(num_indices): return sampler - def __init__(self, num_indices, function, sampling_type=None, prob_weights=None): - - self._type = sampling_type - self._num_indices = num_indices - self.function = function - - if prob_weights is None: - prob_weights = [1/num_indices]*num_indices - else: - if abs(sum(prob_weights)-1) > 1e-6: - raise ValueError('The provided prob_weights must sum to one') - - if any(np.array(prob_weights) < 0): - raise ValueError( - 'The provided prob_weights must be greater than or equal to zero') - - self._prob_weights = prob_weights - self._iteration_number = 0 - - @property - def prob_weights(self): - return self._prob_weights - - @property - def num_indices(self): - return self._num_indices - - @property - def current_iter_number(self): - return self._iteration_number - - def next(self): - """ - Returns and increments the sampler - """ - - out = self.function(self._iteration_number) - - self._iteration_number += 1 - return out - - def __next__(self): - return self.next() - - def get_samples(self, num_samples=20): - """ - Returns the first `num_samples` produced by the sampler as a numpy array. - - Parameters - ---------- - num_samples: int, default = 20 - The number of samples to return. - """ - save_last_index = self._iteration_number - self._iteration_number = 0 - - output = [self.next() for _ in range(num_samples)] - - self._iteration_number = save_last_index - - return np.array(output) - - def __str__(self): - repres = "Sampler that selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" - repres += "Type : {} \n".format(self._type) - repres += "Current iteration number : {} \n".format( - self._iteration_number) - repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Probability weights : {} \n".format(self._prob_weights) - return repres - class SamplerRandom(Sampler): """ - This class follows the factory design pattern. It is not designed to be instantiated directly but instead can be called from the 6 static methods in the parent Sampler class. + This class follows the factory design pattern. It is not designed to be instantiated directly but instead can be called from static methods in the parent Sampler class. Custom samplers can be created by subclassing the sampler class. Each factory method will instantiate a class to select from the list of indices `{0, 1, …, S-1}, where S is the number of indices.`. @@ -584,7 +583,7 @@ def __init__(self, num_indices, seed=None, replace=True, prob=None, sampling_t if seed is not None: self._seed = seed else: - self._seed = int(time.time()) + self._seed = int(time.time()) self._generator = np.random.RandomState(self._seed) self._sampling_list = None self._replace = replace @@ -634,13 +633,8 @@ def get_samples(self, num_samples=20): return np.array(output) - def __str__(self): - repres = "Sampler that selects from a list of indices {0, 1, …, S-1}, where S is the number of indices. \n" - repres += "Type : {} \n".format(self._type) - repres += "Current iteration number : {} \n".format( - self._iteration_number) - repres += "Number of indices : {} \n".format(self._num_indices) - repres += "Probability weights : {} \n".format(self._prob_weights) + def __str__(self): # TODO: Call the parent string and then append + repres=super().__str__() repres += "Seed : {} \n".format(self._seed) return repres @@ -648,10 +642,10 @@ def __str__(self): class MantidSampler(SamplerRandom): def function(self, iteration_number): """ For each iteration number this function samples from a randomly generated list in order. Every num_indices the list is re-created. For the first aproximately 50*(num_indices -1) iterations the last index is never called. """ - if iteration_number < 50*(self.num_indices -1): - location = iteration_number % (self.num_indices -1) + if iteration_number < 50*(self.num_indices - 1): + location = iteration_number % (self.num_indices - 1) if location == 0: - self._sampling_list = self._generator.choice(self.num_indices-1, self.num_indices -1, p=[ + self._sampling_list = self._generator.choice(self.num_indices-1, self.num_indices - 1, p=[ 1/(self.num_indices-1)]*(self.num_indices-1), replace=self.replace) else: location = iteration_number % self.num_indices @@ -661,6 +655,6 @@ def function(self, iteration_number): out = self._sampling_list[location] return out - def __init__(self, num_indices, seed=None, replace=False, prob=None, sampling_type='Mantid Sampler '): + def __init__(self, num_indices, seed=None, replace=False, prob=None, sampling_type='Mantid Sampler'): super(MantidSampler, self).__init__( num_indices, seed, replace, prob, sampling_type) diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 5c8c1d6929..784ffe3248 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -810,6 +810,7 @@ def test_SPDHG_defaults_and_setters(self): for i in range(self.subsets)]) self.assertListEqual(spdhg.prob_weights, [ 1/self.subsets] * self.subsets) + self.assertEqual(spdhg._sampler._type, 'random_with_replacement') self.assertListEqual( spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, @@ -858,6 +859,23 @@ def test_spdhg_non_default_init(self): spdhg.x.array, self.A.domain_geometry().allocate(1).array) self.assertEqual(spdhg.max_iteration, 1000) self.assertEqual(spdhg.update_objective_interval, 10) + + with self.assertRaises(ValueError): + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[1]*len(self.A), prob_weights=[1/(self.subsets-1)]*( + self.subsets-1)+[0], sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) + + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, prob_weights=[1/(self.subsets-1)]*( + self.subsets-1)+[0], initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) + + self.assertListEqual(spdhg.prob_weights, [1/(self.subsets-1)]*(self.subsets-1)+[0]) + self.assertEqual(spdhg._sampler._type, 'random_with_replacement') + + + def test_spdhg_sampler_gives_too_large_index(self): + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.sequential(20), + initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) + with self.assertRaises(IndexError): + spdhg.run(12) def test_spdhg_deprecated_vargs(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[ @@ -870,9 +888,14 @@ def test_spdhg_deprecated_vargs(self): self.assertListEqual(spdhg.prob_weights, [ 1/(self.subsets-1)]*(self.subsets-1)+[0]) - with self.assertRaises(TypeError): + with self.assertRaises(ValueError): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[1]*len(self.A), prob=[1/(self.subsets-1)]*( self.subsets-1)+[0], sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) + + + with self.assertRaises(ValueError): + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[1]*len(self.A), prob=[1/(self.subsets-1)]*( + self.subsets-1)+[0], prob_weights= [1/(self.subsets-1)]*(self.subsets-1)+[0]) with self.assertRaises(ValueError): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sfdsdf=3, norms=[ From f02f8ff71c26b834643cbf398ba5f0bd9e23b829 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 10 Jan 2024 11:30:07 +0000 Subject: [PATCH 100/115] Prob weights in init and documentation --- .../Python/cil/optimisation/algorithms/SPDHG.py | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 6f6d0a6468..dfefec1299 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -53,16 +53,15 @@ class SPDHG(Algorithm): Initial point for the SPDHG algorithm gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: an instance of a `cil.optimisation.utilities.Sampler` class - Method of selecting the next index for the SPDHG update. If None, random sampling and each index will have probability = 1/number of subsets + sampler: an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting a sample from {1,...,len(operator)}. + Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/len(operator) + **kwargs: prob : list of floats, optional, default=None List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ norms : list of floats precalculated list of norms of the operators. To be deprecated and placed by the `set_norms` functionalist in a BlockOperator. - Example - ------- Example @@ -144,7 +143,7 @@ class SPDHG(Algorithm): ''' def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, - initial=None, sampler=None, **kwargs): + initial=None, sampler=None, prob_weights=None, **kwargs): max_iteration = kwargs.pop('max_iteration', 0) @@ -155,7 +154,7 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, - initial=initial, sampler=sampler, **kwargs) + initial=initial, sampler=sampler, prob_weights=prob_weights, **kwargs) def set_up(self, f, g, operator, sigma=None, tau=None, initial=None, sampler=None, prob_weights=None, **deprecated_kwargs): @@ -177,8 +176,8 @@ def set_up(self, f, g, operator, sigma=None, tau=None, Initial point for the SPDHG algorithm gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting t a sample from {1,...,len(operator)}. - Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/number of subsets + sampler: an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting a sample from {1,...,len(operator)}. + Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/len(operator) prob_weights: (Optional) list of floats of length num_indices that sum to 1. Defaults to [1/len(operator)]*len(operator) Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Note that this should not be passed if the provided sampler has it as an attribute. From d34e3f67800a8d58166cf9dae86ebd3a7d013dd5 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 25 Jan 2024 14:26:19 +0000 Subject: [PATCH 101/115] Tidy up PR --- Wrappers/Python/cil/framework/__init__.py | 1 - .../Python/cil/optimisation/utilities/__init__.py | 1 - .../Python/cil/optimisation/utilities/sampler.py | 13 ++++--------- Wrappers/Python/test/test_sampler.py | 1 - docs/source/optimisation.rst | 4 ++-- 5 files changed, 6 insertions(+), 14 deletions(-) diff --git a/Wrappers/Python/cil/framework/__init__.py b/Wrappers/Python/cil/framework/__init__.py index 437ecd787a..4571441515 100644 --- a/Wrappers/Python/cil/framework/__init__.py +++ b/Wrappers/Python/cil/framework/__init__.py @@ -34,4 +34,3 @@ from .BlockGeometry import BlockGeometry from .framework import DataOrder from .framework import Partitioner - diff --git a/Wrappers/Python/cil/optimisation/utilities/__init__.py b/Wrappers/Python/cil/optimisation/utilities/__init__.py index 36215634d8..be557ed9c3 100644 --- a/Wrappers/Python/cil/optimisation/utilities/__init__.py +++ b/Wrappers/Python/cil/optimisation/utilities/__init__.py @@ -21,4 +21,3 @@ from .sampler import Sampler from .sampler import SamplerRandom - diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index 2f6478d142..de3d97477c 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -18,7 +18,6 @@ import numpy as np import math - from functools import partial import time import numbers @@ -37,7 +36,6 @@ class Sampler(): - Parameters ---------- @@ -93,6 +91,8 @@ class Sampler(): >>> print(sampler.get_samples(16)) [ 0 6 3 9 1 7 4 10 2 8 5 11 0 6 3 9] + + Example -------- This example creates a sampler that outputs sequential indices, starting from 1. @@ -108,7 +108,6 @@ class Sampler(): - Note ----- The optimal choice of sampler depends on the data and the number of calls to the sampler. Note that a low number of calls to a random sampler won't give an even distribution. @@ -118,7 +117,7 @@ class Sampler(): def __init__(self, num_indices, function, sampling_type=None, prob_weights=None): self._type = sampling_type - + if isinstance (num_indices, numbers.Integral): self._num_indices = num_indices else: @@ -227,7 +226,6 @@ def sequential(num_indices): def function(x): return x % num_indices - sampler = Sampler(function=function, num_indices=num_indices, sampling_type='sequential' ) @@ -256,7 +254,7 @@ def _staggered_function(num_indices, stride, iter_number): """ if not isinstance (num_indices, numbers.Integral): raise ValueError('`num_indices` should be an integer. ') - + iter_number_mod = iter_number % num_indices floor = num_indices // stride mod = num_indices % stride @@ -278,7 +276,6 @@ def staggered(num_indices, stride): Parameters ---------- num_indices: int - The sampler will select from a range of indices 0 to num_indices. stride: int @@ -310,7 +307,6 @@ def staggered(num_indices, stride): [ 0 8 16 1 9 2 10 3 11 4] - """ if stride >= num_indices: @@ -358,7 +354,6 @@ def random_with_replacement(num_indices, prob=None, seed=None): [0 1 3 0 0 3 0 0 0 0] """ - sampler = SamplerRandom( num_indices=num_indices, sampling_type='random_with_replacement', diff --git a/Wrappers/Python/test/test_sampler.py b/Wrappers/Python/test/test_sampler.py index f368247b27..40f780b8bf 100644 --- a/Wrappers/Python/test/test_sampler.py +++ b/Wrappers/Python/test/test_sampler.py @@ -32,7 +32,6 @@ class TestSamplers(CCPiTestClass): def example_function(self, iteration_number): - return ((iteration_number+5) % 50) def test_init_Sampler(self): diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 9eb5300a0b..8ef8c9841e 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -373,7 +373,6 @@ Utilities ======= Contains utilities for the CIL optimisation framework. - Samplers -------- Here, we define samplers that select from a list of indices {0, 1, …, N-1} either randomly or by some deterministic pattern. @@ -400,7 +399,6 @@ They will all instantiate a Sampler defined in the following class: :members: - In addition, we provide a random sampling class which is a child class of `cil.optimisation.utilities.sampler` and provides options for sampling with and without replacement: .. autoclass:: cil.optimisation.utilities.SamplerRandom @@ -408,6 +406,8 @@ In addition, we provide a random sampling class which is a child class of `cil. + + Block Framework *************** From e2f3f8060921f1dec0f0d62d6b4fe83ba990fa7a Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 25 Jan 2024 16:25:15 +0000 Subject: [PATCH 102/115] Moved some variables to hidden and updated doc-strings --- .../cil/optimisation/algorithms/SPDHG.py | 200 ++++++++++-------- .../cil/optimisation/utilities/sampler.py | 2 - Wrappers/Python/test/test_algorithms.py | 42 ++-- 3 files changed, 135 insertions(+), 109 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index dfefec1299..5cb0011dcc 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -29,7 +29,7 @@ class SPDHG(Algorithm): - r'''Stochastic Primal Dual Hybrid Gradient + r'''Stochastic Primal Dual Hybrid Gradient (SPDHG) solves separable optimisation problems of the type: Problem: @@ -53,15 +53,15 @@ class SPDHG(Algorithm): Initial point for the SPDHG algorithm gamma : float parameter controlling the trade-off between the primal and dual step sizes - sampler: an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting a sample from {1,...,len(operator)}. - Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/len(operator) - + sampler: an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting an integer from {1,...,len(operator)}. + Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/len(operator) + **kwargs: prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated/ + List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated. norms : list of floats - precalculated list of norms of the operators. To be deprecated and placed by the `set_norms` functionalist in a BlockOperator. + Precalculated list of norms of the operators. To be deprecated and placed by the `set_norms` functionalist in a BlockOperator. Example @@ -84,13 +84,13 @@ class SPDHG(Algorithm): >>> >>> F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) for i in range(subsets)]) - + >>> alpha = 0.025 >>> G = alpha * TotalVariation() >>> spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.sequential(len(A)), initial=A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) >>> spdhg.run(100) - + Example ------- Further examples of usage see the [CIL demos.](https://github.com/vais-ral/CIL-Demos/blob/master/Tomography/Simulated/Single%20Channel/PDHG_vs_SPDHG.py) @@ -100,11 +100,10 @@ class SPDHG(Algorithm): When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: - + .. math:: \sigma_i=0.99 / (\|K_i\|**2) - and `tau` is set as per case 2 - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula @@ -126,7 +125,7 @@ class SPDHG(Algorithm): Convergence is guaranteed provided that [2, eq. (12)]: .. math:: - + \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i References @@ -146,20 +145,20 @@ def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=None, sampler=None, prob_weights=None, **kwargs): max_iteration = kwargs.pop('max_iteration', 0) - - print_interval= kwargs.pop('print_interval', None) - log_file= kwargs.pop('log_file', None) + + print_interval = kwargs.pop('print_interval', None) + log_file = kwargs.pop('log_file', None) update_objective_interval = kwargs.pop('update_objective_interval', 1) super(SPDHG, self).__init__(max_iteration=max_iteration, update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, initial=initial, sampler=sampler, prob_weights=prob_weights, **kwargs) - + def set_up(self, f, g, operator, sigma=None, tau=None, initial=None, sampler=None, prob_weights=None, **deprecated_kwargs): '''set-up of the algorithm - + Parameters ---------- f : BlockFunction @@ -178,7 +177,7 @@ def set_up(self, f, g, operator, sigma=None, tau=None, parameter controlling the trade-off between the primal and dual step sizes sampler: an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting a sample from {1,...,len(operator)}. Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/len(operator) - prob_weights: (Optional) list of floats of length num_indices that sum to 1. Defaults to [1/len(operator)]*len(operator) + prob_weights: list of floats of length num_indices that sum to 1. Defaults to [1/len(operator)]*len(operator) Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Note that this should not be passed if the provided sampler has it as an attribute. ''' @@ -188,31 +187,31 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self.f = f self.g = g self.operator = operator - + if not isinstance(operator, BlockOperator): raise TypeError("operator should be a BlockOperator") - - self.ndual_subsets = len(self.operator) + + self._ndual_subsets = len(self.operator) self._sampler = sampler - - self.prob_weights=getattr(self._sampler, 'prob_weights', None) - if prob_weights is not None: - if self.prob_weights is None: - self.prob_weights = prob_weights + + self._prob_weights = getattr(self._sampler, 'prob_weights', None) + if prob_weights is not None: + if self._prob_weights is None: + self._prob_weights = prob_weights else: - raise ValueError( - ' You passed a `prob_weights`argument and a sampler with attribute `prob_weights`, please remove the `prob_weights` argument.') - + raise ValueError( + ' You passed a `prob_weights` argument and a sampler with attribute `prob_weights`, please remove the `prob_weights` argument.') + self._deprecated_kwargs(deprecated_kwargs) - - if self.prob_weights is None: - self.prob_weights = [1/self.ndual_subsets]*self.ndual_subsets - + + if self._prob_weights is None: + self._prob_weights = [1/self._ndual_subsets]*self._ndual_subsets + if self._sampler is None: - self._sampler = Sampler.random_with_replacement(len(operator), prob=self.prob_weights) - - self.norms = operator.get_norms_as_list() + self._sampler = Sampler.random_with_replacement( + len(operator), prob=self._prob_weights) + self._norms = operator.get_norms_as_list() self.set_step_sizes(sigma=sigma, tau=tau) @@ -222,24 +221,24 @@ def set_up(self, f, g, operator, sigma=None, tau=None, else: self.x = initial.copy() - self.x_tmp = self.operator.domain_geometry().allocate(0) + self._x_tmp = self.operator.domain_geometry().allocate(0) # initialize dual variable to 0 - self.y_old = operator.range_geometry().allocate(0) + self._y_old = operator.range_geometry().allocate(0) # initialize variable z corresponding to back-projected dual variable - self.z = operator.domain_geometry().allocate(0) - self.zbar = operator.domain_geometry().allocate(0) + self._z = operator.domain_geometry().allocate(0) + self._zbar = operator.domain_geometry().allocate(0) # relaxation parameter - self.theta = 1 + self._theta = 1 + self.configured = True logging.info("{} configured".format(self.__class__.__name__, )) - def _deprecated_kwargs(self, deprecated_kwargs): """ Handle deprecated keyword arguments for backward compatibility. - + Parameters ---------- deprecated_kwargs : dict @@ -251,23 +250,21 @@ def _deprecated_kwargs(self, deprecated_kwargs): """ norms = deprecated_kwargs.pop('norms', None) prob = deprecated_kwargs.pop('prob', None) - + if prob is not None: - if self.prob_weights is None: + if self._prob_weights is None: warnings.warn('`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). To pass probabilites to the calculation for `sigma` and `tau` please use `prob_weights`. ') - self.prob_weights=prob + self._prob_weights = prob else: - - raise ValueError( + + raise ValueError( '`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. You passed a `prob` argument, and either a `prob_weights` argument or a sampler with a `prob_weights` property. Please give only one of the three. ') - if norms is not None: self.operator.set_norms(norms) warnings.warn( ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') - if deprecated_kwargs: raise ValueError("Additional keyword arguments passed but not used: {}".format( deprecated_kwargs)) @@ -315,14 +312,14 @@ def set_step_sizes_from_ratio(self, gamma=1.0, rho=0.99): raise ValueError( "We currently only support scalar values of gamma") - self._sigma = [gamma * rho / ni for ni in self.norms] + self._sigma = [gamma * rho / ni for ni in self._norms] values = [pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)] + si in zip(self._prob_weights, self._norms, self._sigma)] self._tau = min([value for value in values if value > 1e-8]) self._tau *= (rho / gamma) def set_step_sizes(self, sigma=None, tau=None): - r""" Sets sigma step-sizes for the SPDHG algorithm. The step sizes can be either scalar or array-objects. + r""" Sets sigma and tau step-sizes for the SPDHG algorithm after the initial set-up. The step sizes can be either scalar or array-objects. Parameters ---------- @@ -338,7 +335,7 @@ def set_step_sizes(self, sigma=None, tau=None): When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: - + .. math:: \sigma_i=0.99 / (\|K_i\|**2) @@ -361,61 +358,72 @@ def set_step_sizes(self, sigma=None, tau=None): gamma = 1. rho = .99 if sigma is not None: - if len(sigma) == self.ndual_subsets: - if all(isinstance(x, Number) and x > 0 for x in sigma): - pass + if len(sigma) == self._ndual_subsets: + if all(isinstance(x, Number) and x > 0 for x in sigma): + pass else: raise ValueError( - "Sigma expected to be a positive number.") - + "Sigma expected to be a positive number.") + else: raise ValueError( "Please pass a list of floats to sigma with the same number of entries as number of operators") self._sigma = sigma elif tau is None: - self._sigma = [gamma * rho / ni for ni in self.norms] + self._sigma = [gamma * rho / ni for ni in self._norms] else: self._sigma = [ - gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self.norms, self.prob_weights)] + gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self._norms, self._prob_weights)] if tau is None: values = [pi / (si * ni**2) for pi, ni, - si in zip(self.prob_weights, self.norms, self._sigma)] + si in zip(self._prob_weights, self._norms, self._sigma)] self._tau = min([value for value in values if value > 1e-8]) self._tau *= (rho / gamma) else: - if isinstance(tau, Number) and tau > 0: + if isinstance(tau, Number) and tau > 0: pass else: raise ValueError( - "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) - + "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) + self._tau = tau def check_convergence(self): - """ Check whether convergence criterion for SPDHG is satisfied with scalar values of tau and sigma + """ Checks whether convergence criterion for SPDHG is satisfied with the current scalar values of tau and sigma Returns ------- Boolean - True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. N.B Convergence criterion currently can only be checked for scalar values of tau. + True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. + + Note + ----- + Convergence criterion currently can only be checked for scalar values of tau. + + Note + ---- + This checks the convergence criterion. Numerical errors may mean some sigma and tau values that satisfy the convergence criterion may not converge. + Alternatively, step sizes outside the convergence criterion may still allow (fast) convergence. """ - for i in range(self.ndual_subsets): - if isinstance(self.tau, Number) and isinstance(self._sigma[i], Number): - if self._sigma[i] * self._tau * self.norms[i]**2 > self.prob_weights[i]: + for i in range(self._ndual_subsets): + if isinstance(self._tau, Number) and isinstance(self._sigma[i], Number): + if self._sigma[i] * self._tau * self._norms[i]**2 > self._prob_weights[i]: return False return True else: return False - def update(self): + """ Runs one iteration of SPDHG + + """ # Gradient descent for the primal variable # x_tmp = x - tau * zbar - self.x.sapyb(1., self.zbar, -self.tau, out=self.x_tmp) + self.x.sapyb(1., self._zbar, -self._tau, out=self._x_tmp) - self.g.proximal(self.x_tmp, self.tau, out=self.x) + self.g.proximal(self._x_tmp, self._tau, out=self.x) # Choose subset i = next(self._sampler) @@ -425,29 +433,30 @@ def update(self): try: y_k = self.operator[i].direct(self.x) except IndexError: - raise IndexError('The sampler has outputted an index larger than the number of operators to sample from. Please ensure your sampler samples from {1,2,...,len(operator)} only.') + raise IndexError( + 'The sampler has outputted an index larger than the number of operators to sample from. Please ensure your sampler samples from {1,2,...,len(operator)} only.') - y_k.sapyb(self.sigma[i], self.y_old[i], 1., out=y_k) + y_k.sapyb(self._sigma[i], self._y_old[i], 1., out=y_k) - y_k = self.f[i].proximal_conjugate(y_k, self.sigma[i]) + y_k = self.f[i].proximal_conjugate(y_k, self._sigma[i]) # Back-project # x_tmp = K[i]^*(y_k - y_old[i]) - y_k.subtract(self.y_old[i], out=self.y_old[i]) + y_k.subtract(self._y_old[i], out=self._y_old[i]) - self.operator[i].adjoint(self.y_old[i], out=self.x_tmp) + self.operator[i].adjoint(self._y_old[i], out=self._x_tmp) # Update backprojected dual variable and extrapolate # zbar = z + (1 + theta/p[i]) x_tmp # z = z + x_tmp - self.z.add(self.x_tmp, out=self.z) + self._z.add(self._x_tmp, out=self._z) # zbar = z + (theta/p[i]) * x_tmp - self.z.sapyb(1., self.x_tmp, self.theta / - self.prob_weights[i], out=self.zbar) + self._z.sapyb(1., self._x_tmp, self._theta / + self._prob_weights[i], out=self._zbar) # save previous iteration - self.save_previous_iteration(i, y_k) + self._save_previous_iteration(i, y_k) def update_objective(self): # p1 = self.f(self.operator.direct(self.x)) + self.g(self.x) @@ -456,8 +465,8 @@ def update_objective(self): p1 += self.f[i](op.direct(self.x)) p1 += self.g(self.x) - d1 = - self.f.convex_conjugate(self.y_old) - tmp = self.operator.adjoint(self.y_old) + d1 = - self.f.convex_conjugate(self._y_old) + tmp = self.operator.adjoint(self._y_old) tmp *= -1 d1 -= self.g.convex_conjugate(tmp) @@ -465,16 +474,35 @@ def update_objective(self): @property def objective(self): - '''alias of loss''' + '''The saved primal objectives. + Returns + ------- + list + The saved primal objectives from `update_objective`. The number of saved values depends on the `update_objective_interval` kwarg. + ''' return [x[0] for x in self.loss] @property def dual_objective(self): + '''The saved dual objectives. + Returns + ------- + list + The saved dual objectives from `update_objective`. The number of saved values depends on the `update_objective_interval` kwarg. + ''' return [x[1] for x in self.loss] @property def primal_dual_gap(self): + '''The saved primal-dual gap. + Returns + ------- + list + The saved primal dual gap from `update_objective`. The number of saved values depends on the `update_objective_interval` kwarg. + ''' return [x[2] for x in self.loss] - def save_previous_iteration(self, index, y_current): - self.y_old[index].fill(y_current) + def _save_previous_iteration(self, index, y_current): + ''' Internal function used to save the previous iteration + ''' + self._y_old[index].fill(y_current) diff --git a/Wrappers/Python/cil/optimisation/utilities/sampler.py b/Wrappers/Python/cil/optimisation/utilities/sampler.py index de3d97477c..d5479f0bd5 100644 --- a/Wrappers/Python/cil/optimisation/utilities/sampler.py +++ b/Wrappers/Python/cil/optimisation/utilities/sampler.py @@ -664,7 +664,6 @@ def __init__(self, num_indices, seed=None, replace=True, prob=None, sampling_t self._sampling_list = None self._replace = replace - super(SamplerRandom, self).__init__(num_indices, self._function, sampling_type=sampling_type, prob_weights=prob) @@ -718,4 +717,3 @@ def __str__(self): repres = super().__str__() repres += "Seed : {} \n".format(self._seed) return repres - diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 784ffe3248..5ca9767168 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -806,17 +806,17 @@ def test_SPDHG_defaults_and_setters(self): rho = .99 spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) - self.assertListEqual(spdhg.norms, [self.A.get_item(i, 0).norm() + self.assertListEqual(spdhg._norms, [self.A.get_item(i, 0).norm() for i in range(self.subsets)]) - self.assertListEqual(spdhg.prob_weights, [ + self.assertListEqual(spdhg._prob_weights, [ 1/self.subsets] * self.subsets) self.assertEqual(spdhg._sampler._type, 'random_with_replacement') self.assertListEqual( - spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) + spdhg.sigma, [gamma * rho / ni for ni in spdhg._norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) + si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])*(rho / gamma)) self.assertNumpyArrayEqual( - spdhg.x.array, self.A.domain_geometry().allocate(0).array) + spdhg.x.as_array(), self.A.domain_geometry().allocate(0).as_array()) self.assertEqual(spdhg.max_iteration, 0) self.assertEqual(spdhg.update_objective_interval, 1) @@ -824,17 +824,17 @@ def test_SPDHG_defaults_and_setters(self): rho = 5.6 spdhg.set_step_sizes_from_ratio(gamma, rho) self.assertListEqual( - spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) + spdhg.sigma, [gamma * rho / ni for ni in spdhg._norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) + si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])*(rho / gamma)) gamma = 1. rho = .99 spdhg.set_step_sizes() self.assertListEqual( - spdhg.sigma, [gamma * rho / ni for ni in spdhg.norms]) + spdhg.sigma, [gamma * rho / ni for ni in spdhg._norms]) self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])*(rho / gamma)) + si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])*(rho / gamma)) spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) self.assertListEqual(spdhg.sigma, [1]*self.subsets) @@ -843,31 +843,31 @@ def test_SPDHG_defaults_and_setters(self): spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, min([(pi / (si * ni**2))*(rho / gamma) for pi, ni, - si in zip(spdhg.prob_weights, spdhg.norms, spdhg.sigma)])) + si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])) spdhg.set_step_sizes(sigma=None, tau=100) self.assertListEqual(spdhg.sigma, [ - gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg.norms, spdhg.prob_weights)]) + gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg._norms, spdhg._prob_weights)]) self.assertEqual(spdhg.tau, 100) def test_spdhg_non_default_init(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.)), initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) - self.assertListEqual(spdhg.prob_weights, list(np.arange(1, 11)/55.)) + self.assertListEqual(spdhg._prob_weights, list(np.arange(1, 11)/55.)) self.assertNumpyArrayEqual( - spdhg.x.array, self.A.domain_geometry().allocate(1).array) + spdhg.x.as_array(), self.A.domain_geometry().allocate(1).as_array()) self.assertEqual(spdhg.max_iteration, 1000) self.assertEqual(spdhg.update_objective_interval, 10) with self.assertRaises(ValueError): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[1]*len(self.A), prob_weights=[1/(self.subsets-1)]*( + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, _norms=[1]*len(self.A), prob_weights=[1/(self.subsets-1)]*( self.subsets-1)+[0], sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, prob_weights=[1/(self.subsets-1)]*( self.subsets-1)+[0], initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) - self.assertListEqual(spdhg.prob_weights, [1/(self.subsets-1)]*(self.subsets-1)+[0]) + self.assertListEqual(spdhg._prob_weights, [1/(self.subsets-1)]*(self.subsets-1)+[0]) self.assertEqual(spdhg._sampler._type, 'random_with_replacement') @@ -882,23 +882,23 @@ def test_spdhg_deprecated_vargs(self): 1]*len(self.A), prob=[1/(self.subsets-1)]*(self.subsets-1)+[0]) self.assertListEqual(self.A.get_norms_as_list(), [1]*len(self.A)) - self.assertListEqual(spdhg.norms, [1]*len(self.A)) + self.assertListEqual(spdhg._norms, [1]*len(self.A)) self.assertListEqual(spdhg._sampler.prob_weights, [ 1/(self.subsets-1)]*(self.subsets-1)+[0]) - self.assertListEqual(spdhg.prob_weights, [ + self.assertListEqual(spdhg._prob_weights, [ 1/(self.subsets-1)]*(self.subsets-1)+[0]) with self.assertRaises(ValueError): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[1]*len(self.A), prob=[1/(self.subsets-1)]*( + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, _norms=[1]*len(self.A), prob=[1/(self.subsets-1)]*( self.subsets-1)+[0], sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) with self.assertRaises(ValueError): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, norms=[1]*len(self.A), prob=[1/(self.subsets-1)]*( + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, _norms=[1]*len(self.A), prob=[1/(self.subsets-1)]*( self.subsets-1)+[0], prob_weights= [1/(self.subsets-1)]*(self.subsets-1)+[0]) with self.assertRaises(ValueError): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sfdsdf=3, norms=[ + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sfdsdf=3, _norms=[ 1]*len(self.A), sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) @@ -906,7 +906,7 @@ def test_spdhg_set_norms(self): self.A2.set_norms([1]*len(self.A2)) spdhg = SPDHG(f=self.F, g=self.G, operator=self.A2) - self.assertListEqual(spdhg.norms, [1]*len(self.A2)) + self.assertListEqual(spdhg._norms, [1]*len(self.A2)) def test_spdhg_check_convergence(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) From 716a793b6c59b2fb8b2c665b29630c8959bdaeec Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 30 Jan 2024 16:08:19 +0000 Subject: [PATCH 103/115] Update docs --- docs/source/optimisation.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/source/optimisation.rst b/docs/source/optimisation.rst index 8ef8c9841e..fc1186a56f 100644 --- a/docs/source/optimisation.rst +++ b/docs/source/optimisation.rst @@ -123,7 +123,7 @@ LADMM SPDHG ----- .. autoclass:: cil.optimisation.algorithms.SPDHG - :members: + :members: update, set_step_sizes, set_step_sizes_from_ratio, update_objective :inherited-members: run, update_objective_interval, max_iteration From e21d4504763ffbba2049bf4eb2f4a86d7bfa4819 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 9 Jul 2024 10:31:21 +0000 Subject: [PATCH 104/115] Fixes #1860 --- .../cil/optimisation/algorithms/SPDHG.py | 20 ++--- Wrappers/Python/test/test_algorithms.py | 89 +++++++++---------- 2 files changed, 49 insertions(+), 60 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 132518f485..f4521f2215 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -24,6 +24,7 @@ from cil.optimisation.utilities import Sampler from numbers import Number import numpy as np +import warnings log = logging.getLogger(__name__) @@ -147,13 +148,9 @@ class SPDHG(Algorithm): def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=None, sampler=None, prob_weights=None, **kwargs): - max_iteration = kwargs.pop('max_iteration', 0) - print_interval = kwargs.pop('print_interval', None) - log_file = kwargs.pop('log_file', None) update_objective_interval = kwargs.pop('update_objective_interval', 1) - super(SPDHG, self).__init__(max_iteration=max_iteration, - update_objective_interval=update_objective_interval, log_file=log_file, print_interval=print_interval) + super(SPDHG, self).__init__(update_objective_interval=update_objective_interval) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, initial=initial, sampler=sampler, prob_weights=prob_weights, **kwargs) @@ -297,7 +294,7 @@ def set_step_sizes_from_ratio(self, gamma=1.0, rho=0.99): The step sizes `sigma` and `tau` are set using the equations: .. math:: \sigma_i=\gamma\rho / (\|K_i\|**2)\\ - \tau = (\rho/\gamma)\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + \tau = \min_i([p_i / (\sigma_i * \|K_i\|**2) ]) """ if isinstance(gamma, Number): @@ -318,10 +315,9 @@ def set_step_sizes_from_ratio(self, gamma=1.0, rho=0.99): "We currently only support scalar values of gamma") self._sigma = [gamma * rho / ni for ni in self._norms] - values = [pi / (si * ni**2) for pi, ni, + values = [rho*pi / (si * ni**2) for pi, ni, si in zip(self._prob_weights, self._norms, self._sigma)] self._tau = min([value for value in values if value > 1e-8]) - self._tau *= (rho / gamma) def set_step_sizes(self, sigma=None, tau=None): r""" Sets sigma and tau step-sizes for the SPDHG algorithm after the initial set-up. The step sizes can be either scalar or array-objects. @@ -376,16 +372,16 @@ def set_step_sizes(self, sigma=None, tau=None): self._sigma = sigma elif tau is None: - self._sigma = [gamma * rho / ni for ni in self._norms] + self._sigma = [rho / ni for ni in self._norms] else: self._sigma = [ - gamma * rho*pi / (tau*ni**2) for ni, pi in zip(self._norms, self._prob_weights)] + rho*pi / (tau*ni**2) for ni, pi in zip(self._norms, self._prob_weights)] if tau is None: - values = [pi / (si * ni**2) for pi, ni, + values = [rho*pi / (si * ni**2) for pi, ni, si in zip(self._prob_weights, self._norms, self._sigma)] self._tau = min([value for value in values if value > 1e-8]) - self._tau *= (rho / gamma) + else: if isinstance(tau, Number) and tau > 0: pass diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 66c1074545..3a5c8396a1 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -70,7 +70,7 @@ from utils import has_astra log = logging.getLogger(__name__) -initialise_tests() + if has_astra: from cil.plugins.astra import ProjectionOperator @@ -1038,8 +1038,6 @@ def setUp(self): data = dataexample.SIMPLE_PHANTOM_2D.get(size=(20, 20)) self.subsets = 10 - @unittest.skipUnless(has_astra, "cil-astra not available") - def test_SPDHG_vs_PDHG_implicit(self): data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128, 128)) ig = data.geometry @@ -1079,12 +1077,11 @@ def test_SPDHG_defaults_and_setters(self): 1/self.subsets] * self.subsets) self.assertEqual(spdhg._sampler._type, 'random_with_replacement') self.assertListEqual( - spdhg.sigma, [gamma * rho / ni for ni in spdhg._norms]) - self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])*(rho / gamma)) + spdhg.sigma, [rho / ni for ni in spdhg._norms]) + self.assertEqual(spdhg.tau, min([rho*pi / (si * ni**2) for pi, ni, + si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])) self.assertNumpyArrayEqual( spdhg.x.as_array(), self.A.domain_geometry().allocate(0).as_array()) - self.assertEqual(spdhg.max_iteration, 0) self.assertEqual(spdhg.update_objective_interval, 1) gamma = 3.7 @@ -1092,16 +1089,16 @@ def test_SPDHG_defaults_and_setters(self): spdhg.set_step_sizes_from_ratio(gamma, rho) self.assertListEqual( spdhg.sigma, [gamma * rho / ni for ni in spdhg._norms]) - self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])*(rho / gamma)) + self.assertEqual(spdhg.tau, min([pi*rho / (si * ni**2) for pi, ni, + si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])) gamma = 1. rho = .99 spdhg.set_step_sizes() self.assertListEqual( - spdhg.sigma, [gamma * rho / ni for ni in spdhg._norms]) - self.assertEqual(spdhg.tau, min([pi / (si * ni**2) for pi, ni, - si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])*(rho / gamma)) + spdhg.sigma, [rho / ni for ni in spdhg._norms]) + self.assertEqual(spdhg.tau, min([rho*pi / (si * ni**2) for pi, ni, + si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])) spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) self.assertListEqual(spdhg.sigma, [1]*self.subsets) @@ -1109,7 +1106,7 @@ def test_SPDHG_defaults_and_setters(self): spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) self.assertListEqual(spdhg.sigma, [1]*self.subsets) - self.assertEqual(spdhg.tau, min([(pi / (si * ni**2))*(rho / gamma) for pi, ni, + self.assertEqual(spdhg.tau, min([(rho*pi / (si * ni**2)) for pi, ni, si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])) spdhg.set_step_sizes(sigma=None, tau=100) @@ -1119,12 +1116,11 @@ def test_SPDHG_defaults_and_setters(self): def test_spdhg_non_default_init(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.)), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) + initial=self.A.domain_geometry().allocate(1), update_objective_interval=10) self.assertListEqual(spdhg._prob_weights, list(np.arange(1, 11)/55.)) self.assertNumpyArrayEqual( spdhg.x.as_array(), self.A.domain_geometry().allocate(1).as_array()) - self.assertEqual(spdhg.max_iteration, 1000) self.assertEqual(spdhg.update_objective_interval, 10) with self.assertRaises(ValueError): @@ -1132,7 +1128,7 @@ def test_spdhg_non_default_init(self): self.subsets-1)+[0], sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, prob_weights=[1/(self.subsets-1)]*( - self.subsets-1)+[0], initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) + self.subsets-1)+[0], initial=self.A.domain_geometry().allocate(1), update_objective_interval=10) self.assertListEqual(spdhg._prob_weights, [1/(self.subsets-1)]*(self.subsets-1)+[0]) self.assertEqual(spdhg._sampler._type, 'random_with_replacement') @@ -1140,7 +1136,7 @@ def test_spdhg_non_default_init(self): def test_spdhg_sampler_gives_too_large_index(self): spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.sequential(20), - initial=self.A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) + initial=self.A.domain_geometry().allocate(1), update_objective_interval=10) with self.assertRaises(IndexError): spdhg.run(12) @@ -1199,42 +1195,42 @@ def test_spdhg_check_convergence(self): spdhg.set_step_sizes(sigma=None, tau=100) self.assertTrue(spdhg.check_convergence()) - def test_SPDHG_num_subsets_1(self): - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(10, 10)) + # def test_SPDHG_num_subsets_1(self): TODO: fix this! + # data = dataexample.SIMPLE_PHANTOM_2D.get(size=(10, 10)) - subsets = 1 + # subsets = 1 - ig = data.geometry - ig.voxel_size_x = 0.1 - ig.voxel_size_y = 0.1 + # ig = data.geometry + # ig.voxel_size_x = 0.1 + # ig.voxel_size_y = 0.1 - detectors = ig.shape[0] - angles = np.linspace(0, np.pi, 90) - ag = AcquisitionGeometry.create_Parallel2D().set_angles( - angles, angle_unit='radian').set_panel(detectors, 0.1) - # Select device - dev = 'cpu' + # detectors = ig.shape[0] + # angles = np.linspace(0, np.pi, 90) + # ag = AcquisitionGeometry.create_Parallel2D().set_angles( + # angles, angle_unit='radian').set_panel(detectors, 0.1) + # # Select device + # dev = 'cpu' - Aop = ProjectionOperator(ig, ag, dev) + # Aop = ProjectionOperator(ig, ag, dev) - sin = Aop.direct(data) - partitioned_data = sin.partition(subsets, 'sequential') - A = BlockOperator( - *[IdentityOperator(partitioned_data[i].geometry) for i in range(subsets)]) + # sin = Aop.direct(data) + # partitioned_data = sin.partition(subsets, 'sequential') + # A = BlockOperator( + # *[IdentityOperator(partitioned_data[i].geometry) for i in range(subsets)]) - # block function - F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) - for i in range(subsets)]) - alpha = 0.025 - G = alpha * FGP_TV() + # # block function + # F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) + # for i in range(subsets)]) + # alpha = 0.025 + # G = alpha * FGP_TV() - spdhg = SPDHG(f=F, g=G, operator=A, max_iteration=10, update_objective_interval=10, print_interval=10, log_file=None) + # spdhg = SPDHG(f=F, g=G, operator=A, update_objective_interval=10) - spdhg.run(7) - pdhg = PDHG(f=F, g=G, operator=A, max_iteration=10, update_objective_interval=10, print_interval=10, log_file=None) + # spdhg.run(7) + # pdhg = PDHG(f=F, g=G, operator=A, update_objective_interval=10) - pdhg.run(7) - self.assertNumpyArrayAlmostEqual(pdhg.solution.as_array(), spdhg.solution.as_array(), decimal=3) + # pdhg.run(7) + # self.assertNumpyArrayAlmostEqual(pdhg.solution.as_array(), spdhg.solution.as_array(), decimal=3) @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): @@ -1290,7 +1286,6 @@ def test_SPDHG_vs_PDHG_implicit(self): # Setup and run the PDHG algorithm pdhg = PDHG(f=f, g=g, operator=operator, tau=tau, sigma=sigma, - max_iteration=80, update_objective_interval=1000) pdhg.run(1000, verbose=0) @@ -1325,8 +1320,7 @@ def test_SPDHG_vs_PDHG_implicit(self): G = alpha * TotalVariation(50, 1e-4, lower=0, warm_start=True) prob = [1/len(A)]*len(A) - spdhg = SPDHG(f=F, g=G, operator=A, - max_iteration=250, sampler=Sampler.random_with_replacement(len(A), seed=2), + spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.random_with_replacement(len(A), seed=2), update_objective_interval=1000) spdhg.run(1000, verbose=0) @@ -1411,7 +1405,6 @@ def test_SPDHG_vs_PDHG_explicit(self): prob = [1/(2*subsets)]*(len(A)-1) + [1/2] spdhg = SPDHG(f=F, g=G, operator=A, - max_iteration=300, update_objective_interval=300, sampler=Sampler.random_with_replacement(len(A), prob=prob, seed=10)) spdhg.run(1000, verbose=0) From d7bc4dc226fda5902d37621146775a8f697b2677 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 11 Jul 2024 14:13:13 +0000 Subject: [PATCH 105/115] Updated documentation and examples --- .../cil/optimisation/algorithms/SPDHG.py | 133 ++++++++---------- 1 file changed, 56 insertions(+), 77 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index f4521f2215..62710eac9e 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -23,22 +23,16 @@ import logging from cil.optimisation.utilities import Sampler from numbers import Number -import numpy as np import warnings - log = logging.getLogger(__name__) class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient (SPDHG) solves separable optimisation problems of the type: - Problem: - - - .. math:: - - \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) + Problem: + .. math:: \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) Parameters ---------- @@ -54,13 +48,16 @@ class SPDHG(Algorithm): List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - gamma : float - parameter controlling the trade-off between the primal and dual step sizes - sampler: an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting an integer from {1,...,len(operator)}. - Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/len(operator) + gamma : float, optional + Parameter controlling the trade-off between the primal and dual step sizes + sampler: optional, an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting an integer from {1,...,len(operator)}. + Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/len(operator) + prob_weights: optional, list of floats of length num_indices that sum to 1. Defaults to [1/len(operator)]*len(operator) + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Note that this should not be passed if the provided sampler has it as an attribute. - **kwargs: + **kwargs + --------- prob : list of floats, optional, default=None List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated. norms : list of floats @@ -69,29 +66,22 @@ class SPDHG(Algorithm): Example ------- - >>> data = dataexample.SIMPLE_PHANTOM_2D.get(size=(20, 20)) - >>> subsets = 10 - >>> ig = data.geometry - >>> ig.voxel_size_x = 0.1 - >>> ig.voxel_size_y = 0.1 - >>> - >>> detectors = ig.shape[0] - >>> angles = np.linspace(0, np.pi, 90) - >>> ag = AcquisitionGeometry.create_Parallel2D().set_angles(angles, angle_unit='radian').set_panel(detectors, 0.1) - >>> - >>> Aop = ProjectionOperator(ig, ag, 'cpu') - >>> - >>> sin = Aop.direct(data) - >>> partitioned_data = sin.partition(subsets, 'sequential') - >>> A = BlockOperator(*[ProjectionOperator(ig. partitioned_data[i].geometry, 'cpu') for i in range(subsets)]) - >>> - >>> F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) - for i in range(subsets)]) + >>> data = dataexample.SIMULATED_PARALLEL_BEAM_DATA.get() + >>> data.reorder('astra') + >>> data = data.get_slice(vertical='centre') + >>> ig = ag.get_ImageGeometry() + + >>> data_partitioned = data.partition(num_batches=10, mode='staggered') + >>> A_partitioned = ProjectionOperator(ig, data_partitioned.geometry, device = "cpu") + + + >>> F = BlockFunction(*[L2NormSquared(b=data_partitioned[i]) + for i in range(10)]) >>> alpha = 0.025 >>> G = alpha * TotalVariation() - >>> spdhg = SPDHG(f=F, g=G, operator=A, sampler=Sampler.sequential(len(A)), - initial=A.domain_geometry().allocate(1), max_iteration=1000, update_objective_interval=10) + >>> spdhg = SPDHG(f=F, g=G, operator=A_partitioned, sampler=Sampler.sequential(len(A)), + initial=A.domain_geometry().allocate(1), update_objective_interval=10) >>> spdhg.run(100) @@ -105,20 +95,17 @@ class SPDHG(Algorithm): - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: - .. math:: - \sigma_i=0.99 / (\|K_i\|**2) + .. math:: \sigma_i=0.99 / (\|K_i\|**2) - and `tau` is set as per case 2 + and `tau` is set as per case 2 - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula - .. math:: - \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + .. math:: \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula - .. math:: - \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) + .. math:: \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - Case 4: Both `sigma` and `tau` are provided. @@ -128,9 +115,7 @@ class SPDHG(Algorithm): Convergence is guaranteed provided that [2, eq. (12)]: - .. math:: - - \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i + .. math:: \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i References ---------- @@ -138,11 +123,11 @@ class SPDHG(Algorithm): [1]"Stochastic primal-dual hybrid gradient algorithm with arbitrary sampling and imaging applications", Chambolle, Antonin, Matthias J. Ehrhardt, Peter Richtárik, and Carola-Bibiane Schonlieb, - SIAM Journal on Optimization 28, no. 4 (2018): 2783-2808. + SIAM Journal on Optimization 28, no. 4 (2018): 2783-2808. https://doi.org/10.1137/17M1134834 [2]"Faster PET reconstruction with non-smooth priors by randomization and preconditioning", Matthias J Ehrhardt, Pawel Markiewicz and Carola-Bibiane Schönlieb, - Physics in Medicine & Biology, Volume 64, Number 22, 2019. + Physics in Medicine & Biology, Volume 64, Number 22, 2019. https://doi.org/10.1088/1361-6560/ab3d07 ''' def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, @@ -159,7 +144,7 @@ def set_up(self, f, g, operator, sigma=None, tau=None, initial=None, sampler=None, prob_weights=None, **deprecated_kwargs): '''set-up of the algorithm - + Parameters ---------- f : BlockFunction @@ -174,11 +159,11 @@ def set_up(self, f, g, operator, sigma=None, tau=None, List of Step size parameters for Dual problem initial : DataContainer, optional, default=None Initial point for the SPDHG algorithm - gamma : float + gamma : float, optional parameter controlling the trade-off between the primal and dual step sizes - sampler: an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting a sample from {1,...,len(operator)}. + sampler: optional, an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting a sample from {1,...,len(operator)}. Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/len(operator) - prob_weights: list of floats of length num_indices that sum to 1. Defaults to [1/len(operator)]*len(operator) + prob_weights: optional, list of floats of length num_indices that sum to 1. Defaults to [1/len(operator)]*len(operator) Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Note that this should not be passed if the provided sampler has it as an attribute. ''' @@ -222,7 +207,6 @@ def set_up(self, f, g, operator, sigma=None, tau=None, else: self.x = initial.copy() - self._x_tmp = self.operator.domain_geometry().allocate(0) # initialize dual variable to 0 @@ -282,6 +266,12 @@ def tau(self): def set_step_sizes_from_ratio(self, gamma=1.0, rho=0.99): r""" Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. + The step sizes `sigma` and `tau` are set using the equations: + .. math:: \sigma_i=\gamma\rho / (\|K_i\|**2)\\ + + .. math:: \tau = \rho\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + + Parameters ---------- gamma : Positive float @@ -289,13 +279,8 @@ def set_step_sizes_from_ratio(self, gamma=1.0, rho=0.99): rho : Positive float parameter controlling the size of the product :math: \sigma\tau :math: - Note - ----- - The step sizes `sigma` and `tau` are set using the equations: - .. math:: - \sigma_i=\gamma\rho / (\|K_i\|**2)\\ - \tau = \min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - + + """ if isinstance(gamma, Number): if gamma <= 0: @@ -322,38 +307,32 @@ def set_step_sizes_from_ratio(self, gamma=1.0, rho=0.99): def set_step_sizes(self, sigma=None, tau=None): r""" Sets sigma and tau step-sizes for the SPDHG algorithm after the initial set-up. The step sizes can be either scalar or array-objects. - Parameters - ---------- - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem - tau : positive float, optional, default=None - Step size parameter for Primal problem - - The user can set these or default values are calculated, either sigma, tau, both or None can be passed. - - Note - ----- When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: - .. math:: - \sigma_i=0.99 / (\|K_i\|**2) + .. math:: \sigma_i=0.99 / (\|K_i\|**2)` - and `tau` is set as per case 2 + and `tau` is set as per case 2 - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula - .. math:: - \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + .. math:: \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula - .. math:: - \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) + .. math:: \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) - Case 4: Both `sigma` and `tau` are provided. + + + Parameters + ---------- + sigma : list of positive float, optional, default=None + List of Step size parameters for Dual problem + tau : positive float, optional, default=None + Step size parameter for Primal problem """ gamma = 1. @@ -372,7 +351,7 @@ def set_step_sizes(self, sigma=None, tau=None): self._sigma = sigma elif tau is None: - self._sigma = [rho / ni for ni in self._norms] + self._sigma = [gamma* rho / ni for ni in self._norms] else: self._sigma = [ rho*pi / (tau*ni**2) for ni, pi in zip(self._norms, self._prob_weights)] @@ -435,7 +414,7 @@ def update(self): y_k = self.operator[i].direct(self.x) except IndexError: raise IndexError( - 'The sampler has outputted an index larger than the number of operators to sample from. Please ensure your sampler samples from {1,2,...,len(operator)} only.') + 'The sampler has outputted an index larger than the number of operators to sample from. Please ensure your sampler samples from {0,1,...,len(operator)-1} only.') y_k.sapyb(self._sigma[i], self._y_old[i], 1., out=y_k) From 64b86a0bb6dde92027da70d8be13ac7c4b5258d4 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Thu, 22 Aug 2024 15:09:49 +0000 Subject: [PATCH 106/115] Documentation updates and unit test fix --- .../cil/optimisation/algorithms/SPDHG.py | 115 +++++++----------- Wrappers/Python/test/test_algorithms.py | 62 +++++----- 2 files changed, 80 insertions(+), 97 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 62710eac9e..9bd9258f86 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -24,15 +24,18 @@ from cil.optimisation.utilities import Sampler from numbers import Number import warnings +from cil.framework import BlockDataContainer log = logging.getLogger(__name__) class SPDHG(Algorithm): r'''Stochastic Primal Dual Hybrid Gradient (SPDHG) solves separable optimisation problems of the type: + .. math:: - Problem: - .. math:: \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) + \min_{x} f(Kx) + g(x) = \min_{x} \sum f_i(K_i x) + g(x) + + where :math:`f_i` and the regulariser :math:`g` need to be proper, convex and lower semi-continuous. Parameters ---------- @@ -42,11 +45,11 @@ class SPDHG(Algorithm): A convex function with a "simple" proximal operator : BlockOperator BlockOperator must contain Linear Operators - tau : positive float, optional, default=None - Step size parameter for Primal problem - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem - initial : DataContainer, optional, default=None + tau : positive float, optional, default= see note + Step size parameter for primal problem + sigma : list of positive float, optional, default= see note + List of Step size parameters for dual problem + initial : DataContainer, optional, default to a zero DataContainer in the range of the `operator`. Initial point for the SPDHG algorithm gamma : float, optional Parameter controlling the trade-off between the primal and dual step sizes @@ -56,13 +59,6 @@ class SPDHG(Algorithm): Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Note that this should not be passed if the provided sampler has it as an attribute. - **kwargs - --------- - prob : list of floats, optional, default=None - List of probabilities. If None each subset will have probability = 1/number of subsets. To be deprecated. - norms : list of floats - Precalculated list of norms of the operators. To be deprecated and placed by the `set_norms` functionalist in a BlockOperator. - Example ------- @@ -95,17 +91,17 @@ class SPDHG(Algorithm): - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: - .. math:: \sigma_i=0.99 / (\|K_i\|**2) + .. math:: \sigma_i= \frac{0.99}{\|K_i\|^2} and `tau` is set as per case 2 - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula - .. math:: \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + .. math:: \tau = 0.99\min_i( \frac{p_i}{ (\sigma_i \|K_i\|^2) }) - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula - .. math:: \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) + .. math:: \sigma_i= \frac{0.99 p_i}{\tau\|K_i\|^2} - Case 4: Both `sigma` and `tau` are provided. @@ -115,7 +111,7 @@ class SPDHG(Algorithm): Convergence is guaranteed provided that [2, eq. (12)]: - .. math:: \|\sigma[i]^{1/2} * K[i] * tau^{1/2} \|^2 < p_i for all i + .. math:: \|\sigma[i]^{1/2} K[i] \tau^{1/2} \|^2 < p_i \text{ for all } i References ---------- @@ -133,42 +129,19 @@ class SPDHG(Algorithm): def __init__(self, f=None, g=None, operator=None, tau=None, sigma=None, initial=None, sampler=None, prob_weights=None, **kwargs): - update_objective_interval = kwargs.pop('update_objective_interval', 1) - super(SPDHG, self).__init__(update_objective_interval=update_objective_interval) + super(SPDHG, self).__init__( + update_objective_interval=update_objective_interval) self.set_up(f=f, g=g, operator=operator, sigma=sigma, tau=tau, initial=initial, sampler=sampler, prob_weights=prob_weights, **kwargs) def set_up(self, f, g, operator, sigma=None, tau=None, initial=None, sampler=None, prob_weights=None, **deprecated_kwargs): - '''set-up of the algorithm - - Parameters - ---------- - f : BlockFunction - Each must be a convex function with a "simple" proximal method of its conjugate - g : Function - A convex function with a "simple" proximal - operator : BlockOperator - BlockOperator must contain Linear Operators - tau : positive float, optional, default=None - Step size parameter for Primal problem - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem - initial : DataContainer, optional, default=None - Initial point for the SPDHG algorithm - gamma : float, optional - parameter controlling the trade-off between the primal and dual step sizes - sampler: optional, an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting a sample from {1,...,len(operator)}. - Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/len(operator) - prob_weights: optional, list of floats of length num_indices that sum to 1. Defaults to [1/len(operator)]*len(operator) - Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Note that this should not be passed if the provided sampler has it as an attribute. - ''' log.info("%s setting up", self.__class__.__name__) - + # algorithmic parameters self.f = f self.g = g @@ -211,13 +184,15 @@ def set_up(self, f, g, operator, sigma=None, tau=None, # initialize dual variable to 0 self._y_old = operator.range_geometry().allocate(0) + if not isinstance(self._y_old, BlockDataContainer): #This can be removed once #1863 is fixed + self._y_old =BlockDataContainer(self._y_old) # initialize variable z corresponding to back-projected dual variable self._z = operator.domain_geometry().allocate(0) self._zbar = operator.domain_geometry().allocate(0) # relaxation parameter self._theta = 1 - + self.configured = True logging.info("{} configured".format(self.__class__.__name__, )) @@ -239,7 +214,7 @@ def _deprecated_kwargs(self, deprecated_kwargs): if prob is not None: if self._prob_weights is None: - warnings.warn('`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). To pass probabilites to the calculation for `sigma` and `tau` please use `prob_weights`. ') + warnings.warn('`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). To pass probabilities to the calculation for `sigma` and `tau` please use `prob_weights`. ', DeprecationWarning, stacklevel=2) self._prob_weights = prob else: @@ -249,11 +224,10 @@ def _deprecated_kwargs(self, deprecated_kwargs): if norms is not None: self.operator.set_norms(norms) warnings.warn( - ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`') + ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`', DeprecationWarning, stacklevel=2) if deprecated_kwargs: - raise ValueError("Additional keyword arguments passed but not used: {}".format( - deprecated_kwargs)) + raise ValueError("Additional keyword arguments passed but not used: {}".format(deprecated_kwargs)) @property def sigma(self): @@ -267,9 +241,10 @@ def set_step_sizes_from_ratio(self, gamma=1.0, rho=0.99): r""" Sets gamma, the step-size ratio for the SPDHG algorithm. Currently gamma takes a scalar value. The step sizes `sigma` and `tau` are set using the equations: - .. math:: \sigma_i=\gamma\rho / (\|K_i\|**2)\\ - - .. math:: \tau = \rho\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + + .. math:: \sigma_i= \frac{\gamma\rho }{\|K_i\|^2} + + .. math:: \tau = \rho\min_i([ \frac{p_i }{\sigma_i \|K_i\|^2}) Parameters @@ -279,8 +254,8 @@ def set_step_sizes_from_ratio(self, gamma=1.0, rho=0.99): rho : Positive float parameter controlling the size of the product :math: \sigma\tau :math: - - + + """ if isinstance(gamma, Number): if gamma <= 0: @@ -311,28 +286,27 @@ def set_step_sizes(self, sigma=None, tau=None): - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: - .. math:: \sigma_i=0.99 / (\|K_i\|**2)` - + .. math:: \sigma_i= \frac{0.99}{\|K_i\|^2} and `tau` is set as per case 2 - Case 2: If `sigma` is provided but not `tau` then `tau` is calculated using the formula - .. math:: \tau = 0.99\min_i([p_i / (\sigma_i * \|K_i\|**2) ]) + .. math:: \tau = 0.99\min_i( \frac{p_i}{ (\sigma_i \|K_i\|^2) }) - Case 3: If `tau` is provided but not `sigma` then `sigma` is calculated using the formula - .. math:: \sigma_i=0.99 p_i / (\tau*\|K_i\|**2) + .. math:: \sigma_i= \frac{0.99 p_i}{\tau\|K_i\|^2} - Case 4: Both `sigma` and `tau` are provided. - - + + Parameters ---------- - sigma : list of positive float, optional, default=None - List of Step size parameters for Dual problem - tau : positive float, optional, default=None - Step size parameter for Primal problem + sigma : list of positive float, optional, default= see docstring + List of Step size parameters for dual problem + tau : positive float, optional, default= see docstring + Step size parameter for primal problem """ gamma = 1. @@ -351,7 +325,7 @@ def set_step_sizes(self, sigma=None, tau=None): self._sigma = sigma elif tau is None: - self._sigma = [gamma* rho / ni for ni in self._norms] + self._sigma = [gamma * rho / ni for ni in self._norms] else: self._sigma = [ rho*pi / (tau*ni**2) for ni, pi in zip(self._norms, self._prob_weights)] @@ -360,7 +334,7 @@ def set_step_sizes(self, sigma=None, tau=None): values = [rho*pi / (si * ni**2) for pi, ni, si in zip(self._prob_weights, self._norms, self._sigma)] self._tau = min([value for value in values if value > 1e-8]) - + else: if isinstance(tau, Number) and tau > 0: pass @@ -377,11 +351,11 @@ def check_convergence(self): ------- Boolean True if convergence criterion is satisfied. False if not satisfied or convergence is unknown. - + Note ----- Convergence criterion currently can only be checked for scalar values of tau. - + Note ---- This checks the convergence criterion. Numerical errors may mean some sigma and tau values that satisfy the convergence criterion may not converge. @@ -433,7 +407,7 @@ def update(self): # zbar = z + (theta/p[i]) * x_tmp self._z.sapyb(1., self._x_tmp, self._theta / - self._prob_weights[i], out=self._zbar) + self._prob_weights[i], out=self._zbar) # save previous iteration self._save_previous_iteration(i, y_k) @@ -455,6 +429,7 @@ def update_objective(self): @property def objective(self): '''The saved primal objectives. + Returns ------- list @@ -465,6 +440,7 @@ def objective(self): @property def dual_objective(self): '''The saved dual objectives. + Returns ------- list @@ -475,6 +451,7 @@ def dual_objective(self): @property def primal_dual_gap(self): '''The saved primal-dual gap. + Returns ------- list diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index a10176dff1..310266f88f 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -1120,7 +1120,7 @@ def setUp(self): data = dataexample.SIMPLE_PHANTOM_2D.get(size=(20, 20)) self.subsets = 10 - data = dataexample.SIMPLE_PHANTOM_2D.get(size=(128, 128)) + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(16, 16)) ig = data.geometry ig.voxel_size_x = 0.1 @@ -1277,42 +1277,48 @@ def test_spdhg_check_convergence(self): spdhg.set_step_sizes(sigma=None, tau=100) self.assertTrue(spdhg.check_convergence()) - # def test_SPDHG_num_subsets_1(self): TODO: fix this! - # data = dataexample.SIMPLE_PHANTOM_2D.get(size=(10, 10)) + def test_SPDHG_num_subsets_1(self): + data = dataexample.SIMPLE_PHANTOM_2D.get(size=(10, 10)) - # subsets = 1 + subsets = 1 - # ig = data.geometry - # ig.voxel_size_x = 0.1 - # ig.voxel_size_y = 0.1 + ig = data.geometry + ig.voxel_size_x = 0.1 + ig.voxel_size_y = 0.1 - # detectors = ig.shape[0] - # angles = np.linspace(0, np.pi, 90) - # ag = AcquisitionGeometry.create_Parallel2D().set_angles( - # angles, angle_unit='radian').set_panel(detectors, 0.1) - # # Select device - # dev = 'cpu' + detectors = ig.shape[0] + angles = np.linspace(0, np.pi, 90) + ag = AcquisitionGeometry.create_Parallel2D().set_angles( + angles, angle_unit='radian').set_panel(detectors, 0.1) + # Select device + dev = 'cpu' - # Aop = ProjectionOperator(ig, ag, dev) + Aop = ProjectionOperator(ig, ag, dev) - # sin = Aop.direct(data) - # partitioned_data = sin.partition(subsets, 'sequential') - # A = BlockOperator( - # *[IdentityOperator(partitioned_data[i].geometry) for i in range(subsets)]) + sin = Aop.direct(data) + partitioned_data = sin.partition(subsets, 'sequential') + A = BlockOperator( + *[IdentityOperator(partitioned_data[i].geometry) for i in range(subsets)]) - # # block function - # F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) - # for i in range(subsets)]) - # alpha = 0.025 - # G = alpha * FGP_TV() + # block function + F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) + for i in range(subsets)]) + + F_phdhg=L2NormSquared(b=partitioned_data[0]) + A_pdhg = IdentityOperator(partitioned_data[0].geometry) + + alpha = 0.025 + G = alpha * FGP_TV() + + spdhg = SPDHG(f=F, g=G, operator=A, update_objective_interval=10) + + spdhg.run(7) - # spdhg = SPDHG(f=F, g=G, operator=A, update_objective_interval=10) + pdhg = PDHG(f=F_phdhg, g=G, operator=A_pdhg, update_objective_interval=10) - # spdhg.run(7) - # pdhg = PDHG(f=F, g=G, operator=A, update_objective_interval=10) + pdhg.run(7) - # pdhg.run(7) - # self.assertNumpyArrayAlmostEqual(pdhg.solution.as_array(), spdhg.solution.as_array(), decimal=3) + self.assertNumpyArrayAlmostEqual(pdhg.solution.as_array(), spdhg.solution.as_array(), decimal=3) @unittest.skipUnless(has_astra, "cil-astra not available") def test_SPDHG_vs_PDHG_implicit(self): From 2b11156bf6a4bf0a91857e1322839b2a23fa1a45 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 2 Sep 2024 15:26:24 +0000 Subject: [PATCH 107/115] Changes to sapyb call to save memory --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 9bd9258f86..c3432cd3d9 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -375,7 +375,8 @@ def update(self): """ # Gradient descent for the primal variable # x_tmp = x - tau * zbar - self.x.sapyb(1., self._zbar, -self._tau, out=self._x_tmp) + self._zbar.sapyb(self._tau, self.x, -1., out=self._x_tmp ) + self._x_tmp*=-1 self.g.proximal(self._x_tmp, self._tau, out=self.x) From 9da703ad3e40056e8eb3b758d40920e784b93718 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 2 Oct 2024 10:00:54 +0000 Subject: [PATCH 108/115] Edo's comments --- .../cil/optimisation/algorithms/SPDHG.py | 82 +++++++++++++------ 1 file changed, 58 insertions(+), 24 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index c3432cd3d9..2de8f6cb95 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -45,18 +45,18 @@ class SPDHG(Algorithm): A convex function with a "simple" proximal operator : BlockOperator BlockOperator must contain Linear Operators - tau : positive float, optional, default= see note - Step size parameter for primal problem - sigma : list of positive float, optional, default= see note - List of Step size parameters for dual problem - initial : DataContainer, optional, default to a zero DataContainer in the range of the `operator`. + tau : positive float, optional, default=None + Step size parameter for primal problem. If `None` see note. + sigma : list of positive float, optional, default=None + List of Step size parameters for dual problem. If `None` see note. + initial : DataContainer, optional, the default value is a zero DataContainer in the range of the `operator`. Initial point for the SPDHG algorithm gamma : float, optional Parameter controlling the trade-off between the primal and dual step sizes sampler: optional, an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting an integer from {1,...,len(operator)}. - Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have probability = 1/len(operator) - prob_weights: optional, list of floats of length num_indices that sum to 1. Defaults to [1/len(operator)]*len(operator) - Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Note that this should not be passed if the provided sampler has it as an attribute. + Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have `probability = 1/len(operator)` + prob_weights: optional, list of floats of length `num_indices` that sum to 1. Defaults to `[1/len(operator)]*len(operator)` + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Note that this should not be passed if the provided sampler has it as an attribute: if the sampler has a `prob_weight` attribute it will take precedence on this parameter. @@ -87,7 +87,7 @@ class SPDHG(Algorithm): Note ----- - When setting `sigma` and `tau`, there are 4 possible cases considered by setup function: + When setting `sigma` and `tau`, there are 4 possible cases considered by setup function. In all cases the probabilities :math:`p_i` are set by a default or user defined sampler: - Case 1: If neither `sigma` or `tau` are provided then `sigma` is set using the formula: @@ -153,24 +153,29 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self._ndual_subsets = len(self.operator) self._sampler = sampler - self._prob_weights = getattr(self._sampler, 'prob_weights', None) - if prob_weights is not None: - if self._prob_weights is None: - self._prob_weights = prob_weights - else: - raise ValueError( + #Set up the _prob_weights. In preference order they are taken from: the sampler, the prob_weights argument, the deprecated prob argument or set as defualt. + self._prob_weights = getattr(self._sampler, 'prob_weights', None) # from the sampler + if self._prob_weights is None: #from prob_weights + self._prob_weights = prob_weights + elif prob_weights is not None: + raise ValueError( ' You passed a `prob_weights` argument and a sampler with attribute `prob_weights`, please remove the `prob_weights` argument.') - self._deprecated_kwargs(deprecated_kwargs) + self._deprecated_prob(deprecated_kwargs) #from prob argument - if self._prob_weights is None: + if self._prob_weights is None: #set from default self._prob_weights = [1/self._ndual_subsets]*self._ndual_subsets + #Set the sampler if self._sampler is None: self._sampler = Sampler.random_with_replacement( len(operator), prob=self._prob_weights) + #Set the norms of the operators + self._deprecated_norms(deprecated_kwargs) self._norms = operator.get_norms_as_list() + #Check for other kwargs + self._deprecated_else(deprecated_kwargs) self.set_step_sizes(sigma=sigma, tau=tau) @@ -196,7 +201,7 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self.configured = True logging.info("{} configured".format(self.__class__.__name__, )) - def _deprecated_kwargs(self, deprecated_kwargs): + def _deprecated_prob(self, deprecated_kwargs): """ Handle deprecated keyword arguments for backward compatibility. @@ -209,7 +214,7 @@ def _deprecated_kwargs(self, deprecated_kwargs): ----- This method is called by the set_up method. """ - norms = deprecated_kwargs.pop('norms', None) + prob = deprecated_kwargs.pop('prob', None) if prob is not None: @@ -221,14 +226,45 @@ def _deprecated_kwargs(self, deprecated_kwargs): raise ValueError( '`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. You passed a `prob` argument, and either a `prob_weights` argument or a sampler with a `prob_weights` property. Please give only one of the three. ') + + + def _deprecated_norms(self, deprecated_kwargs): + """ + Handle deprecated keyword arguments for backward compatibility. + + Parameters + ---------- + deprecated_kwargs : dict + Dictionary of keyword arguments. + + Notes + ----- + This method is called by the set_up method. + """ + norms = deprecated_kwargs.pop('norms', None) + if norms is not None: self.operator.set_norms(norms) warnings.warn( ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`', DeprecationWarning, stacklevel=2) + def _deprecated_else(self, deprecated_kwargs): + """ + Handle deprecated keyword arguments for backward compatibility. + + Parameters + ---------- + deprecated_kwargs : dict + Dictionary of keyword arguments. + + Notes + ----- + This method is called by the set_up method. + """ if deprecated_kwargs: raise ValueError("Additional keyword arguments passed but not used: {}".format(deprecated_kwargs)) - + + @property def sigma(self): return self._sigma @@ -336,9 +372,7 @@ def set_step_sizes(self, sigma=None, tau=None): self._tau = min([value for value in values if value > 1e-8]) else: - if isinstance(tau, Number) and tau > 0: - pass - else: + if not ( isinstance(tau, Number) and tau > 0): raise ValueError( "The step-sizes of SPDHG must be positive, passed tau = {}".format(tau)) @@ -367,7 +401,7 @@ def check_convergence(self): return False return True else: - return False + raise ValueError('Convergence criterion currently can only be checked for scalar values of tau and sigma[i].') def update(self): """ Runs one iteration of SPDHG From 0addbdba57fe56df6a9dcaa35973bf44760cfd88 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 7 Oct 2024 15:51:32 +0000 Subject: [PATCH 109/115] Updates following discussion with Edo --- .../cil/optimisation/algorithms/SPDHG.py | 37 ++++++++++--------- 1 file changed, 20 insertions(+), 17 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 2de8f6cb95..8f12b26403 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -153,26 +153,23 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self._ndual_subsets = len(self.operator) self._sampler = sampler - #Set up the _prob_weights. In preference order they are taken from: the sampler, the prob_weights argument, the deprecated prob argument or set as defualt. - self._prob_weights = getattr(self._sampler, 'prob_weights', None) # from the sampler - if self._prob_weights is None: #from prob_weights - self._prob_weights = prob_weights - elif prob_weights is not None: - raise ValueError( - ' You passed a `prob_weights` argument and a sampler with attribute `prob_weights`, please remove the `prob_weights` argument.') - - self._deprecated_prob(deprecated_kwargs) #from prob argument - - if self._prob_weights is None: #set from default + # Set up sampler and prob weights from deprecated "prob" argument + self._deprecated_set_prob(deprecated_kwargs, prob_weights, sampler) + + + self._prob_weights = getattr(self._sampler, 'prob_weights', prob_weights) + if self._prob_weights is None: self._prob_weights = [1/self._ndual_subsets]*self._ndual_subsets + + if prob_weights is not None and self._prob_weights != prob_weights: + raise ValueError(' You passed a `prob_weights` argument and a sampler with a different attribute `prob_weights`, please remove the `prob_weights` argument.') - #Set the sampler if self._sampler is None: self._sampler = Sampler.random_with_replacement( len(operator), prob=self._prob_weights) #Set the norms of the operators - self._deprecated_norms(deprecated_kwargs) + self._deprecated_set_norms(deprecated_kwargs) self._norms = operator.get_norms_as_list() #Check for other kwargs self._deprecated_else(deprecated_kwargs) @@ -201,7 +198,7 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self.configured = True logging.info("{} configured".format(self.__class__.__name__, )) - def _deprecated_prob(self, deprecated_kwargs): + def _deprecated_set_prob(self, deprecated_kwargs, prob_weights, sampler): """ Handle deprecated keyword arguments for backward compatibility. @@ -209,6 +206,10 @@ def _deprecated_prob(self, deprecated_kwargs): ---------- deprecated_kwargs : dict Dictionary of keyword arguments. + prob_weights : list of floats + List of probabilities for each operator. + sampler : Sampler + Sampler class for selecting the next index for the SPDHG update. Notes ----- @@ -218,17 +219,19 @@ def _deprecated_prob(self, deprecated_kwargs): prob = deprecated_kwargs.pop('prob', None) if prob is not None: - if self._prob_weights is None: + if (prob_weights is None) and (sampler is None): warnings.warn('`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). To pass probabilities to the calculation for `sigma` and `tau` please use `prob_weights`. ', DeprecationWarning, stacklevel=2) self._prob_weights = prob + self._sampler = Sampler.random_with_replacement( + len(self.operator), prob=prob) else: raise ValueError( - '`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. You passed a `prob` argument, and either a `prob_weights` argument or a sampler with a `prob_weights` property. Please give only one of the three. ') + '`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. You passed a `prob` argument, and either a `prob_weights` argument or a sampler. Please remove the `prob` argument.') - def _deprecated_norms(self, deprecated_kwargs): + def _deprecated_set_norms(self, deprecated_kwargs): """ Handle deprecated keyword arguments for backward compatibility. From e8641d0c786957d74e08fbefc0dac84b3f83b725 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 15 Oct 2024 14:14:00 +0000 Subject: [PATCH 110/115] Changed sampler init --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 8f12b26403..0c7cb45283 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -151,22 +151,24 @@ def set_up(self, f, g, operator, sigma=None, tau=None, raise TypeError("operator should be a BlockOperator") self._ndual_subsets = len(self.operator) - self._sampler = sampler + # Set up sampler and prob weights from deprecated "prob" argument self._deprecated_set_prob(deprecated_kwargs, prob_weights, sampler) - self._prob_weights = getattr(self._sampler, 'prob_weights', prob_weights) + self._prob_weights = getattr(sampler, 'prob_weights', prob_weights) if self._prob_weights is None: self._prob_weights = [1/self._ndual_subsets]*self._ndual_subsets if prob_weights is not None and self._prob_weights != prob_weights: raise ValueError(' You passed a `prob_weights` argument and a sampler with a different attribute `prob_weights`, please remove the `prob_weights` argument.') - if self._sampler is None: + if sampler is None: self._sampler = Sampler.random_with_replacement( len(operator), prob=self._prob_weights) + else: + self._sampler = sampler #Set the norms of the operators self._deprecated_set_norms(deprecated_kwargs) From b1f0dbb521324f2b3afa2390f2cd383d2e3d51ea Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Tue, 15 Oct 2024 14:49:32 +0000 Subject: [PATCH 111/115] Fix to failing test --- Wrappers/Python/cil/optimisation/algorithms/SPDHG.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 0c7cb45283..60c86af447 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -154,7 +154,7 @@ def set_up(self, f, g, operator, sigma=None, tau=None, # Set up sampler and prob weights from deprecated "prob" argument - self._deprecated_set_prob(deprecated_kwargs, prob_weights, sampler) + sampler = self._deprecated_set_prob(deprecated_kwargs, prob_weights, sampler) self._prob_weights = getattr(sampler, 'prob_weights', prob_weights) @@ -224,14 +224,14 @@ def _deprecated_set_prob(self, deprecated_kwargs, prob_weights, sampler): if (prob_weights is None) and (sampler is None): warnings.warn('`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). To pass probabilities to the calculation for `sigma` and `tau` please use `prob_weights`. ', DeprecationWarning, stacklevel=2) self._prob_weights = prob - self._sampler = Sampler.random_with_replacement( + sampler = Sampler.random_with_replacement( len(self.operator), prob=prob) else: raise ValueError( '`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. You passed a `prob` argument, and either a `prob_weights` argument or a sampler. Please remove the `prob` argument.') - + return sampler def _deprecated_set_norms(self, deprecated_kwargs): """ From 36c0bf993cfc373cb75b8b05e7c68d0750d6b792 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Wed, 16 Oct 2024 16:27:59 +0000 Subject: [PATCH 112/115] Updates from Gemma's comments --- .../cil/optimisation/algorithms/SPDHG.py | 65 ++++++++----------- 1 file changed, 27 insertions(+), 38 deletions(-) diff --git a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py index 60c86af447..b8d04069a6 100644 --- a/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py +++ b/Wrappers/Python/cil/optimisation/algorithms/SPDHG.py @@ -45,19 +45,28 @@ class SPDHG(Algorithm): A convex function with a "simple" proximal operator : BlockOperator BlockOperator must contain Linear Operators - tau : positive float, optional, default=None - Step size parameter for primal problem. If `None` see note. - sigma : list of positive float, optional, default=None - List of Step size parameters for dual problem. If `None` see note. - initial : DataContainer, optional, the default value is a zero DataContainer in the range of the `operator`. - Initial point for the SPDHG algorithm + tau : positive float, optional + Step size parameter for the primal problem. If `None` will be computed by algorithm, see note for details. + sigma : list of positive float, optional + List of Step size parameters for dual problem. If `None` will be computed by algorithm, see note for details. + initial : DataContainer, optional + Initial point for the SPDHG algorithm. The default value is a zero DataContainer in the range of the `operator`. gamma : float, optional Parameter controlling the trade-off between the primal and dual step sizes - sampler: optional, an instance of a `cil.optimisation.utilities.Sampler` class or another class with the function __next__(self) implemented outputting an integer from {1,...,len(operator)}. - Method of selecting the next index for the SPDHG update. If None, a sampler will be created for random sampling with replacement and each index will have `probability = 1/len(operator)` - prob_weights: optional, list of floats of length `num_indices` that sum to 1. Defaults to `[1/len(operator)]*len(operator)` - Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Note that this should not be passed if the provided sampler has it as an attribute: if the sampler has a `prob_weight` attribute it will take precedence on this parameter. + sampler: `cil.optimisation.utilities.Sampler`, optional + A `Sampler` controllingthe selection of the next index for the SPDHG update. If `None`, a sampler will be created for uniform random sampling with replacement. See notes. + prob_weights: list of floats, optional, + Consider that the sampler is called a large number of times this argument holds the expected number of times each index would be called, normalised to 1. Note that this should not be passed if the provided sampler has it as an attribute: if the sampler has a `prob_weight` attribute it will take precedence on this parameter. Should be a list of floats of length `num_indices` that sum to 1. If no sampler with `prob_weights` is passed, it defaults to `[1/len(operator)]*len(operator)`. + + + Note + ----- + The `sampler` can be an instance of the `cil.optimisation.utilities.Sampler` class or a custom class with the `__next__(self)` method implemented, which outputs an integer index from {1, ..., len(operator)}. + + Note + ----- + "Random sampling with replacement" will select the next index with equal probability from `1 - len(operator)`. Example @@ -152,12 +161,10 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self._ndual_subsets = len(self.operator) - - # Set up sampler and prob weights from deprecated "prob" argument - sampler = self._deprecated_set_prob(deprecated_kwargs, prob_weights, sampler) + self._prob_weights = getattr(sampler, 'prob_weights', prob_weights) + self._deprecated_set_prob(deprecated_kwargs, sampler) - self._prob_weights = getattr(sampler, 'prob_weights', prob_weights) if self._prob_weights is None: self._prob_weights = [1/self._ndual_subsets]*self._ndual_subsets @@ -169,12 +176,13 @@ def set_up(self, f, g, operator, sigma=None, tau=None, len(operator), prob=self._prob_weights) else: self._sampler = sampler - + #Set the norms of the operators self._deprecated_set_norms(deprecated_kwargs) self._norms = operator.get_norms_as_list() #Check for other kwargs - self._deprecated_else(deprecated_kwargs) + if deprecated_kwargs: + raise ValueError("Additional keyword arguments passed but not used: {}".format(deprecated_kwargs)) self.set_step_sizes(sigma=sigma, tau=tau) @@ -200,7 +208,7 @@ def set_up(self, f, g, operator, sigma=None, tau=None, self.configured = True logging.info("{} configured".format(self.__class__.__name__, )) - def _deprecated_set_prob(self, deprecated_kwargs, prob_weights, sampler): + def _deprecated_set_prob(self, deprecated_kwargs, sampler): """ Handle deprecated keyword arguments for backward compatibility. @@ -208,8 +216,6 @@ def _deprecated_set_prob(self, deprecated_kwargs, prob_weights, sampler): ---------- deprecated_kwargs : dict Dictionary of keyword arguments. - prob_weights : list of floats - List of probabilities for each operator. sampler : Sampler Sampler class for selecting the next index for the SPDHG update. @@ -221,17 +227,15 @@ def _deprecated_set_prob(self, deprecated_kwargs, prob_weights, sampler): prob = deprecated_kwargs.pop('prob', None) if prob is not None: - if (prob_weights is None) and (sampler is None): + if (self._prob_weights is None) and (sampler is None): warnings.warn('`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. To randomly sample with replacement use "sampler=Sampler.randomWithReplacement(number_of_subsets, prob=prob). To pass probabilities to the calculation for `sigma` and `tau` please use `prob_weights`. ', DeprecationWarning, stacklevel=2) self._prob_weights = prob - sampler = Sampler.random_with_replacement( - len(self.operator), prob=prob) else: raise ValueError( '`prob` is being deprecated to be replaced with a sampler class and `prob_weights`. You passed a `prob` argument, and either a `prob_weights` argument or a sampler. Please remove the `prob` argument.') - return sampler + def _deprecated_set_norms(self, deprecated_kwargs): """ @@ -253,22 +257,7 @@ def _deprecated_set_norms(self, deprecated_kwargs): warnings.warn( ' `norms` is being deprecated, use instead the `BlockOperator` function `set_norms`', DeprecationWarning, stacklevel=2) - def _deprecated_else(self, deprecated_kwargs): - """ - Handle deprecated keyword arguments for backward compatibility. - Parameters - ---------- - deprecated_kwargs : dict - Dictionary of keyword arguments. - - Notes - ----- - This method is called by the set_up method. - """ - if deprecated_kwargs: - raise ValueError("Additional keyword arguments passed but not used: {}".format(deprecated_kwargs)) - @property def sigma(self): From c8ee858a63d44a36246aea78b176ed7c72d52d42 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Fri, 22 Nov 2024 13:56:49 +0000 Subject: [PATCH 113/115] Changes from Gemma's review --- CHANGELOG.md | 6 ++++-- Wrappers/Python/test/test_algorithms.py | 26 ++++++++++++++++--------- 2 files changed, 21 insertions(+), 11 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index cb49c81fd9..0478dc0459 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,8 +3,12 @@ - Fix bug with 'median' and 'mean' methods in Masker averaging over the wrong axes. - Enhancements: - Removed multiple exits from numba implementation of KullbackLeibler divergence (#1901) +- Updated the `SPDHG` algorithm to take a stochastic `Sampler` and to more easily set step sizes (#1644) - Dependencies: - Added scikit-image to CIL-Demos conda install command as needed for new Callbacks notebook. +- Changes that break backwards compatibility: + - Deprecated `norms` and `prob` in the `SPDHG` algorithm to be set in the `BlockOperator` and `Sampler` respectively (#1644) + * 24.2.0 - New Features: @@ -58,7 +62,6 @@ - Added documentation for the Partitioner to `framework.rst` (#1828) - Added CIL vs SIRF tests comparing preconditioned ISTA in CIL and MLEM in SIRF (#1823) - Update to CCPi-Regularisation toolkit v24.0.1 (#1868) - - Updated the `SPDHG` algorithm to take a stochastic `Sampler` and to more easily set step sizes (#1644) - Bug fixes: - gradient descent `update_objective` called twice on the initial point.(#1789) - ProjectionMap operator bug fix in adjoint and added documentation (#1743) @@ -68,7 +71,6 @@ - Update dataexample remote data download to work with windows and use zenodo_get for data download (#1774) - Changes that break backwards compatibility: - Merged the files `BlockGeometry.py` and `BlockDataContainer.py` in `framework` to one file `block.py`. Please use `from cil.framework import BlockGeometry, BlockDataContainer` as before (#1799) - - Deprecated `norms` and `prob` in the `SPDHG` algorithm to be set in the `BlockOperator` and `Sampler` respectively (#1644) - Bug fix in `FGP_TV` function to set the default behaviour not to enforce non-negativity (#1826). * 24.0.0 diff --git a/Wrappers/Python/test/test_algorithms.py b/Wrappers/Python/test/test_algorithms.py index 981cc9c3c2..e6e5b087b5 100644 --- a/Wrappers/Python/test/test_algorithms.py +++ b/Wrappers/Python/test/test_algorithms.py @@ -70,7 +70,6 @@ # Fast Gradient Projection algorithm for Total Variation(TV) from cil.optimisation.functions import TotalVariation -from cil.plugins.ccpi_regularisation.functions import FGP_TV import logging from testclass import CCPiTestClass from utils import has_astra @@ -1178,9 +1177,10 @@ def setUp(self): self.F = BlockFunction(*[L2NormSquared(b=partitioned_data[i]) for i in range(self.subsets)]) alpha = 0.025 - self.G = alpha * FGP_TV() + self.G = alpha * IndicatorBox(lower=0) def test_SPDHG_defaults_and_setters(self): + #Test SPDHG init with default values gamma = 1. rho = .99 spdhg = SPDHG(f=self.F, g=self.G, operator=self.A) @@ -1198,6 +1198,7 @@ def test_SPDHG_defaults_and_setters(self): spdhg.x.as_array(), self.A.domain_geometry().allocate(0).as_array()) self.assertEqual(spdhg.update_objective_interval, 1) + #Test SPDHG setters - "from ratio" gamma = 3.7 rho = 5.6 spdhg.set_step_sizes_from_ratio(gamma, rho) @@ -1206,6 +1207,7 @@ def test_SPDHG_defaults_and_setters(self): self.assertEqual(spdhg.tau, min([pi*rho / (si * ni**2) for pi, ni, si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])) + #Test SPDHG setters - set_step_sizes default values for sigma and tau gamma = 1. rho = .99 spdhg.set_step_sizes() @@ -1214,21 +1216,25 @@ def test_SPDHG_defaults_and_setters(self): self.assertEqual(spdhg.tau, min([rho*pi / (si * ni**2) for pi, ni, si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])) + #Test SPDHG setters - set_step_sizes with sigma and tau spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=100) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, 100) + #Test SPDHG setters - set_step_sizes with sigma spdhg.set_step_sizes(sigma=[1]*self.subsets, tau=None) self.assertListEqual(spdhg.sigma, [1]*self.subsets) self.assertEqual(spdhg.tau, min([(rho*pi / (si * ni**2)) for pi, ni, si in zip(spdhg._prob_weights, spdhg._norms, spdhg.sigma)])) + #Test SPDHG setters - set_step_sizes with tau spdhg.set_step_sizes(sigma=None, tau=100) self.assertListEqual(spdhg.sigma, [ gamma * rho*pi / (spdhg.tau*ni**2) for ni, pi in zip(spdhg._norms, spdhg._prob_weights)]) self.assertEqual(spdhg.tau, 100) def test_spdhg_non_default_init(self): + #Test SPDHG init with non-default values spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.)), initial=self.A.domain_geometry().allocate(1), update_objective_interval=10) @@ -1237,8 +1243,9 @@ def test_spdhg_non_default_init(self): spdhg.x.as_array(), self.A.domain_geometry().allocate(1).as_array()) self.assertEqual(spdhg.update_objective_interval, 10) + #Test SPDHG setters - prob_weights and a sampler gives an error with self.assertRaises(ValueError): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, _norms=[1]*len(self.A), prob_weights=[1/(self.subsets-1)]*( + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, prob_weights=[1/(self.subsets-1)]*( self.subsets-1)+[0], sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, prob_weights=[1/(self.subsets-1)]*( @@ -1266,17 +1273,16 @@ def test_spdhg_deprecated_vargs(self): 1/(self.subsets-1)]*(self.subsets-1)+[0]) with self.assertRaises(ValueError): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, _norms=[1]*len(self.A), prob=[1/(self.subsets-1)]*( + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, prob=[1/(self.subsets-1)]*( self.subsets-1)+[0], sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) with self.assertRaises(ValueError): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, _norms=[1]*len(self.A), prob=[1/(self.subsets-1)]*( + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, prob=[1/(self.subsets-1)]*( self.subsets-1)+[0], prob_weights= [1/(self.subsets-1)]*(self.subsets-1)+[0]) with self.assertRaises(ValueError): - spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sfdsdf=3, _norms=[ - 1]*len(self.A), sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) + spdhg = SPDHG(f=self.F, g=self.G, operator=self.A, sfdsdf=3, sampler=Sampler.random_with_replacement(10, list(np.arange(1, 11)/55.))) def test_spdhg_set_norms(self): @@ -1309,6 +1315,8 @@ def test_spdhg_check_convergence(self): spdhg.set_step_sizes(sigma=None, tau=100) self.assertTrue(spdhg.check_convergence()) + @unittest.skipUnless(has_astra, "cil-astra not available") + def test_SPDHG_num_subsets_1(self): data = dataexample.SIMPLE_PHANTOM_2D.get(size=(10, 10)) @@ -1340,7 +1348,7 @@ def test_SPDHG_num_subsets_1(self): A_pdhg = IdentityOperator(partitioned_data[0].geometry) alpha = 0.025 - G = alpha * FGP_TV() + G = alpha * IndicatorBox(lower=0) spdhg = SPDHG(f=F, g=G, operator=A, update_objective_interval=10) @@ -1477,7 +1485,7 @@ def test_SPDHG_vs_PDHG_explicit(self): prob = [1/(2*subsets)]*(len(K)-1) + [1/2] spdhg = SPDHG(f=F, g=G, operator=K, update_objective_interval=200, prob=prob) - spdhg.run(20 * subsets) + spdhg.run(25 * subsets) # %% 'explicit' PDHG, scalar step-sizes op1 = alpha * GradientOperator(ig) From e2efb06ad299bd30993b399b94da6b38047f963c Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 25 Nov 2024 10:03:01 +0000 Subject: [PATCH 114/115] Changelog mess --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0478dc0459..0ddca1c0f0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -95,6 +95,7 @@ - ZeroOperator no longer relies on the default of allocate - Bug fix in SIRF TotalVariation unit tests with warm_start - Allow show2D to be used with 3D `DataContainer` instances + - Added the a `Sampler` class as a CIL optimisation utility - Update documentation for symmetrised gradient - Added documentation for CompositionOperator and SumOperator - Updated FISTA and ISTA algorithms to allow input functions to be None From b30666b63fbb457b82362edbd9cae2aa33c64be3 Mon Sep 17 00:00:00 2001 From: Margaret Duff Date: Mon, 25 Nov 2024 10:13:36 +0000 Subject: [PATCH 115/115] Changelog (again) --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0ddca1c0f0..8413a2b8c5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,7 @@ * 24.x.x - Bug fixes: - Fix bug with 'median' and 'mean' methods in Masker averaging over the wrong axes. + - `SPDHG` `gamma` parameter is now applied correctly, so that the product of the dual and primal step sizes remains constant as `gamma` varies (#1644) - Enhancements: - Removed multiple exits from numba implementation of KullbackLeibler divergence (#1901) - Updated the `SPDHG` algorithm to take a stochastic `Sampler` and to more easily set step sizes (#1644)