From 1d0d3ae7a95e14a56d3536ff5bb00b8c24b402ea Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 28 Nov 2020 12:25:23 -0700 Subject: [PATCH 01/76] Add SharedImage, RGBToBGR, & ScaleInputRange * Added SharedImage parameterization that's based off of Lucid / Lucent's lowres_tensor. * Added ScaleInputRange transform for use with models that have an input range other than 0,1. * Added RGBToBGR transform for converting RGB inputs to BGR. * Some fixes to transforms. --- captum/optim/_param/image/images.py | 72 +++++++++++++++++++++++++- captum/optim/_param/image/transform.py | 37 ++++++++++++- 2 files changed, 105 insertions(+), 4 deletions(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index dced0f130e..d1b377c552 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -1,5 +1,5 @@ from copy import deepcopy -from typing import Any, Callable, Dict, List, Optional, Tuple +from typing import Any, Callable, Dict, List, Optional, Tuple, Union import matplotlib.pyplot as plt import numpy as np @@ -342,6 +342,73 @@ def forward(self) -> torch.Tensor: return torch.stack(A).refine_names("B", "C", "H", "W") +class SharedImage(ImageParameterization): + """ + Share some image parameters across the batch. + Mordvintsev, et al., "Differentiable Image Parameterizations", Distill, 2018. + https://distill.pub/2018/differentiable-parameterizations/ + """ + + def __init__( + self, + shared_shapes: Union[Tuple[Tuple[int]], Tuple[int]] = None, + parameterization=None, + ) -> None: + super().__init__() + A = [] + shared_shapes = ( + [shared_shapes] if type(shared_shapes[0]) is not tuple else shared_shapes + ) + for shape in shared_shapes: + assert len(shape) >= 2 and len(shape) <= 4 + if len(shape) == 2: + shape = (1, 1, shape[0], shape[1]) + if len(shape) == 3: + shape = (1, shape[0], shape[1], shape[2]) + batch, channels, height, width = shape[0], shape[1], shape[2], shape[3] + A.append(torch.nn.Parameter(torch.randn([batch, channels, height, width]))) + self.shared_init = torch.nn.ParameterList(A) + self.parameterization = parameterization + + def interpolate_tensor( + self, x: torch.Tensor, size: InitSize, batch: int, channels: int + ) -> torch.Tensor: + """ + Linear interpolation for 4D, 5D, and 6D tensors. + """ + + if x.size(1) == channels: + mode = "bilinear" + else: + mode = "trilinear" + x = x.unsqueeze(0) + size = (channels, size[0], size[1]) + x = F.interpolate(x, size=size, mode=mode) + x = x.squeeze(0) if len(size) == 3 else x + if x.size(0) != batch: + x = x.permute(1, 0, 2, 3) + x = F.interpolate( + x.unsqueeze(0), + size=(batch, x.size(2), x.size(3)), + mode="trilinear", + ).squeeze(0) + x = x.permute(1, 0, 2, 3) + return x + + def forward(self) -> torch.Tensor: + image = self.parameterization() + x = [ + self.interpolate_tensor( + shared_tensor, + (image.size(2), image.size(3)), + image.size(0), + image.size(1), + ) + for shared_tensor in self.shared_init + ] + return (image + sum(x)).refine_names("B", "C", "H", "W") + + class NaturalImage(ImageParameterization): r"""Outputs an optimizable input image. @@ -351,7 +418,8 @@ class NaturalImage(ImageParameterization): uncorrelated image parameterization. :-) If a model requires a normalization step, such as normalizing imagenet RGB values, - or rescaling to [0,255], it has to perform that step inside its computation. + or rescaling to [0,255], it can perform those steps with the provided transforms or + inside its computation. For example, our GoogleNet factory function has a `transform_input=True` argument. """ diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index d0f2d2cb3e..ba0a5006c4 100755 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -24,7 +24,7 @@ def __init__(self, background: Optional[torch.Tensor] = None) -> None: def forward(self, x: torch.Tensor) -> torch.Tensor: assert x.size(1) == 4 rgb, alpha = x[:, :3, ...], x[:, 3:4, ...] - background = self.background or torch.rand_like(rgb) + background = self.background if self.background is not None else torch.rand_like(rgb) blended = alpha * rgb + (1 - alpha) * background return blended @@ -119,7 +119,14 @@ class CenterCrop(torch.nn.Module): def __init__(self, size: TransformSize = 0) -> None: super(CenterCrop, self).__init__() - self.crop_val = [size] * 2 if size is not list and size is not tuple else size + if type(size) is list or type(size) is tuple: + assert ( + len(size) == 2 + ), "CenterCrop requires a single crop value or a tuple of (height,width) in pixels for cropping." + self.crop_val = size + else: + self.crop_val = [size] * 2 + def forward(self, input: torch.Tensor) -> torch.Tensor: assert ( @@ -187,6 +194,7 @@ def __init__(self, translate: int) -> None: self.pad_range = 2 * translate self.pad = nn.ReflectionPad2d(translate) + def translate_tensor(self, x: torch.Tensor, insets: torch.Tensor) -> torch.Tensor: padded = self.pad(x) tblr = [ @@ -199,11 +207,36 @@ def translate_tensor(self, x: torch.Tensor, insets: torch.Tensor) -> torch.Tenso assert cropped.shape == x.shape return cropped + def forward(self, input: torch.Tensor) -> torch.Tensor: insets = torch.randint(high=self.pad_range, size=(2,)) return self.translate_tensor(input, insets) +class ScaleInputRange(nn.Module): + """ + Multiplies the input by a specified multiplier for models with input ranges other + than [0,1]. + """ + + def __init__(self, multiplier: float = 1.0) -> None: + super().__init__() + self.multiplier = multiplier + + def forward(self, x: torch.Tensor) -> torch.Tensor: + return x * self.multiplier + + +class RGBToBGR(nn.Module): + """ + Converts RGB images to BGR by switching the red and blue channels. + """ + + def forward(self, x: torch.Tensor) -> torch.Tensor: + assert x.dim() == 4 + return x[:, [2, 1, 0]] + + # class TransformationRobustness(nn.Module): # def __init__(self, jitter=False, scale=False): # super().__init__() From 5802844d2c68728ac0bb83dede0f93c57c10350d Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 28 Nov 2020 13:03:20 -0700 Subject: [PATCH 02/76] Fix class formatting --- captum/optim/_param/image/transform.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index ba0a5006c4..713bf44cac 100755 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -127,7 +127,6 @@ def __init__(self, size: TransformSize = 0) -> None: else: self.crop_val = [size] * 2 - def forward(self, input: torch.Tensor) -> torch.Tensor: assert ( input.dim() == 3 or input.dim() == 4 @@ -194,7 +193,6 @@ def __init__(self, translate: int) -> None: self.pad_range = 2 * translate self.pad = nn.ReflectionPad2d(translate) - def translate_tensor(self, x: torch.Tensor, insets: torch.Tensor) -> torch.Tensor: padded = self.pad(x) tblr = [ @@ -207,7 +205,6 @@ def translate_tensor(self, x: torch.Tensor, insets: torch.Tensor) -> torch.Tenso assert cropped.shape == x.shape return cropped - def forward(self, input: torch.Tensor) -> torch.Tensor: insets = torch.randint(high=self.pad_range, size=(2,)) return self.translate_tensor(input, insets) From 334ab79db18a5f3eeb6dd09bdfee3727fa5c5131 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 30 Nov 2020 12:50:57 -0700 Subject: [PATCH 03/76] Improvements to SharedImage & more asserts --- captum/optim/_param/image/images.py | 5 +---- captum/optim/_param/image/transform.py | 2 ++ 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index d1b377c552..7aef05e8da 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -361,10 +361,7 @@ def __init__( ) for shape in shared_shapes: assert len(shape) >= 2 and len(shape) <= 4 - if len(shape) == 2: - shape = (1, 1, shape[0], shape[1]) - if len(shape) == 3: - shape = (1, shape[0], shape[1], shape[2]) + shape = ([1] * (4 - len(shape))) + list(shape) batch, channels, height, width = shape[0], shape[1], shape[2], shape[3] A.append(torch.nn.Parameter(torch.randn([batch, channels, height, width]))) self.shared_init = torch.nn.ParameterList(A) diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index 713bf44cac..22228f3667 100755 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -23,6 +23,7 @@ def __init__(self, background: Optional[torch.Tensor] = None) -> None: def forward(self, x: torch.Tensor) -> torch.Tensor: assert x.size(1) == 4 + assert x.dim() == 4 rgb, alpha = x[:, :3, ...], x[:, 3:4, ...] background = self.background if self.background is not None else torch.rand_like(rgb) blended = alpha * rgb + (1 - alpha) * background @@ -34,6 +35,7 @@ class IgnoreAlpha(nn.Module): def forward(self, x: torch.Tensor) -> torch.Tensor: assert x.size(1) == 4 + assert x.dim() == 4 rgb = x[:, :3, ...] return rgb From 6f26c1ca18a030858e9dec79a5ebc41311ba0f81 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 30 Nov 2020 13:04:40 -0700 Subject: [PATCH 04/76] Fix lint error --- captum/optim/_param/image/transform.py | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index 22228f3667..307652cc0b 100755 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -25,7 +25,9 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: assert x.size(1) == 4 assert x.dim() == 4 rgb, alpha = x[:, :3, ...], x[:, 3:4, ...] - background = self.background if self.background is not None else torch.rand_like(rgb) + background = ( + self.background if self.background is not None else torch.rand_like(rgb) + ) blended = alpha * rgb + (1 - alpha) * background return blended @@ -122,9 +124,10 @@ class CenterCrop(torch.nn.Module): def __init__(self, size: TransformSize = 0) -> None: super(CenterCrop, self).__init__() if type(size) is list or type(size) is tuple: - assert ( - len(size) == 2 - ), "CenterCrop requires a single crop value or a tuple of (height,width) in pixels for cropping." + assert len(size) == 2, ( + "CenterCrop requires a single crop value or a tuple of (height,width)" + + "in pixels for cropping." + ) self.crop_val = size else: self.crop_val = [size] * 2 From a1f51f917237e056c54bd4db03aec9d724babf0f Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 1 Dec 2020 10:02:44 -0700 Subject: [PATCH 05/76] Add offset parameter to SharedImage --- captum/optim/_param/image/images.py | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 7aef05e8da..bf801da4ca 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -353,6 +353,7 @@ def __init__( self, shared_shapes: Union[Tuple[Tuple[int]], Tuple[int]] = None, parameterization=None, + offset: Optional[int, Tuple[int]] = None, ) -> None: super().__init__() A = [] @@ -366,6 +367,32 @@ def __init__( A.append(torch.nn.Parameter(torch.randn([batch, channels, height, width]))) self.shared_init = torch.nn.ParameterList(A) self.parameterization = parameterization + self.offset = self.get_offset(offset, len(A)) if offset is not None else None + + def get_offset(self, offset: Union[int, Tuple[int]], n: int): + if type(offset) is tuple or type(offset) is list: + if type(offset[0]) is tuple or type(offset[0]) is list: + assert len(offset) == n and all( + [len(o) == 4 for o in t] for t in offset + ) + else: + assert len(offset) >= 1 and len(offset) <= 4 + offset = [([0] * (4 - len(offset))) + list(offset)] * n + else: + offset = [[offset] * 4] * n + offset = [[int(o) for o in v] for v in offset] + return offset + + def apply_offset( + self, x_list: List[torch.Tensor], size: Tuple[int] + ) -> List[torch.Tensor]: + assert len(size) == 4 + A = [] + for x, offset in zip(x_list, self.offset): + x = F.pad(x, offset, "reflect") + x = x[:size[0], :size[1], :size[2], :size[3]] + A.append(x) + return A def interpolate_tensor( self, x: torch.Tensor, size: InitSize, batch: int, channels: int @@ -403,6 +430,8 @@ def forward(self) -> torch.Tensor: ) for shared_tensor in self.shared_init ] + if self.offset is not None: + x = self.apply_offset(x, tuple(image.size())) return (image + sum(x)).refine_names("B", "C", "H", "W") From 98a5f7c6e4235b07e1c14e02967f5ff0ab0aecb0 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 1 Dec 2020 10:10:41 -0700 Subject: [PATCH 06/76] Add missing type hint --- captum/optim/_param/image/images.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index bf801da4ca..13ee8e79f7 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -369,7 +369,7 @@ def __init__( self.parameterization = parameterization self.offset = self.get_offset(offset, len(A)) if offset is not None else None - def get_offset(self, offset: Union[int, Tuple[int]], n: int): + def get_offset(self, offset: Union[int, Tuple[int]], n: int) -> Tuple[Tuple[int]]: if type(offset) is tuple or type(offset) is list: if type(offset[0]) is tuple or type(offset[0]) is list: assert len(offset) == n and all( @@ -390,7 +390,7 @@ def apply_offset( A = [] for x, offset in zip(x_list, self.offset): x = F.pad(x, offset, "reflect") - x = x[:size[0], :size[1], :size[2], :size[3]] + x = x[: size[0], : size[1], : size[2], : size[3]] A.append(x) return A From ae944267ab286fa2e18e1a03dcda8e5a7ce63fd6 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 1 Dec 2020 10:13:45 -0700 Subject: [PATCH 07/76] Fix type hint --- captum/optim/_param/image/images.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 13ee8e79f7..1c114f94d0 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -369,7 +369,7 @@ def __init__( self.parameterization = parameterization self.offset = self.get_offset(offset, len(A)) if offset is not None else None - def get_offset(self, offset: Union[int, Tuple[int]], n: int) -> Tuple[Tuple[int]]: + def get_offset(self, offset: Union[int, Tuple[int]], n: int) -> List[List[int]]: if type(offset) is tuple or type(offset) is list: if type(offset[0]) is tuple or type(offset[0]) is list: assert len(offset) == n and all( From 6baf6c189043370ab62389c3fd27c48f67884c18 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 1 Dec 2020 10:18:13 -0700 Subject: [PATCH 08/76] Correct type hint --- captum/optim/_param/image/images.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 1c114f94d0..a108e1605d 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -353,7 +353,7 @@ def __init__( self, shared_shapes: Union[Tuple[Tuple[int]], Tuple[int]] = None, parameterization=None, - offset: Optional[int, Tuple[int]] = None, + offset: Optional[int, Tuple[int], Tuple[Tuple[int]]] = None, ) -> None: super().__init__() A = [] From 29148da71b664683a8b443d0fbb480fb2f3243df Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 1 Dec 2020 14:07:01 -0700 Subject: [PATCH 09/76] Remove Optional from type hint --- captum/optim/_param/image/images.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index a108e1605d..22fd8e9b65 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -353,7 +353,7 @@ def __init__( self, shared_shapes: Union[Tuple[Tuple[int]], Tuple[int]] = None, parameterization=None, - offset: Optional[int, Tuple[int], Tuple[Tuple[int]]] = None, + offset: Union[int, Tuple[int], Tuple[Tuple[int]], None] = None, ) -> None: super().__init__() A = [] From 0e327cd029d0a936b737d6559b91909321a4d5ac Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 8 Dec 2020 08:48:50 -0700 Subject: [PATCH 10/76] Fix size mismatch when FFTImage init height > width * This issue may not occur with every image. * I'll see about reporting the issue to PyTorch. --- captum/optim/_param/image/images.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 22fd8e9b65..ca133f258d 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -219,7 +219,16 @@ def __init__( ) # names=["C", "H_f", "W_f", "complex"] fourier_coeffs = random_coeffs / 50 else: - fourier_coeffs = torch.rfft(init, signal_ndim=2) / spectrum_scale + fourier_coeffs = torch.rfft(init, signal_ndim=2) + w = ( + spectrum_scale.size(2) - fourier_coeffs.size(3) + if init.dim() == 4 + else spectrum_scale.size(2) - fourier_coeffs.size(2) + ) + self.spectrum_scale = ( + spectrum_scale[:, :, w:, :] if w > 0 else self.spectrum_scale + ) + fourier_coeffs = fourier_coeffs / self.spectrum_scale fourier_coeffs = self.setup_batch(fourier_coeffs, batch, 4) self.fourier_coeffs = nn.Parameter(fourier_coeffs) From ac4954c81e7350264fb71021eddc3fcb0799e48b Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 9 Dec 2020 08:30:54 -0700 Subject: [PATCH 11/76] Add tests for SharedImage & 2 new transforms --- tests/optim/param/test_images.py | 265 +++++++++++++++++++++++++++ tests/optim/param/test_transforms.py | 17 ++ 2 files changed, 282 insertions(+) diff --git a/tests/optim/param/test_images.py b/tests/optim/param/test_images.py index 2f8c308621..027869b27e 100644 --- a/tests/optim/param/test_images.py +++ b/tests/optim/param/test_images.py @@ -242,5 +242,270 @@ def test_laplacianimage_random_forward(self) -> None: self.assertEqual(test_tensor.size(3), size[1]) +class TestSharedImage(BaseTest): + def test_sharedimage_get_offset_single_number(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param + ) + + offset = image_param.get_offset(4, 3) + + self.assertEqual(len(offset), 4) + self.assertEqual(offset, [[4, 4, 4, 4]] * 3) + + def test_sharedimage_get_offset_exact(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param + ) + + offset_vals = ((1, 2, 3, 4), (4, 3, 2, 1), (1, 2, 3, 4)) + offset = image_param.get_offset(offset_vals, 3) + + self.assertEqual(len(offset), 4) + self.assertEqual(offset, [[int(o) for o in v] for v in offset_vals]) + + def test_sharedimage_apply_offset_single_set_four_numbers(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param + ) + + offset_vals = [(1, 2, 3, 4)] + offset = image_param.get_offset(offset_vals, 3) + + self.assertEqual(len(offset), 4) + self.assertEqual(offset, [[int(o) for o in v] for v in offset_vals * 3]) + + def test_sharedimage_apply_offset_single_set_three_numbers(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param + ) + + offset_vals = [(2, 3, 4)] + offset = image_param.get_offset(offset_vals, 3) + + self.assertEqual(len(offset), 4) + self.assertEqual(offset, [[0] + [int(o) for o in v] for v in offset_vals * 3]) + + def test_sharedimage_apply_offset_single_set_two_numbers(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param + ) + + offset_vals = [(3, 4)] + offset = image_param.get_offset(offset_vals, 3) + + self.assertEqual(len(offset), 4) + self.assertEqual( + offset, [[0, 0] + [int(o) for o in v] for v in offset_vals * 3] + ) + + def test_apply_offset(self): + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + size = (4, 3, 224, 224) + shared_shapes = (128 // 2, 128 // 2) + offset_vals = (2, 3, 4, 5) + test_param = lambda: torch.ones(*size) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param, offset=offset_vals + ) + + test_x_list = [torch.ones(*size) for x in range(size[0])] + output_A = image_param.apply_offset(test_x_list, size) + + x_list = [torch.ones(*size) for x in range(size[0])] + offset_list = image_param.offset + expected_A = [] + for x, offset in zip(x_list, offset_list): + x = F.pad(x, offset, "reflect") + x = x[: size[0], : size[1], : size[2], : size[3]] + expected_A.append(x) + + for t_expected, t_output in zip(expected_A, output_A): + assertTensorAlmostEqual(self, t_expected, t_output) + + def test_interpolate_tensor(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + shared_shapes = (128 // 2, 128 // 2) + test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param + ) + + size = (224, 224) + channels = 3 + batch = 1 + + test_tensor = torch.ones(6, 4, 128, 128) + output_tensor = image_param.interpolate_tensor( + test_tensor, size, batch, channels + ) + + self.assertEqual(output_tensor.dim(), 4) + self.assertEqual(output_tensor.size(0), batch) + self.assertEqual(output_tensor.size(1), channels) + self.assertEqual(output_tensor.size(2), size[0]) + self.assertEqual(output_tensor.size(3), size[1]) + + def test_sharedimage_single_shape_hw_forward(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + + shared_shapes = (128 // 2, 128 // 2) + batch = 6 + channels = 3 + size = (224, 224) + test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param + ) + test_tensor = image_param.forward() + + self.assertEqual(test_tensor.dim(), 4) + self.assertEqual(test_tensor.size(0), 1) + self.assertEqual(test_tensor.size(1), channels) + self.assertEqual(test_tensor.size(2), size[0]) + self.assertEqual(test_tensor.size(3), size[1]) + + def test_sharedimage_single_shape_chw_forward(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + + shared_shapes = (3, 128 // 2, 128 // 2) + batch = 6 + channels = 3 + size = (224, 224) + test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param + ) + test_tensor = image_param.forward() + + self.assertEqual(test_tensor.dim(), 4) + self.assertEqual(test_tensor.size(0), 1) + self.assertEqual(test_tensor.size(1), channels) + self.assertEqual(test_tensor.size(2), size[0]) + self.assertEqual(test_tensor.size(3), size[1]) + + def test_sharedimage_single_shape_bchw_forward(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + + shared_shapes = (1, 3, 128 // 2, 128 // 2) + batch = 6 + channels = 3 + size = (224, 224) + test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param + ) + test_tensor = image_param.forward() + + self.assertEqual(test_tensor.dim(), 4) + self.assertEqual(test_tensor.size(0), 1) + self.assertEqual(test_tensor.size(1), channels) + self.assertEqual(test_tensor.size(2), size[0]) + self.assertEqual(test_tensor.size(3), size[1]) + + def test_sharedimage_multiple_shapes_forward(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + + shared_shapes = ( + (1, 3, 128 // 2, 128 // 2), + (1, 3, 128 // 4, 128 // 4), + (1, 3, 128 // 8, 128 // 8), + (2, 3, 128 // 8, 128 // 8), + (1, 3, 128 // 16, 128 // 16), + (2, 3, 128 // 16, 128 // 16), + ) + batch = 6 + channels = 3 + size = (224, 224) + test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param + ) + test_tensor = image_param.forward() + + self.assertEqual(test_tensor.dim(), 4) + self.assertEqual(test_tensor.size(0), batch) + self.assertEqual(test_tensor.size(1), channels) + self.assertEqual(test_tensor.size(2), size[0]) + self.assertEqual(test_tensor.size(3), size[1]) + + def test_sharedimage_multiple_shapes_diff_len_forward(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping SharedImage test due to insufficient Torch version." + ) + + shared_shapes = ( + (128 // 2, 128 // 2), + (7, 3, 128 // 4, 128 // 4), + (3, 128 // 8, 128 // 8), + (2, 4, 128 // 8, 128 // 8), + (1, 3, 128 // 16, 128 // 16), + (2, 2, 128 // 16, 128 // 16), + ) + batch = 6 + channels = 3 + size = (224, 224) + test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 + image_param = images.SharedImage( + shared_shapes=shared_shapes, parameterization=test_param + ) + test_tensor = image_param.forward() + + self.assertEqual(test_tensor.dim(), 4) + self.assertEqual(test_tensor.size(0), batch) + self.assertEqual(test_tensor.size(1), channels) + self.assertEqual(test_tensor.size(2), size[0]) + self.assertEqual(test_tensor.size(3), size[1]) + + if __name__ == "__main__": unittest.main() diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index d3bef26a25..8b52edf6d9 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -344,5 +344,22 @@ def test_gaussian_smoothing_3d(self) -> None: self.assertGreaterEqual(t_min, 3.3377e-06) +class TestScaleInputRange(BaseTest): + def test_scale_input_range(self) -> None: + x = torch.ones(1, 3, 4, 4) + scale_input = transform.ScaleInputRange(255) + output_tensor = scale_input(x) + self.assertEqual(output_tensor.mean(), 255.0) + + +class TestRGBToBGR(BaseTest): + def test_rgb_to_bgr(self) -> None: + x = torch.randn(1, 3, 224, 224) + rgb_to_bgr = transform.RGBToBGR() + output_tensor = rgb_to_bgr(x) + expected_x = x[:, [2, 1, 0]] + assertTensorAlmostEqual(self, output_tensor, expected_x) + + if __name__ == "__main__": unittest.main() From 6510d8f9ff7d3e133f2635fd42b361657a97d256 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 11 Dec 2020 13:50:12 -0700 Subject: [PATCH 12/76] Preliminary circuit functions, fixes, & param name change --- captum/optim/_param/image/images.py | 10 ++-- captum/optim/_utils/circuits.py | 84 +++++++++++++++++++++++++++++ tests/optim/helpers/numpy_image.py | 6 +-- tests/optim/param/test_images.py | 62 ++++++++++----------- tests/optim/utils/test_circuits.py | 60 +++++++++++++++++++++ 5 files changed, 182 insertions(+), 40 deletions(-) create mode 100644 captum/optim/_utils/circuits.py create mode 100644 tests/optim/utils/test_circuits.py diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 3895c2a145..992375d13f 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -373,15 +373,13 @@ class SharedImage(ImageParameterization): def __init__( self, - shared_shapes: Union[Tuple[Tuple[int]], Tuple[int]] = None, + shapes: Union[Tuple[Tuple[int]], Tuple[int]] = None, parameterization=None, offset: Union[int, Tuple[int], Tuple[Tuple[int]], None] = None, ) -> None: super().__init__() A = [] - shared_shapes = ( - [shared_shapes] if type(shared_shapes[0]) is not tuple else shared_shapes - ) + shared_shapes = [shapes] if type(shapes[0]) is not tuple else shapes for shape in shared_shapes: assert len(shape) >= 2 and len(shape) <= 4 shape = ([1] * (4 - len(shape))) + list(shape) @@ -394,9 +392,7 @@ def __init__( def get_offset(self, offset: Union[int, Tuple[int]], n: int) -> List[List[int]]: if type(offset) is tuple or type(offset) is list: if type(offset[0]) is tuple or type(offset[0]) is list: - assert len(offset) == n and all( - [len(o) == 4 for o in t] for t in offset - ) + assert len(offset) == n and all(len(t) == 4 for t in offset) else: assert len(offset) >= 1 and len(offset) <= 4 offset = [([0] * (4 - len(offset))) + list(offset)] * n diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py new file mode 100644 index 0000000000..23abb59679 --- /dev/null +++ b/captum/optim/_utils/circuits.py @@ -0,0 +1,84 @@ +from contextlib import suppress +from typing import List, Union + +import torch +import torch.nn as nn + +from captum.optim._core.output_hook import AbortForwardException, ModuleOutputsHook +from captum.optim._utils.typing import ModuleOutputMapping + + +def max2avg_pool(model) -> None: + """ + Convert MaxPool2d layers to their AvgPool2d equivalents. + """ + + for name, child in model._modules.items(): + if isinstance(child, nn.MaxPool2d): + new_layer = nn.AvgPool2d( + kernel_size=child.kernel_size, + stride=child.stride, + padding=child.padding, + ceil_mode=child.ceil_mode, + ) + setattr(model, name, new_layer) + elif child is not None: + max2avg_pool(child) + + +class ActivationCatcher(object): + """ + Simple module for collecting activations from model targets. + """ + + def __init__(self, targets: Union[nn.Module, List[nn.Module]]) -> None: + super(ActivationCatcher, self).__init__() + self.layers = ModuleOutputsHook(targets) + + def __call__(self, model, input_t: torch.Tensor) -> ModuleOutputMapping: + try: + with suppress(AbortForwardException): + model(input_t) + activations = self.layers.consume_outputs() + self.layers.remove_hooks() + return activations + except (Exception, BaseException) as e: + self.layers.remove_hooks() + raise e + + +def get_expanded_weights(model, target1: nn.Module, target2: nn.Module) -> torch.Tensor: + """ + Extract meaningful weight interactions from between neurons which aren’t + literally adjacent in a neural network, or where the weights aren’t directly + represented in a single weight tensor. + + Schubert, et al., "Visualizing Weights", Distill, 2020. + See: https://distill.pub/2020/circuits-visualizing-weights/ + """ + + def get_activations( + model, targets: Union[nn.Module, List[nn.Module]] + ) -> ModuleOutputMapping: + catch_activ = ActivationCatcher(targets) + activ_out = catch_activ(model, torch.zeros(1, 3, 224, 224)) + return activ_out + + activations = get_activations(model, [target1, target2]) + activ1 = activations[target1] + activ2 = activations[target2] + + t_offset = (activ2.size(2) - 1) // 2 + t_center = activ2[0, :, t_offset, t_offset] + + A = [] + for i in range(activ2.size(1)): + x = torch.autograd.grad( + outputs=t_center[i], + inputs=[activ1], + grad_outputs=torch.ones_like(t_center[i]), + retain_graph=True, + )[0] + A.append(x) + + return torch.stack(A) diff --git a/tests/optim/helpers/numpy_image.py b/tests/optim/helpers/numpy_image.py index c3d55029a5..08e397446e 100644 --- a/tests/optim/helpers/numpy_image.py +++ b/tests/optim/helpers/numpy_image.py @@ -53,7 +53,6 @@ def __init__( fourier_coeffs = ( np.fft.rfftn(init, s=self.size).view("(2,)float") / spectrum_scale ) - fourier_coeffs = fourier_coeffs / spectrum_scale fourier_coeffs = setup_batch(fourier_coeffs, batch, 4) self.fourier_coeffs = fourier_coeffs @@ -74,5 +73,6 @@ def set_image(self, correlated_image: np.ndarray) -> None: def forward(self) -> np.ndarray: h, w = self.size scaled_spectrum = self.fourier_coeffs * self.spectrum_scale - output = np.fft.rfftn(scaled_spectrum, s=self.size) - return output.view(dtype=np.complex128)[..., 0] + scaled_spectrum = scaled_spectrum.astype(complex) + output = np.fft.irfftn(scaled_spectrum, s=self.size) + return output.view(dtype=np.complex128)[..., 0].real diff --git a/tests/optim/param/test_images.py b/tests/optim/param/test_images.py index 027869b27e..3593b6cf87 100644 --- a/tests/optim/param/test_images.py +++ b/tests/optim/param/test_images.py @@ -3,6 +3,7 @@ import numpy as np import torch +import torch.nn.functional as F from captum.optim._param.image import images from tests.helpers.basic import ( @@ -77,7 +78,7 @@ def test_fftimage_forward_init_randn_batch(self) -> None: "Skipping FFTImage test due to insufficient Torch version." ) size = (224, 224) - batch = 5 + batch = 2 fftimage = images.FFTImage(size=size, batch=batch) fftimage_np = numpy_image.FFTImage(size=size, batch=batch) @@ -119,6 +120,7 @@ def test_fftimage_forward_init_chw(self) -> None: fftimage_array = fftimage_np.forward() self.assertEqual(fftimage_tensor.detach().numpy().shape, fftimage_array.shape) + assertArraysAlmostEqual(fftimage_tensor.detach().numpy(), fftimage_array, 25.0) def test_fftimage_forward_init_bchw(self) -> None: if torch.__version__ == "1.2.0": @@ -136,6 +138,7 @@ def test_fftimage_forward_init_bchw(self) -> None: fftimage_array = fftimage_np.forward() self.assertEqual(fftimage_tensor.detach().numpy().shape, fftimage_array.shape) + assertArraysAlmostEqual(fftimage_tensor.detach().numpy(), fftimage_array, 25.0) def test_fftimage_forward_init_batch(self) -> None: if torch.__version__ == "1.2.0": @@ -143,7 +146,7 @@ def test_fftimage_forward_init_batch(self) -> None: "Skipping FFTImage test due to insufficient Torch version." ) size = (224, 224) - batch = 5 + batch = 2 init_tensor = torch.randn(1, 3, 224, 224) init_array = init_tensor.numpy() @@ -154,6 +157,7 @@ def test_fftimage_forward_init_batch(self) -> None: fftimage_array = fftimage_np.forward() self.assertEqual(fftimage_tensor.detach().numpy().shape, fftimage_array.shape) + assertArraysAlmostEqual(fftimage_tensor.detach().numpy(), fftimage_array, 25.0) class TestPixelImage(BaseTest): @@ -251,12 +255,12 @@ def test_sharedimage_get_offset_single_number(self) -> None: shared_shapes = (128 // 2, 128 // 2) test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param + shapes=shared_shapes, parameterization=test_param ) offset = image_param.get_offset(4, 3) - self.assertEqual(len(offset), 4) + self.assertEqual(len(offset), 3) self.assertEqual(offset, [[4, 4, 4, 4]] * 3) def test_sharedimage_get_offset_exact(self) -> None: @@ -267,13 +271,13 @@ def test_sharedimage_get_offset_exact(self) -> None: shared_shapes = (128 // 2, 128 // 2) test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param + shapes=shared_shapes, parameterization=test_param ) offset_vals = ((1, 2, 3, 4), (4, 3, 2, 1), (1, 2, 3, 4)) offset = image_param.get_offset(offset_vals, 3) - self.assertEqual(len(offset), 4) + self.assertEqual(len(offset), 3) self.assertEqual(offset, [[int(o) for o in v] for v in offset_vals]) def test_sharedimage_apply_offset_single_set_four_numbers(self) -> None: @@ -284,14 +288,14 @@ def test_sharedimage_apply_offset_single_set_four_numbers(self) -> None: shared_shapes = (128 // 2, 128 // 2) test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param + shapes=shared_shapes, parameterization=test_param ) - offset_vals = [(1, 2, 3, 4)] + offset_vals = (1, 2, 3, 4) offset = image_param.get_offset(offset_vals, 3) - self.assertEqual(len(offset), 4) - self.assertEqual(offset, [[int(o) for o in v] for v in offset_vals * 3]) + self.assertEqual(len(offset), 3) + self.assertEqual(offset, [list(offset_vals)] * 3) def test_sharedimage_apply_offset_single_set_three_numbers(self) -> None: if torch.__version__ == "1.2.0": @@ -301,14 +305,14 @@ def test_sharedimage_apply_offset_single_set_three_numbers(self) -> None: shared_shapes = (128 // 2, 128 // 2) test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param + shapes=shared_shapes, parameterization=test_param ) - offset_vals = [(2, 3, 4)] + offset_vals = (2, 3, 4) offset = image_param.get_offset(offset_vals, 3) - self.assertEqual(len(offset), 4) - self.assertEqual(offset, [[0] + [int(o) for o in v] for v in offset_vals * 3]) + self.assertEqual(len(offset), 3) + self.assertEqual(offset, [[0] + list(offset_vals)] * 3) def test_sharedimage_apply_offset_single_set_two_numbers(self) -> None: if torch.__version__ == "1.2.0": @@ -318,16 +322,14 @@ def test_sharedimage_apply_offset_single_set_two_numbers(self) -> None: shared_shapes = (128 // 2, 128 // 2) test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param + shapes=shared_shapes, parameterization=test_param ) - offset_vals = [(3, 4)] + offset_vals = (3, 4) offset = image_param.get_offset(offset_vals, 3) - self.assertEqual(len(offset), 4) - self.assertEqual( - offset, [[0, 0] + [int(o) for o in v] for v in offset_vals * 3] - ) + self.assertEqual(len(offset), 3) + self.assertEqual(offset, [[0, 0] + list(offset_vals)] * 3) def test_apply_offset(self): if torch.__version__ == "1.2.0": @@ -339,7 +341,7 @@ def test_apply_offset(self): offset_vals = (2, 3, 4, 5) test_param = lambda: torch.ones(*size) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param, offset=offset_vals + shapes=shared_shapes, parameterization=test_param, offset=offset_vals ) test_x_list = [torch.ones(*size) for x in range(size[0])] @@ -364,7 +366,7 @@ def test_interpolate_tensor(self) -> None: shared_shapes = (128 // 2, 128 // 2) test_param = lambda: torch.ones(3, 3, 224, 224) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param + shapes=shared_shapes, parameterization=test_param ) size = (224, 224) @@ -394,12 +396,12 @@ def test_sharedimage_single_shape_hw_forward(self) -> None: size = (224, 224) test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param + shapes=shared_shapes, parameterization=test_param ) test_tensor = image_param.forward() self.assertEqual(test_tensor.dim(), 4) - self.assertEqual(test_tensor.size(0), 1) + self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) self.assertEqual(test_tensor.size(2), size[0]) self.assertEqual(test_tensor.size(3), size[1]) @@ -416,12 +418,12 @@ def test_sharedimage_single_shape_chw_forward(self) -> None: size = (224, 224) test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param + shapes=shared_shapes, parameterization=test_param ) test_tensor = image_param.forward() self.assertEqual(test_tensor.dim(), 4) - self.assertEqual(test_tensor.size(0), 1) + self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) self.assertEqual(test_tensor.size(2), size[0]) self.assertEqual(test_tensor.size(3), size[1]) @@ -438,12 +440,12 @@ def test_sharedimage_single_shape_bchw_forward(self) -> None: size = (224, 224) test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param + shapes=shared_shapes, parameterization=test_param ) test_tensor = image_param.forward() self.assertEqual(test_tensor.dim(), 4) - self.assertEqual(test_tensor.size(0), 1) + self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) self.assertEqual(test_tensor.size(2), size[0]) self.assertEqual(test_tensor.size(3), size[1]) @@ -467,7 +469,7 @@ def test_sharedimage_multiple_shapes_forward(self) -> None: size = (224, 224) test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param + shapes=shared_shapes, parameterization=test_param ) test_tensor = image_param.forward() @@ -496,7 +498,7 @@ def test_sharedimage_multiple_shapes_diff_len_forward(self) -> None: size = (224, 224) test_param = lambda: torch.ones(batch, channels, size[0], size[1]) # noqa: E731 image_param = images.SharedImage( - shared_shapes=shared_shapes, parameterization=test_param + shapes=shared_shapes, parameterization=test_param ) test_tensor = image_param.forward() diff --git a/tests/optim/utils/test_circuits.py b/tests/optim/utils/test_circuits.py new file mode 100644 index 0000000000..050d942076 --- /dev/null +++ b/tests/optim/utils/test_circuits.py @@ -0,0 +1,60 @@ +#!/usr/bin/env python3 +import unittest + +import torch + +import captum.optim._utils.circuits as circuits +from captum.optim._models.inception_v1 import googlenet +from tests.helpers.basic import BaseTest + + +class TestReplaceLayers(BaseTest): + def test_activation_catcher(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping ActivationCatcher test due to insufficient Torch version." + ) + model = googlenet(pretrained=True) + try: + catch_activ = circuits.ActivationCatcher(targets=[model.mixed4d]) + activ_out = catch_activ(model, torch.zeros(1, 3, 224, 224)) + self.assertIsInstance(activ_out, dict) + test = True + except Exception: + test = False + self.assertTrue(test) + + +class TestMax2AvgPool(BaseTest): + def test_max2avg_pool(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping max2avg_pool test due to insufficient Torch version." + ) + model = googlenet(pretrained=True) + circuits.max2avg_pool(model) + check_is_not_instance(self, model, torch.nn.MaxPool2d) + + +class TestGetExpandedWeights(BaseTest): + def test_get_expanded_weights(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping get_expanded_weights test due to insufficient Torch version." + ) + model = googlenet(pretrained=True) + output_tensor = circuits.get_expanded_weights( + model, model.mixed4c, model.mixed4d + ) + self.assertTrue(torch.is_tensor(output_tensor)) + + +def check_is_not_instance(self, model, layer) -> None: + for name, child in model._modules.items(): + if child is not None: + self.assertNotIsInstance(child, layer) + check_is_not_instance(self, child, layer) + + +if __name__ == "__main__": + unittest.main() From 3df40bc50519de577126bf3a80fb1d1fe38fb192 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 11 Dec 2020 15:27:45 -0700 Subject: [PATCH 13/76] Add ChannelReducer --- captum/optim/_utils/reducer.py | 68 +++++++++++++++++++++++++++++++ tests/optim/utils/test_reducer.py | 27 ++++++++++++ 2 files changed, 95 insertions(+) create mode 100644 captum/optim/_utils/reducer.py create mode 100644 tests/optim/utils/test_reducer.py diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py new file mode 100644 index 0000000000..9c80c1ae12 --- /dev/null +++ b/captum/optim/_utils/reducer.py @@ -0,0 +1,68 @@ +from typing import Any, Callable + +try: + import sklearn.decomposition + from sklearn.base import BaseEstimator +except (ImportError, AssertionError): + print("The sklearn library is required to use Captum's ChannelReducer") +import torch + + +class ChannelReducer(object): + """ + Dimensionality reduction for the channel dimension of an input. + + Olah, et al., "The Building Blocks of Interpretability", Distill, 2018. + See: https://distill.pub/2018/building-blocks/ + """ + + def __init__( + self, n_components: int = 3, reduction_alg: Any = "NMF", **kwargs + ) -> None: + algorithm_map = {} + for name in dir(sklearn.decomposition): + obj = sklearn.decomposition.__getattribute__(name) + if isinstance(obj, type) and issubclass(obj, BaseEstimator): + algorithm_map[name] = obj + if isinstance(reduction_alg, str): + if reduction_alg in algorithm_map: + reduction_alg = algorithm_map[reduction_alg] + else: + raise ValueError( + "Unknown dimensionality reduction method '%s'." % reduction_alg + ) + + self.n_components = n_components + self._reducer = reduction_alg(n_components=n_components, **kwargs) + + @classmethod + def _apply_flat(cls, func: Callable, x: torch.Tensor) -> torch.Tensor: + orig_shape = x.shape + return func(x.reshape([-1, x.shape[-1]])).reshape(list(orig_shape[:-1]) + [-1]) + + def fit_transform(self, x: torch.Tensor) -> torch.Tensor: + """ + Move channels to channels last NumPy format + Assume first dimension is batch size except for shape CHW + """ + + if x.dim() == 3: + x = x.permute(2, 1, 0) + elif x.dim() > 3: + permute_vals = [0] + list(range(x.dim()))[2:] + [1] + x = x.permute(*permute_vals) + + x_out = torch.as_tensor( + ChannelReducer._apply_flat(self._reducer.fit_transform, x) + ) + + if x.dim() == 3: + x_out = x_out.permute(2, 1, 0) + elif x.dim() > 3: + permute_vals = ( + [0] + + [x.dim() - 1] + + list(range(x.dim()))[1 : len(list(range(x.dim()))) - 1] + ) + x_out = x_out.permute(*permute_vals) + return x_out diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py new file mode 100644 index 0000000000..cfe3b5e1c0 --- /dev/null +++ b/tests/optim/utils/test_reducer.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python3 +import unittest + +import torch + +from captum.optim._utils.reducer import ChannelReducer +from tests.helpers.basic import BaseTest + + +class TestChannelReducer(BaseTest): + def test_channelreducer(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer test" + ) + + test_input = torch.randn(1, 32, 224, 224).abs() + c_reducer = ChannelReducer(n_components=3, max_iter=100) + test_output = c_reducer.fit_transform(test_input) + self.assertEquals(test_output.size(1), 3) + + +if __name__ == "__main__": + unittest.main() From 0f5827257a885b584a001fe63718495ae40168bd Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 11 Dec 2020 15:43:15 -0700 Subject: [PATCH 14/76] Fix test name --- tests/optim/utils/test_circuits.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/optim/utils/test_circuits.py b/tests/optim/utils/test_circuits.py index 050d942076..74459982cb 100644 --- a/tests/optim/utils/test_circuits.py +++ b/tests/optim/utils/test_circuits.py @@ -8,7 +8,7 @@ from tests.helpers.basic import BaseTest -class TestReplaceLayers(BaseTest): +class TestActivationCatcher(BaseTest): def test_activation_catcher(self) -> None: if torch.__version__ == "1.2.0": raise unittest.SkipTest( From e5ede3a088bef40b4f3b9b2f97a67f06ed776cc6 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 11 Dec 2020 18:16:32 -0700 Subject: [PATCH 15/76] Reorganize new code --- captum/optim/__init__.py | 2 ++ captum/optim/_utils/circuits.py | 41 +------------------------- captum/optim/_utils/models.py | 42 +++++++++++++++++++++++++++ tests/optim/utils/test_circuits.py | 18 ------------ tests/optim/utils/test_model_utils.py | 22 ++++++++++++-- 5 files changed, 64 insertions(+), 61 deletions(-) diff --git a/captum/optim/__init__.py b/captum/optim/__init__.py index 0358aa9860..e1dc6509a5 100755 --- a/captum/optim/__init__.py +++ b/captum/optim/__init__.py @@ -7,3 +7,5 @@ from captum.optim._param.image import transform # noqa: F401 from captum.optim._param.image.images import ImageTensor # noqa: F401 from captum.optim._utils import models # noqa: F401 +from captum.optim._utils.circuits import get_expanded_weights # noqa: F401 +from captum.optim._utils.reducer import ChannelReducer # noqa: F401 diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index 23abb59679..4336cfc3a5 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -4,47 +4,8 @@ import torch import torch.nn as nn -from captum.optim._core.output_hook import AbortForwardException, ModuleOutputsHook from captum.optim._utils.typing import ModuleOutputMapping - - -def max2avg_pool(model) -> None: - """ - Convert MaxPool2d layers to their AvgPool2d equivalents. - """ - - for name, child in model._modules.items(): - if isinstance(child, nn.MaxPool2d): - new_layer = nn.AvgPool2d( - kernel_size=child.kernel_size, - stride=child.stride, - padding=child.padding, - ceil_mode=child.ceil_mode, - ) - setattr(model, name, new_layer) - elif child is not None: - max2avg_pool(child) - - -class ActivationCatcher(object): - """ - Simple module for collecting activations from model targets. - """ - - def __init__(self, targets: Union[nn.Module, List[nn.Module]]) -> None: - super(ActivationCatcher, self).__init__() - self.layers = ModuleOutputsHook(targets) - - def __call__(self, model, input_t: torch.Tensor) -> ModuleOutputMapping: - try: - with suppress(AbortForwardException): - model(input_t) - activations = self.layers.consume_outputs() - self.layers.remove_hooks() - return activations - except (Exception, BaseException) as e: - self.layers.remove_hooks() - raise e +from captum.optim._utils.circuits import ActivationCatcher def get_expanded_weights(model, target1: nn.Module, target2: nn.Module) -> torch.Tensor: diff --git a/captum/optim/_utils/models.py b/captum/optim/_utils/models.py index 810edfafb1..016afaec8b 100644 --- a/captum/optim/_utils/models.py +++ b/captum/optim/_utils/models.py @@ -5,6 +5,9 @@ import torch.nn as nn import torch.nn.functional as F +from captum.optim._core.output_hook import AbortForwardException, ModuleOutputsHook +from captum.optim._utils.typing import ModuleOutputMapping + def get_model_layers(model) -> List[str]: """ @@ -85,6 +88,24 @@ def replace_layers(model, old_layer=ReluLayer, new_layer=RedirectedReluLayer) -> replace_layers(child, old_layer, new_layer) +def max2avg_pool(model) -> None: + """ + Convert MaxPool2d layers to their AvgPool2d equivalents. + """ + + for name, child in model._modules.items(): + if isinstance(child, nn.MaxPool2d): + new_layer = nn.AvgPool2d( + kernel_size=child.kernel_size, + stride=child.stride, + padding=child.padding, + ceil_mode=child.ceil_mode, + ) + setattr(model, name, new_layer) + elif child is not None: + max2avg_pool(child) + + class LocalResponseNormLayer(nn.Module): """ Basic Hookable Local Response Norm layer. @@ -151,3 +172,24 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: self.dilation, self.groups, ) + + +class ActivationCatcher(object): + """ + Simple module for collecting activations from model targets. + """ + + def __init__(self, targets: Union[nn.Module, List[nn.Module]]) -> None: + super(ActivationCatcher, self).__init__() + self.layers = ModuleOutputsHook(targets) + + def __call__(self, model, input_t: torch.Tensor) -> ModuleOutputMapping: + try: + with suppress(AbortForwardException): + model(input_t) + activations = self.layers.consume_outputs() + self.layers.remove_hooks() + return activations + except (Exception, BaseException) as e: + self.layers.remove_hooks() + raise e diff --git a/tests/optim/utils/test_circuits.py b/tests/optim/utils/test_circuits.py index 74459982cb..7dca5ace56 100644 --- a/tests/optim/utils/test_circuits.py +++ b/tests/optim/utils/test_circuits.py @@ -25,17 +25,6 @@ def test_activation_catcher(self) -> None: self.assertTrue(test) -class TestMax2AvgPool(BaseTest): - def test_max2avg_pool(self) -> None: - if torch.__version__ == "1.2.0": - raise unittest.SkipTest( - "Skipping max2avg_pool test due to insufficient Torch version." - ) - model = googlenet(pretrained=True) - circuits.max2avg_pool(model) - check_is_not_instance(self, model, torch.nn.MaxPool2d) - - class TestGetExpandedWeights(BaseTest): def test_get_expanded_weights(self) -> None: if torch.__version__ == "1.2.0": @@ -49,12 +38,5 @@ def test_get_expanded_weights(self) -> None: self.assertTrue(torch.is_tensor(output_tensor)) -def check_is_not_instance(self, model, layer) -> None: - for name, child in model._modules.items(): - if child is not None: - self.assertNotIsInstance(child, layer) - check_is_not_instance(self, child, layer) - - if __name__ == "__main__": unittest.main() diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index e42bf19c5c..845a4d1417 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -71,6 +71,13 @@ def check_grad(self, grad_input, grad_output): assertTensorAlmostEqual(self, t_grad_input[0], t_grad_output[0], 0) +def check_is_not_instance(self, model, layer) -> None: + for name, child in model._modules.items(): + if child is not None: + self.assertNotIsInstance(child, layer) + check_is_not_instance(self, child, layer) + + class TestReplaceLayers(BaseTest): def test_replace_layers(self) -> None: class BasicReluModule(torch.nn.Module): @@ -97,13 +104,22 @@ def forward(self, input: torch.Tensor) -> torch.Tensor: # Unittest can't run replace_layers correctly? model_utils.replace_layers(toy_model.relu2, old_layer, new_layer) - self.assertNotIsInstance(toy_model.relu1, old_layer) + check_is_not_instance(self, toy_model, old_layer) self.assertIsInstance(toy_model.relu1, new_layer) - - self.assertNotIsInstance(toy_model.relu2.relu, old_layer) self.assertIsInstance(toy_model.relu2.relu, new_layer) +class TestMax2AvgPool(BaseTest): + def test_max2avg_pool(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping max2avg_pool test due to insufficient Torch version." + ) + model = googlenet(pretrained=True) + model_utils.max2avg_pool(model) + check_is_not_instance(self, model, torch.nn.MaxPool2d) + + class TestGetLayers(BaseTest): def test_get_layers_pretrained_inceptionv1(self) -> None: if torch.__version__ == "1.2.0": From f54a9893a51c4443ab8f181448fdddb3861b43ef Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 11 Dec 2020 18:20:46 -0700 Subject: [PATCH 16/76] Move ActivationCatcher test --- tests/optim/utils/test_circuits.py | 17 ----------------- tests/optim/utils/test_model_utils.py | 17 +++++++++++++++++ 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/tests/optim/utils/test_circuits.py b/tests/optim/utils/test_circuits.py index 7dca5ace56..aef375e52d 100644 --- a/tests/optim/utils/test_circuits.py +++ b/tests/optim/utils/test_circuits.py @@ -8,23 +8,6 @@ from tests.helpers.basic import BaseTest -class TestActivationCatcher(BaseTest): - def test_activation_catcher(self) -> None: - if torch.__version__ == "1.2.0": - raise unittest.SkipTest( - "Skipping ActivationCatcher test due to insufficient Torch version." - ) - model = googlenet(pretrained=True) - try: - catch_activ = circuits.ActivationCatcher(targets=[model.mixed4d]) - activ_out = catch_activ(model, torch.zeros(1, 3, 224, 224)) - self.assertIsInstance(activ_out, dict) - test = True - except Exception: - test = False - self.assertTrue(test) - - class TestGetExpandedWeights(BaseTest): def test_get_expanded_weights(self) -> None: if torch.__version__ == "1.2.0": diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index 845a4d1417..a22e8b424e 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -310,5 +310,22 @@ def test_get_layers_torchvision_alexnet(self) -> None: self.assertEqual(collected_layers, expected_list) +class TestActivationCatcher(BaseTest): + def test_activation_catcher(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping ActivationCatcher test due to insufficient Torch version." + ) + model = googlenet(pretrained=True) + try: + catch_activ = model_utils.ActivationCatcher(targets=[model.mixed4d]) + activ_out = catch_activ(model, torch.zeros(1, 3, 224, 224)) + self.assertIsInstance(activ_out, dict) + test = True + except Exception: + test = False + self.assertTrue(test) + + if __name__ == "__main__": unittest.main() From a3e1e60139c2bfdc4e076d68fbca44a6a429e8c7 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 11 Dec 2020 18:36:26 -0700 Subject: [PATCH 17/76] Forgot to move import --- captum/optim/_utils/circuits.py | 1 - captum/optim/_utils/models.py | 1 + 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index 4336cfc3a5..9f0e6fce59 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -1,4 +1,3 @@ -from contextlib import suppress from typing import List, Union import torch diff --git a/captum/optim/_utils/models.py b/captum/optim/_utils/models.py index 016afaec8b..1712997732 100644 --- a/captum/optim/_utils/models.py +++ b/captum/optim/_utils/models.py @@ -1,4 +1,5 @@ import math +from contextlib import suppress from typing import List, Tuple, Union import torch From 3da14cbcdd6cbac388b1663ffcd364942415ae63 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 11 Dec 2020 18:46:36 -0700 Subject: [PATCH 18/76] Fix import order --- captum/optim/_utils/circuits.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index 9f0e6fce59..f57c73552e 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -3,8 +3,8 @@ import torch import torch.nn as nn -from captum.optim._utils.typing import ModuleOutputMapping from captum.optim._utils.circuits import ActivationCatcher +from captum.optim._utils.typing import ModuleOutputMapping def get_expanded_weights(model, target1: nn.Module, target2: nn.Module) -> torch.Tensor: From 8ed6cd3e78fcd5af3c4e6198b1e5054a01886c03 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 11 Dec 2020 19:02:11 -0700 Subject: [PATCH 19/76] Fix import --- captum/optim/__init__.py | 3 +-- captum/optim/_utils/circuits.py | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/captum/optim/__init__.py b/captum/optim/__init__.py index e1dc6509a5..65ebdc6e95 100755 --- a/captum/optim/__init__.py +++ b/captum/optim/__init__.py @@ -6,6 +6,5 @@ from captum.optim._param.image import images # noqa: F401 from captum.optim._param.image import transform # noqa: F401 from captum.optim._param.image.images import ImageTensor # noqa: F401 -from captum.optim._utils import models # noqa: F401 -from captum.optim._utils.circuits import get_expanded_weights # noqa: F401 +from captum.optim._utils import circuits, models # noqa: F401 from captum.optim._utils.reducer import ChannelReducer # noqa: F401 diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index f57c73552e..2ff24db91c 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -3,7 +3,7 @@ import torch import torch.nn as nn -from captum.optim._utils.circuits import ActivationCatcher +from captum.optim._utils.models import ActivationCatcher from captum.optim._utils.typing import ModuleOutputMapping From 43ed0930b731e1a6fae0ab0916b522e1456db427 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 12 Dec 2020 13:24:27 -0700 Subject: [PATCH 20/76] Update inception_v1.py --- captum/optim/_models/inception_v1.py | 1 + 1 file changed, 1 insertion(+) diff --git a/captum/optim/_models/inception_v1.py b/captum/optim/_models/inception_v1.py index 8021b77d6c..aed16a0475 100644 --- a/captum/optim/_models/inception_v1.py +++ b/captum/optim/_models/inception_v1.py @@ -262,6 +262,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: c5x5 = self.conv_5x5_reduce(x) c5x5 = self.conv_5x5_reduce_relu(c5x5) + c5x5 = F.pad(c5x5, (2, 2, 2, 2)) c5x5 = self.conv_5x5(c5x5) c5x5 = self.conv_5x5_relu(c5x5) From 1c4f5339ca93acc9982eb86754f4107d73a1df09 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 12 Dec 2020 13:25:02 -0700 Subject: [PATCH 21/76] Update inception_v1.py --- captum/optim/_models/inception_v1.py | 1 - 1 file changed, 1 deletion(-) diff --git a/captum/optim/_models/inception_v1.py b/captum/optim/_models/inception_v1.py index aed16a0475..5e6cacb0fe 100644 --- a/captum/optim/_models/inception_v1.py +++ b/captum/optim/_models/inception_v1.py @@ -234,7 +234,6 @@ def __init__( out_channels=c5x5, kernel_size=(5, 5), stride=(1, 1), - padding=(2, 2), groups=1, bias=True, ) From c783a35e2546280491748a7e062eeddc51110cc1 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 12 Dec 2020 18:26:44 -0700 Subject: [PATCH 22/76] Fix model class & improvements --- captum/optim/_models/inception_v1.py | 8 ++++---- captum/optim/_utils/circuits.py | 24 ++++++++++++++++-------- captum/optim/_utils/reducer.py | 10 +++++----- 3 files changed, 25 insertions(+), 17 deletions(-) diff --git a/captum/optim/_models/inception_v1.py b/captum/optim/_models/inception_v1.py index 5e6cacb0fe..e378bb951b 100644 --- a/captum/optim/_models/inception_v1.py +++ b/captum/optim/_models/inception_v1.py @@ -67,7 +67,6 @@ def __init__( out_channels=64, kernel_size=(7, 7), stride=(2, 2), - padding=(3, 3), groups=1, bias=True, ) @@ -89,7 +88,6 @@ def __init__( out_channels=192, kernel_size=(3, 3), stride=(1, 1), - padding=(1, 1), groups=1, bias=True, ) @@ -132,6 +130,7 @@ def _transform_input(self, x: torch.Tensor) -> torch.Tensor: def forward(self, x: torch.Tensor) -> torch.Tensor: x = self._transform_input(x) + x = F.pad(x, (2, 3, 2, 3)) x = self.conv1(x) x = self.conv1_relu(x) x = F.pad(x, (0, 1, 0, 1), value=float("-inf")) @@ -140,6 +139,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.conv2(x) x = self.conv2_relu(x) + x = F.pad(x, (1, 1, 1, 1)) x = self.conv3(x) x = self.conv3_relu(x) x = self.localresponsenorm2(x) @@ -214,7 +214,6 @@ def __init__( out_channels=c3x3, kernel_size=(3, 3), stride=(1, 1), - padding=(1, 1), groups=1, bias=True, ) @@ -256,7 +255,8 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: c3x3 = self.conv_3x3_reduce(x) c3x3 = self.conv_3x3_reduce_relu(c3x3) - c3x3 = self.conv_3x3(c3x3) + c3x3 = F.pad(c3x3, (1, 1, 1, 1)) + c3x3 = self.conv_3x3(c3x3) c3x3 = self.conv_3x3_relu(c3x3) c5x5 = self.conv_5x5_reduce(x) diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index 2ff24db91c..3a2fdec545 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -7,38 +7,46 @@ from captum.optim._utils.typing import ModuleOutputMapping -def get_expanded_weights(model, target1: nn.Module, target2: nn.Module) -> torch.Tensor: +def get_expanded_weights( + model, + target1: nn.Module, + target2: nn.Module, + input: torch.Tensor = torch.zeros(1, 3, 224, 224), +) -> torch.Tensor: """ Extract meaningful weight interactions from between neurons which aren’t literally adjacent in a neural network, or where the weights aren’t directly represented in a single weight tensor. Schubert, et al., "Visualizing Weights", Distill, 2020. - See: https://distill.pub/2020/circuits-visualizing-weights/ + See: https://distill.pub/2020/circuits/visualizing-weights/ """ def get_activations( model, targets: Union[nn.Module, List[nn.Module]] ) -> ModuleOutputMapping: catch_activ = ActivationCatcher(targets) - activ_out = catch_activ(model, torch.zeros(1, 3, 224, 224)) + activ_out = catch_activ(model, input) return activ_out activations = get_activations(model, [target1, target2]) activ1 = activations[target1] activ2 = activations[target2] - t_offset = (activ2.size(2) - 1) // 2 - t_center = activ2[0, :, t_offset, t_offset] + if activ2.dim() == 4: + t_offset_h, t_offset_w = (activ2.size(2) - 1) // 2, (activ2.size(3) - 1) // 2 + t_center = activ2[:, :, t_offset_h, t_offset_w] + elif activ2.dim() == 2: + t_center = activ2 A = [] for i in range(activ2.size(1)): x = torch.autograd.grad( - outputs=t_center[i], + outputs=t_center[:, i], inputs=[activ1], - grad_outputs=torch.ones_like(t_center[i]), + grad_outputs=torch.ones_like(t_center[:, i]), retain_graph=True, )[0] A.append(x) - return torch.stack(A) + return torch.cat(A, dim=0) diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index 9c80c1ae12..e68c727173 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -40,15 +40,15 @@ def _apply_flat(cls, func: Callable, x: torch.Tensor) -> torch.Tensor: orig_shape = x.shape return func(x.reshape([-1, x.shape[-1]])).reshape(list(orig_shape[:-1]) + [-1]) - def fit_transform(self, x: torch.Tensor) -> torch.Tensor: + def fit_transform(self, x: torch.Tensor, reshape: bool = True) -> torch.Tensor: """ Move channels to channels last NumPy format Assume first dimension is batch size except for shape CHW """ - if x.dim() == 3: + if x.dim() == 3 and reshape: x = x.permute(2, 1, 0) - elif x.dim() > 3: + elif x.dim() > 3 and reshape: permute_vals = [0] + list(range(x.dim()))[2:] + [1] x = x.permute(*permute_vals) @@ -56,9 +56,9 @@ def fit_transform(self, x: torch.Tensor) -> torch.Tensor: ChannelReducer._apply_flat(self._reducer.fit_transform, x) ) - if x.dim() == 3: + if x.dim() == 3 and reshape: x_out = x_out.permute(2, 1, 0) - elif x.dim() > 3: + elif x.dim() > 3 and reshape: permute_vals = ( [0] + [x.dim() - 1] From 443ea1dc4da1f519c892c5d0ed3e846efe2f1067 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 12 Dec 2020 18:35:41 -0700 Subject: [PATCH 23/76] Fix model lint --- captum/optim/_models/inception_v1.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/captum/optim/_models/inception_v1.py b/captum/optim/_models/inception_v1.py index e378bb951b..b8f3b202bb 100644 --- a/captum/optim/_models/inception_v1.py +++ b/captum/optim/_models/inception_v1.py @@ -139,7 +139,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: x = self.conv2(x) x = self.conv2_relu(x) - x = F.pad(x, (1, 1, 1, 1)) + x = F.pad(x, (1, 1, 1, 1)) x = self.conv3(x) x = self.conv3_relu(x) x = self.localresponsenorm2(x) @@ -255,8 +255,8 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: c3x3 = self.conv_3x3_reduce(x) c3x3 = self.conv_3x3_reduce_relu(c3x3) - c3x3 = F.pad(c3x3, (1, 1, 1, 1)) - c3x3 = self.conv_3x3(c3x3) + c3x3 = F.pad(c3x3, (1, 1, 1, 1)) + c3x3 = self.conv_3x3(c3x3) c3x3 = self.conv_3x3_relu(c3x3) c5x5 = self.conv_5x5_reduce(x) From 55610ad679560182649cf5e82027f187f60af598 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 13 Dec 2020 11:12:39 -0700 Subject: [PATCH 24/76] Fix layer order in InceptionModule & fix expanded weights --- captum/optim/_models/inception_v1.py | 6 +++--- captum/optim/_utils/circuits.py | 7 +++---- 2 files changed, 6 insertions(+), 7 deletions(-) diff --git a/captum/optim/_models/inception_v1.py b/captum/optim/_models/inception_v1.py index b8f3b202bb..7fa6441720 100644 --- a/captum/optim/_models/inception_v1.py +++ b/captum/optim/_models/inception_v1.py @@ -265,10 +265,10 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: c5x5 = self.conv_5x5(c5x5) c5x5 = self.conv_5x5_relu(c5x5) - px = self.pool_proj(x) - px = self.pool_proj_relu(px) - px = F.pad(px, (1, 1, 1, 1), value=float("-inf")) + px = F.pad(x, (1, 1, 1, 1), value=float("-inf")) px = self.pool(px) + px = self.pool_proj(px) + px = self.pool_proj_relu(px) return torch.cat([c1x1, c3x3, c5x5, px], dim=1) diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index 3a2fdec545..da0093bc8c 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -11,7 +11,7 @@ def get_expanded_weights( model, target1: nn.Module, target2: nn.Module, - input: torch.Tensor = torch.zeros(1, 3, 224, 224), + model_input: torch.Tensor = torch.zeros(1, 3, 224, 224), ) -> torch.Tensor: """ Extract meaningful weight interactions from between neurons which aren’t @@ -26,7 +26,7 @@ def get_activations( model, targets: Union[nn.Module, List[nn.Module]] ) -> ModuleOutputMapping: catch_activ = ActivationCatcher(targets) - activ_out = catch_activ(model, input) + activ_out = catch_activ(model, model_input) return activ_out activations = get_activations(model, [target1, target2]) @@ -48,5 +48,4 @@ def get_activations( retain_graph=True, )[0] A.append(x) - - return torch.cat(A, dim=0) + return torch.stack(A, -1)[0] From cf88521a25650323245a55764b555e9294c3c9ab Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 13 Dec 2020 12:12:50 -0700 Subject: [PATCH 25/76] Add weight visualization tutorial --- tutorials/WeightVisualization_OptimViz.ipynb | 218 +++++++++++++++++++ 1 file changed, 218 insertions(+) create mode 100644 tutorials/WeightVisualization_OptimViz.ipynb diff --git a/tutorials/WeightVisualization_OptimViz.ipynb b/tutorials/WeightVisualization_OptimViz.ipynb new file mode 100644 index 0000000000..338d823492 --- /dev/null +++ b/tutorials/WeightVisualization_OptimViz.ipynb @@ -0,0 +1,218 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "WeightVisualization_OptimViz.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "VWy2Woand8P0" + }, + "source": [ + "# Visualizing weights with captum.optim\r\n", + "\r\n", + "This notebook demonstrates the use of the captum.optim submodule for visualizing the weights of the InceptionV1 model imported from Caffe." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GWrStkUVEbOC" + }, + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import torch\n", + "import torchvision\n", + "from captum.optim._models.inception_v1 import googlenet\n", + "\n", + "import captum.optim as optimviz\n", + "\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "model = googlenet(pretrained=True).to(device).eval()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rzb9RtdUfE_H" + }, + "source": [ + "For convenience, we can create helper functions for visualizing the weights of our model.\r\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "D46o5t8a4iVk" + }, + "source": [ + "import numpy as np\r\n", + "import matplotlib.pyplot as plt\r\n", + "\r\n", + "\r\n", + "def show(x: np.ndarray, scale: float = 255.0) -> None:\r\n", + " x = x * scale\r\n", + " plt.imshow(x.astype(np.uint8))\r\n", + " plt.axis(\"off\")\r\n", + " plt.show()\r\n", + "\r\n", + "def weight_heatmap(array: np.ndarray) -> np.ndarray:\r\n", + " def C(x: str) -> np.ndarray:\r\n", + " def H(x: str) -> float:\r\n", + " return int(x, 16) / 255.0\r\n", + "\r\n", + " return np.asarray([H(x[0:2]), H(x[2:4]), H(x[4:6])])\r\n", + "\r\n", + " def weight_color_scale(x: np.float32) -> np.float32:\r\n", + " if x < 0:\r\n", + " x = -x\r\n", + " if x < 0.5:\r\n", + " x = x * 2\r\n", + " return (1 - x) * C(\"f7f7f7\") + x * C(\"92c5de\")\r\n", + " else:\r\n", + " x = (x - 0.5) * 2\r\n", + " return (1 - x) * C(\"92c5de\") + x * C(\"0571b0\")\r\n", + " else:\r\n", + " if x < 0.5:\r\n", + " x = x * 2\r\n", + " return (1 - x) * C(\"f7f7f7\") + x * C(\"f4a582\")\r\n", + " else:\r\n", + " x = (x - 0.5) * 2\r\n", + " return (1 - x) * C(\"f4a582\") + x * C(\"ca0020\")\r\n", + "\r\n", + " return np.asarray([[weight_color_scale(x) for x in a] for a in array])" + ], + "execution_count": 63, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fMvQtKFEe9R8" + }, + "source": [ + "## Extracting Hidden Weights\r\n", + "\r\n", + "We can extract hidden weights with Captum.optim's get_expanded_weights function.\r\n", + "\r\n", + "Below we extract the hidden weights between layers mixed3a and mixed3b:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "IWbzbWvGTj0-" + }, + "source": [ + "W_3a_3b = optimviz.circuits.get_expanded_weights(test_model, test_model.mixed3a, test_model.mixed3b)" + ], + "execution_count": 64, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HnNDlOiFWMf7" + }, + "source": [ + "# Visualizing hidden-hidden weights\r\n", + "\r\n", + "We can visualize our newly collected hidden weights like so:" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 248 + }, + "id": "BiAXnE0zqyFP", + "outputId": "9f00a11a-e807-43fa-cd60-63dfaae17f92" + }, + "source": [ + "W_3a_3b_np = W_3a_3b.permute(1, 2, 0, 3).numpy()\r\n", + "show(weight_heatmap(W_3a_3b_np[:,:,147,379] / W_3a_3b_np[:,:,:,379].max()))" + ], + "execution_count": 65, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADpElEQVR4nO3dMW4TQRiAURwcYSQkwg2gSkhHT8FluAcNdIgz0HEAImquQBMKDoBEJNI4mIRkuYA9BYL4i3iv9K/xrmR9O5JHsmfTNN0Cena2fQPAeuKEKHFClDghSpwQNR8NV6uVr3LhH1ssFrN1r9s5IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROi5tu+gf/R8bflxtmPX1fDtU92Tobz6fvX8cWvLofjncOn4/VcGzsnRIkTosQJUeKEKHFClDghylHKFvy8nDbO9t+9Gq49fvlhON9/+3x88XsPxnMy7JwQJU6IEidEiROixAlR4oQocUKUc84tODh6vXH25cX74drDj2+G8+XjZ8P5ydnFcP5oOOU62TkhSpwQJU6IEidEiROixAlR4oQo55xbML9/d+Ps8PTTcO3yfPzTlnfm4+ft7m3P45vCJwVR4oQocUKUOCFKnBAlTogSJ0TNpmnzb6iuVqvNQ/7YtDzdOPt8tjtce7A3np+cj6+9vBj/xeDDvcX4DfjrFovFbN3rdk6IEidEiROixAlR4oQocUKUOCHKOSdsmXNOuGHECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocULUbJqmbd8DsIadE6LECVHihChxQpQ4IUqcEPUb26BFy1PevGwAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e1ZoZdYdVv0G" + }, + "source": [ + "# NMF Visualizations of hidden-hidden weights\r\n", + "\r\n", + "NMF and other dimensionality reduction alorgrithms can reveal the spaital structure of weights." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 248 + }, + "id": "rrT2Z3HiVDPt", + "outputId": "124f1bd5-a021-4a1b-e168-eb99b01195b1" + }, + "source": [ + "reducer = optimviz.ChannelReducer(3)\r\n", + "\r\n", + "W_3a_3b_posneg = np.concatenate([np.maximum(0, W_3a_3b_np), np.maximum(0, -W_3a_3b_np)], axis=2)\r\n", + "\r\n", + "W_nmf = reducer.fit_transform(torch.as_tensor(W_3a_3b_posneg[..., 320]), reshape=False).numpy()\r\n", + "W_nmf /= W_nmf.max()\r\n", + "show(W_nmf)" + ], + "execution_count": 66, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADo0lEQVR4nO3dP2oUcQCG4R0TBIUgkgiirReIgoW1YGPnQTyGheARvEAKewsrCxFS2mhhYyuCiv8CjhfY/QmSZN7g85T7ZXameRnIMOw0z/MK6Dm39AUA64kTosQJUeKEKHFC1PZonKbJv3LhhM3zPK373J0TosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFqe+kL+B/d2rm7cTv88XB47M7R/eH+ZffZ+Nxfnwz3w58vhzunx50TosQJUeKEKHFClDghSpwQNc3zvHmcps0j/+zXYDtcXR8eu7+6PdxfrC4P963V0+F+b7hyEuZ5ntZ97s4JUeKEKHFClDghSpwQJU6IEidEec65gDs3N2/v98fHXvq2Ndz3Xp0f7hePvg/35x/G5+f4ec4JZ4w4IUqcECVOiBInRIkTosQJUZ5zLuHx4J3LK5/Gxz74y3c/2h3v766O94M3fzkBx81zTjhjxAlR4oQocUKUOCFKnBAlTojyE4BLuPF54zS9HR86vR7vv/c+jv/g2oXxfjCeOT3unBAlTogSJ0SJE6LECVHihChxQpT3OWFh3ueEM0acECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0RN8zwvfQ3AGu6cECVOiBInRIkTosQJUeKEqD/qn0dGD/xY6AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file From 50ac26f64dafa284a6975dc219db4f841fbac5b0 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 13 Dec 2020 12:18:02 -0700 Subject: [PATCH 26/76] Change some tutorial text --- tutorials/WeightVisualization_OptimViz.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/tutorials/WeightVisualization_OptimViz.ipynb b/tutorials/WeightVisualization_OptimViz.ipynb index 338d823492..c08bb736c1 100644 --- a/tutorials/WeightVisualization_OptimViz.ipynb +++ b/tutorials/WeightVisualization_OptimViz.ipynb @@ -98,7 +98,7 @@ "\r\n", " return np.asarray([[weight_color_scale(x) for x in a] for a in array])" ], - "execution_count": 63, + "execution_count": null, "outputs": [] }, { @@ -122,7 +122,7 @@ "source": [ "W_3a_3b = optimviz.circuits.get_expanded_weights(test_model, test_model.mixed3a, test_model.mixed3b)" ], - "execution_count": 64, + "execution_count": null, "outputs": [] }, { @@ -133,7 +133,7 @@ "source": [ "# Visualizing hidden-hidden weights\r\n", "\r\n", - "We can visualize our newly collected hidden weights like so:" + "We can visualize our newly collected expanded weights like so:" ] }, { @@ -150,7 +150,7 @@ "W_3a_3b_np = W_3a_3b.permute(1, 2, 0, 3).numpy()\r\n", "show(weight_heatmap(W_3a_3b_np[:,:,147,379] / W_3a_3b_np[:,:,:,379].max()))" ], - "execution_count": 65, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -197,7 +197,7 @@ "W_nmf /= W_nmf.max()\r\n", "show(W_nmf)" ], - "execution_count": 66, + "execution_count": null, "outputs": [ { "output_type": "display_data", From 206880d7a3dac9d52d7454c659d66ba80c1ae610 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 13 Dec 2020 13:16:49 -0700 Subject: [PATCH 27/76] Improve ChannelReducer * sklearn is no longer required to use the ChannelReducer! Though you'll have to supply your own reduction algorithm. * NumPy arrays can now be transformed in addition to PyTorch tensors. * Better descriptions and warning messages. --- captum/optim/_utils/models.py | 18 ----- captum/optim/_utils/reducer.py | 96 +++++++++++++++++---------- tests/optim/utils/test_model_utils.py | 11 --- 3 files changed, 62 insertions(+), 63 deletions(-) diff --git a/captum/optim/_utils/models.py b/captum/optim/_utils/models.py index 1712997732..cb0b3856a1 100644 --- a/captum/optim/_utils/models.py +++ b/captum/optim/_utils/models.py @@ -89,24 +89,6 @@ def replace_layers(model, old_layer=ReluLayer, new_layer=RedirectedReluLayer) -> replace_layers(child, old_layer, new_layer) -def max2avg_pool(model) -> None: - """ - Convert MaxPool2d layers to their AvgPool2d equivalents. - """ - - for name, child in model._modules.items(): - if isinstance(child, nn.MaxPool2d): - new_layer = nn.AvgPool2d( - kernel_size=child.kernel_size, - stride=child.stride, - padding=child.padding, - ceil_mode=child.ceil_mode, - ) - setattr(model, name, new_layer) - elif child is not None: - max2avg_pool(child) - - class LocalResponseNormLayer(nn.Module): """ Basic Hookable Local Response Norm layer. diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index e68c727173..d3fadf6111 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -1,10 +1,15 @@ -from typing import Any, Callable +from typing import Any, Callable, Union + +import numpy as np try: import sklearn.decomposition from sklearn.base import BaseEstimator except (ImportError, AssertionError): - print("The sklearn library is required to use Captum's ChannelReducer") + print( + "The sklearn library is required to use Captum's ChannelReducer" + + " unless you supply your own reduction algorithm." + ) import torch @@ -19,18 +24,20 @@ class ChannelReducer(object): def __init__( self, n_components: int = 3, reduction_alg: Any = "NMF", **kwargs ) -> None: - algorithm_map = {} - for name in dir(sklearn.decomposition): - obj = sklearn.decomposition.__getattribute__(name) - if isinstance(obj, type) and issubclass(obj, BaseEstimator): - algorithm_map[name] = obj - if isinstance(reduction_alg, str): - if reduction_alg in algorithm_map: - reduction_alg = algorithm_map[reduction_alg] - else: - raise ValueError( - "Unknown dimensionality reduction method '%s'." % reduction_alg - ) + if not callable(reduction_alg): + algorithm_map = {} + for name in dir(sklearn.decomposition): + obj = sklearn.decomposition.__getattribute__(name) + if isinstance(obj, type) and issubclass(obj, BaseEstimator): + algorithm_map[name] = obj + if isinstance(reduction_alg, str): + if reduction_alg in algorithm_map: + reduction_alg = algorithm_map[reduction_alg] + else: + raise ValueError( + "Unknown sklearn dimensionality reduction method '%s'." + % reduction_alg + ) self.n_components = n_components self._reducer = reduction_alg(n_components=n_components, **kwargs) @@ -40,29 +47,50 @@ def _apply_flat(cls, func: Callable, x: torch.Tensor) -> torch.Tensor: orig_shape = x.shape return func(x.reshape([-1, x.shape[-1]])).reshape(list(orig_shape[:-1]) + [-1]) - def fit_transform(self, x: torch.Tensor, reshape: bool = True) -> torch.Tensor: + def fit_transform( + self, x: Union[torch.Tensor, np.ndarray], reshape: bool = True + ) -> Union[torch.Tensor, np.ndarray]: """ - Move channels to channels last NumPy format - Assume first dimension is batch size except for shape CHW + Perform dimensionality reduction on an input tensor or NumPy array. """ - if x.dim() == 3 and reshape: - x = x.permute(2, 1, 0) - elif x.dim() > 3 and reshape: - permute_vals = [0] + list(range(x.dim()))[2:] + [1] - x = x.permute(*permute_vals) + is_tensor = torch.is_tensor(x) + + if is_tensor: + if x.dim() == 3 and reshape: + x = x.permute(2, 1, 0) + elif x.dim() > 3 and reshape: + permute_vals = [0] + list(range(x.dim()))[2:] + [1] + x = x.permute(*permute_vals) + else: + if x.ndim == 3 and reshape: + x = x.transpose(2, 1, 0) + elif x.ndim > 3 and reshape: + permute_vals = [0] + list(range(x.ndim))[2:] + [1] + x = x.transpose(*permute_vals) - x_out = torch.as_tensor( - ChannelReducer._apply_flat(self._reducer.fit_transform, x) - ) + x_out = ChannelReducer._apply_flat(self._reducer.fit_transform, x) + + if is_tensor: + x_out = torch.as_tensor(x_out) + if x.dim() == 3 and reshape: + x_out = x_out.permute(2, 1, 0) + elif x.dim() > 3 and reshape: + permute_vals = ( + [0] + + [x.dim() - 1] + + list(range(x.dim()))[1 : len(list(range(x.dim()))) - 1] + ) + x_out = x_out.permute(*permute_vals) + else: + if x.ndim == 3 and reshape: + x_out = x_out.permute(2, 1, 0) + elif x.ndim > 3 and reshape: + permute_vals = ( + [0] + + [x.ndim - 1] + + list(range(x.ndim))[1 : len(list(range(x.ndim))) - 1] + ) + x_out = x_out.transpose(*permute_vals) - if x.dim() == 3 and reshape: - x_out = x_out.permute(2, 1, 0) - elif x.dim() > 3 and reshape: - permute_vals = ( - [0] - + [x.dim() - 1] - + list(range(x.dim()))[1 : len(list(range(x.dim()))) - 1] - ) - x_out = x_out.permute(*permute_vals) return x_out diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index a22e8b424e..b353c71c07 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -109,17 +109,6 @@ def forward(self, input: torch.Tensor) -> torch.Tensor: self.assertIsInstance(toy_model.relu2.relu, new_layer) -class TestMax2AvgPool(BaseTest): - def test_max2avg_pool(self) -> None: - if torch.__version__ == "1.2.0": - raise unittest.SkipTest( - "Skipping max2avg_pool test due to insufficient Torch version." - ) - model = googlenet(pretrained=True) - model_utils.max2avg_pool(model) - check_is_not_instance(self, model, torch.nn.MaxPool2d) - - class TestGetLayers(BaseTest): def test_get_layers_pretrained_inceptionv1(self) -> None: if torch.__version__ == "1.2.0": From 745d3225af4264f948bf269dea02ca2255128cac Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 13 Dec 2020 16:26:55 -0700 Subject: [PATCH 28/76] Fixes & improvements --- captum/optim/_core/loss.py | 6 +- captum/optim/_param/image/transform.py | 4 +- tutorials/WeightVisualization_OptimViz.ipynb | 1010 +++++++++++++++++- 3 files changed, 1000 insertions(+), 20 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index b0e7573086..928a0af09e 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -66,12 +66,10 @@ def __init__( self.x = x self.y = y - # ensure channel_index will be valid - assert self.channel_index < self.target.out_channels - - def _call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] assert activations is not None + assert self.channel_index < activations.shape[1] assert len(activations.shape) == 4 # assume NCHW _x, _y = get_neuron_pos( activations.size(2), activations.size(3), self.x, self.y diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index 307652cc0b..65ae9a1dc6 100644 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -22,8 +22,8 @@ def __init__(self, background: Optional[torch.Tensor] = None) -> None: self.background = background def forward(self, x: torch.Tensor) -> torch.Tensor: - assert x.size(1) == 4 assert x.dim() == 4 + assert x.size(1) == 4 rgb, alpha = x[:, :3, ...], x[:, 3:4, ...] background = ( self.background if self.background is not None else torch.rand_like(rgb) @@ -36,8 +36,8 @@ class IgnoreAlpha(nn.Module): r"""Ignores a 4th channel""" def forward(self, x: torch.Tensor) -> torch.Tensor: - assert x.size(1) == 4 assert x.dim() == 4 + assert x.size(1) == 4 rgb = x[:, :3, ...] return rgb diff --git a/tutorials/WeightVisualization_OptimViz.ipynb b/tutorials/WeightVisualization_OptimViz.ipynb index c08bb736c1..28e4a1d4af 100644 --- a/tutorials/WeightVisualization_OptimViz.ipynb +++ b/tutorials/WeightVisualization_OptimViz.ipynb @@ -11,6 +11,745 @@ "kernelspec": { "name": "python3", "display_name": "Python 3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "c916baaee35649f5b66baa43bdbb59df": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_2bb4d57151184551b6325e58524d720e", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_b999b5e8552d482ab4f1b0e1ea80d1e5", + "IPY_MODEL_b0e972107ae0425db050ce3784052c6f" + ] + } + }, + "2bb4d57151184551b6325e58524d720e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "b999b5e8552d482ab4f1b0e1ea80d1e5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_601144387cf1405d9116818a81d88d3e", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_40d7e3d2688a4065a78956f0d090b567" + } + }, + "b0e972107ae0425db050ce3784052c6f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_d8d9192ba2a44c4fa3a83fbbe2029886", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [00:36<00:00, 3.53step/s, Objective=1022.5]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_3fc94e3ced87438288d8bff147eb34a6" + } + }, + "601144387cf1405d9116818a81d88d3e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "40d7e3d2688a4065a78956f0d090b567": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "d8d9192ba2a44c4fa3a83fbbe2029886": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "3fc94e3ced87438288d8bff147eb34a6": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "e132a09016234c159637c6df989eacba": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_0c755fb79f594742bafb743de238014e", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_ae636a95c5c7407aae95ebfa07237605", + "IPY_MODEL_204c67654d09436fbbf64c63c6e6114d" + ] + } + }, + "0c755fb79f594742bafb743de238014e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "ae636a95c5c7407aae95ebfa07237605": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_41867ab292944ec9b511ca7691a7d44d", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_bc84394660b4440f94864eb0936e6634" + } + }, + "204c67654d09436fbbf64c63c6e6114d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_45a6c54c2d2c48a4975346c5b582f2f2", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [00:45<00:00, 2.79step/s, Objective=4041.6]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_d5232a8d98764bb38e0144c67a9be7d3" + } + }, + "41867ab292944ec9b511ca7691a7d44d": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "bc84394660b4440f94864eb0936e6634": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "45a6c54c2d2c48a4975346c5b582f2f2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "d5232a8d98764bb38e0144c67a9be7d3": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "17cd567871164a309ad8647234fc7e6e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_68d7b1cbc7f54e05b83731c299a293c8", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_253faa5f26994760aba84c5cdc8c8edb", + "IPY_MODEL_18b3695da5fa4ceebffc88286b2c0aed" + ] + } + }, + "68d7b1cbc7f54e05b83731c299a293c8": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "253faa5f26994760aba84c5cdc8c8edb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_bbb055348e9c4e99a36b4ce71195eaf0", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_f33ed004c31a4347b5e644721ce2b6c8" + } + }, + "18b3695da5fa4ceebffc88286b2c0aed": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_c6f6f5e291ba4032a1b0648f87720c35", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [32:11<00:00, 15.09s/step, Objective=4029.8]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_15a632adfb484d93b5317536805a6443" + } + }, + "bbb055348e9c4e99a36b4ce71195eaf0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "f33ed004c31a4347b5e644721ce2b6c8": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "c6f6f5e291ba4032a1b0648f87720c35": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "15a632adfb484d93b5317536805a6443": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } } }, "cells": [ @@ -67,11 +806,15 @@ "\r\n", "\r\n", "def show(x: np.ndarray, scale: float = 255.0) -> None:\r\n", + " assert x.ndim == 3\r\n", + " if x.shape[2] == 1:\r\n", + " x = np.concatenate([x,x,x],2)\r\n", " x = x * scale\r\n", " plt.imshow(x.astype(np.uint8))\r\n", " plt.axis(\"off\")\r\n", " plt.show()\r\n", "\r\n", + "\r\n", "def weight_heatmap(array: np.ndarray) -> np.ndarray:\r\n", " def C(x: str) -> np.ndarray:\r\n", " def H(x: str) -> float:\r\n", @@ -96,22 +839,50 @@ " x = (x - 0.5) * 2\r\n", " return (1 - x) * C(\"f4a582\") + x * C(\"ca0020\")\r\n", "\r\n", - " return np.asarray([[weight_color_scale(x) for x in a] for a in array])" + " return np.asarray([[weight_color_scale(x) for x in a] for a in array])\r\n", + "\r\n", + "\r\n", + "def visualize_activations(model, target, channel: int, neuron=True) -> None:\r\n", + " image = optimviz.images.NaturalImage((224, 224)).to(device)\r\n", + " transforms = torch.nn.Sequential(\r\n", + " torch.nn.ReflectionPad2d(16),\r\n", + " optimviz.transform.RandomSpatialJitter(16),\r\n", + " optimviz.transform.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\r\n", + " torchvision.transforms.RandomRotation(degrees=(-5,5)),\r\n", + " optimviz.transform.RandomSpatialJitter(8),\r\n", + " optimviz.transform.CenterCrop(16),\r\n", + " )\r\n", + " if neuron:\r\n", + " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", + " else:\r\n", + " loss_fn = optimviz.loss.ChannelActivation(target, channel)\r\n", + " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", + " history = obj.optimize(optimviz.objectives.n_steps(128))\r\n", + " image().show()" ], - "execution_count": null, + "execution_count": 4, "outputs": [] }, + { + "cell_type": "markdown", + "metadata": { + "id": "5M4Z6f-b7shW" + }, + "source": [ + "## Visualizing weights\r\n" + ] + }, { "cell_type": "markdown", "metadata": { "id": "fMvQtKFEe9R8" }, "source": [ - "## Extracting Hidden Weights\r\n", + "## Extracting expanded weights\r\n", "\r\n", - "We can extract hidden weights with Captum.optim's get_expanded_weights function.\r\n", + "We can extract expanded weights with Captum.optim's get_expanded_weights function.\r\n", "\r\n", - "Below we extract the hidden weights between layers mixed3a and mixed3b:" + "Below we extract the expanded weights from between the mixed3a and mixed3b layers:" ] }, { @@ -120,9 +891,10 @@ "id": "IWbzbWvGTj0-" }, "source": [ - "W_3a_3b = optimviz.circuits.get_expanded_weights(test_model, test_model.mixed3a, test_model.mixed3b)" + "W_3a_3b = optimviz.circuits.get_expanded_weights(model, model.mixed3a, model.mixed3b)\r\n", + "W_3a_3b_np = W_3a_3b.permute(1, 2, 0, 3).numpy() # Convert output to NumPy format" ], - "execution_count": null, + "execution_count": 5, "outputs": [] }, { @@ -131,9 +903,9 @@ "id": "HnNDlOiFWMf7" }, "source": [ - "# Visualizing hidden-hidden weights\r\n", + "# Visualizing expanded weights\r\n", "\r\n", - "We can visualize our newly collected expanded weights like so:" + "We can visualize our newly collected expanded weights for channel 147 of mixed3a and channel 379 of mixed3b like so:" ] }, { @@ -144,10 +916,9 @@ "height": 248 }, "id": "BiAXnE0zqyFP", - "outputId": "9f00a11a-e807-43fa-cd60-63dfaae17f92" + "outputId": "dfa36dc5-c63a-4205-91dc-0f10cb14ecc8" }, "source": [ - "W_3a_3b_np = W_3a_3b.permute(1, 2, 0, 3).numpy()\r\n", "show(weight_heatmap(W_3a_3b_np[:,:,147,379] / W_3a_3b_np[:,:,:,379].max()))" ], "execution_count": null, @@ -167,13 +938,142 @@ } ] }, + { + "cell_type": "markdown", + "metadata": { + "id": "mYPv8ncH1V8x" + }, + "source": [ + "By looking at the weights above, we can see how the the following two curve dectector neurons are connected to each other." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 708, + "referenced_widgets": [ + "c916baaee35649f5b66baa43bdbb59df", + "2bb4d57151184551b6325e58524d720e", + "b999b5e8552d482ab4f1b0e1ea80d1e5", + "b0e972107ae0425db050ce3784052c6f", + "601144387cf1405d9116818a81d88d3e", + "40d7e3d2688a4065a78956f0d090b567", + "d8d9192ba2a44c4fa3a83fbbe2029886", + "3fc94e3ced87438288d8bff147eb34a6", + "e132a09016234c159637c6df989eacba", + "0c755fb79f594742bafb743de238014e", + "ae636a95c5c7407aae95ebfa07237605", + "204c67654d09436fbbf64c63c6e6114d", + "41867ab292944ec9b511ca7691a7d44d", + "bc84394660b4440f94864eb0936e6634", + "45a6c54c2d2c48a4975346c5b582f2f2", + "d5232a8d98764bb38e0144c67a9be7d3" + ] + }, + "id": "8pCOa_o4xF0w", + "outputId": "58960e52-94f0-4abb-aebe-b0045afe83b5" + }, + "source": [ + "visualize_activations(model, model.mixed3a, 147)\r\n", + "visualize_activations(model, model.mixed3b, 379)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c916baaee35649f5b66baa43bdbb59df", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/torch/tensor.py:775: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at /pytorch/c10/core/TensorImpl.h:848.)\n", + " return super(Tensor, self).refine_names(names)\n", + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e132a09016234c159637c6df989eacba", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, { "cell_type": "markdown", "metadata": { "id": "e1ZoZdYdVv0G" }, "source": [ - "# NMF Visualizations of hidden-hidden weights\r\n", + "# NMF Visualizations of expanded weights\r\n", "\r\n", "NMF and other dimensionality reduction alorgrithms can reveal the spaital structure of weights." ] @@ -186,14 +1086,14 @@ "height": 248 }, "id": "rrT2Z3HiVDPt", - "outputId": "124f1bd5-a021-4a1b-e168-eb99b01195b1" + "outputId": "74bbbd23-ef6f-4813-9b9c-6fdbbb279e0d" }, "source": [ "reducer = optimviz.ChannelReducer(3)\r\n", "\r\n", "W_3a_3b_posneg = np.concatenate([np.maximum(0, W_3a_3b_np), np.maximum(0, -W_3a_3b_np)], axis=2)\r\n", "\r\n", - "W_nmf = reducer.fit_transform(torch.as_tensor(W_3a_3b_posneg[..., 320]), reshape=False).numpy()\r\n", + "W_nmf = reducer.fit_transform(W_3a_3b_posneg[..., 320], reshape=False)\r\n", "W_nmf /= W_nmf.max()\r\n", "show(W_nmf)" ], @@ -213,6 +1113,88 @@ } } ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xR3M4v1y367s" + }, + "source": [ + "Using the weights above, we can see how that they match the structure of the target neurons when they are visualized." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 391, + "referenced_widgets": [ + "17cd567871164a309ad8647234fc7e6e", + "68d7b1cbc7f54e05b83731c299a293c8", + "253faa5f26994760aba84c5cdc8c8edb", + "18b3695da5fa4ceebffc88286b2c0aed", + "bbb055348e9c4e99a36b4ce71195eaf0", + "f33ed004c31a4347b5e644721ce2b6c8", + "c6f6f5e291ba4032a1b0648f87720c35", + "15a632adfb484d93b5317536805a6443" + ] + }, + "id": "mgzEU3Iu2R5Y", + "outputId": "49aaa682-ce3b-4072-8a94-cadbd0842af0" + }, + "source": [ + "visualize_activations(model, model.mixed3b, 320)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "17cd567871164a309ad8647234fc7e6e", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] } ] } \ No newline at end of file From 129f6b50a4c3da4834389927f9e168e6b5a3bec5 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 14 Dec 2020 08:37:27 -0700 Subject: [PATCH 29/76] Improve weight visualization tutorial --- tutorials/WeightVisualization_OptimViz.ipynb | 51 ++++++++++++-------- 1 file changed, 31 insertions(+), 20 deletions(-) diff --git a/tutorials/WeightVisualization_OptimViz.ipynb b/tutorials/WeightVisualization_OptimViz.ipynb index 28e4a1d4af..158aeb6fbc 100644 --- a/tutorials/WeightVisualization_OptimViz.ipynb +++ b/tutorials/WeightVisualization_OptimViz.ipynb @@ -805,10 +805,19 @@ "import matplotlib.pyplot as plt\r\n", "\r\n", "\r\n", - "def show(x: np.ndarray, scale: float = 255.0) -> None:\r\n", + "def resize_image(x: np.ndarray) -> np.ndarray:\r\n", + " x = torch.as_tensor(x).permute(2, 1, 0).unsqueeze(0)\r\n", + " x = torch.nn.functional.interpolate(x, size=(224,224), mode='bilinear')\r\n", + " x = x.squeeze(0).permute(2, 1, 0).numpy()\r\n", + " return x\r\n", + "\r\n", + "\r\n", + "def show(x: np.ndarray, resize: bool = False, scale: float = 255.0) -> None:\r\n", " assert x.ndim == 3\r\n", + " if resize:\r\n", + " x = resize_image(x)\r\n", " if x.shape[2] == 1:\r\n", - " x = np.concatenate([x,x,x],2)\r\n", + " x = np.concatenate([x, x, x], 2)\r\n", " x = x * scale\r\n", " plt.imshow(x.astype(np.uint8))\r\n", " plt.axis(\"off\")\r\n", @@ -863,15 +872,6 @@ "execution_count": 4, "outputs": [] }, - { - "cell_type": "markdown", - "metadata": { - "id": "5M4Z6f-b7shW" - }, - "source": [ - "## Visualizing weights\r\n" - ] - }, { "cell_type": "markdown", "metadata": { @@ -916,17 +916,19 @@ "height": 248 }, "id": "BiAXnE0zqyFP", - "outputId": "dfa36dc5-c63a-4205-91dc-0f10cb14ecc8" + "outputId": "25703dc5-8584-4037-a991-c485f9bb3773" }, "source": [ - "show(weight_heatmap(W_3a_3b_np[:,:,147,379] / W_3a_3b_np[:,:,:,379].max()))" + "W_3a_3b_hm = weight_heatmap(W_3a_3b_np[:,:,147,379] / W_3a_3b_np[:,:,:,379].max())\r\n", + "W_3a_3b_hm = W_3a_3b_hm[11:16, 11:16, :] # crop away border\r\n", + "show(W_3a_3b_hm)" ], - "execution_count": null, + "execution_count": 7, "outputs": [ { "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADpElEQVR4nO3dMW4TQRiAURwcYSQkwg2gSkhHT8FluAcNdIgz0HEAImquQBMKDoBEJNI4mIRkuYA9BYL4i3iv9K/xrmR9O5JHsmfTNN0Cena2fQPAeuKEKHFClDghSpwQNR8NV6uVr3LhH1ssFrN1r9s5IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROi5tu+gf/R8bflxtmPX1fDtU92Tobz6fvX8cWvLofjncOn4/VcGzsnRIkTosQJUeKEKHFClDghylHKFvy8nDbO9t+9Gq49fvlhON9/+3x88XsPxnMy7JwQJU6IEidEiROixAlR4oQocUKUc84tODh6vXH25cX74drDj2+G8+XjZ8P5ydnFcP5oOOU62TkhSpwQJU6IEidEiROixAlR4oQo55xbML9/d+Ps8PTTcO3yfPzTlnfm4+ft7m3P45vCJwVR4oQocUKUOCFKnBAlTogSJ0TNpmnzb6iuVqvNQ/7YtDzdOPt8tjtce7A3np+cj6+9vBj/xeDDvcX4DfjrFovFbN3rdk6IEidEiROixAlR4oQocUKUOCHKOSdsmXNOuGHECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocULUbJqmbd8DsIadE6LECVHihChxQpQ4IUqcEPUb26BFy1PevGwAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADpUlEQVR4nO3YPU5UUQCGYUeHGI2J2LkDfjpdgYVbcR822hnXYOcCNNauwMRGCzsbCog2QAThugGYcIPhvJDnKc9pvineOcldTNN0C+i5PXoAcDZxQpQ4IUqcECVOiFquuvzyc+/afMo9/Hs6esIsT27vjp4wy/RrZ/SEizs9Gb1glvtPny/OOvdyQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBC1XHX552S6qh2XtvH+9egJs3x79Wn0hFk23r0YPeHiHjwaveC/8HJClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IWq56nLz45ur2nFpP15+GD1hlu3Pb0dPmGV/69noCRe2e3A8esIsW+ecezkhSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiFquvHx476p2XNr276+jJ8yyf3QyesIsd5fX53987c712brKzfgVcAOJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROiFtM0nXt5uLdz/mXM94O10RNm2Vy/Xnt3j0YvuLj949PRE2bZfLy+OOvcywlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFC1GKaptEbgDN4OSFKnBAlTogSJ0SJE6LECVH/ACgcONUh9QcDAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] @@ -1083,10 +1085,10 @@ "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 248 + "height": 304 }, "id": "rrT2Z3HiVDPt", - "outputId": "74bbbd23-ef6f-4813-9b9c-6fdbbb279e0d" + "outputId": "1581f7d9-8556-44ea-8df5-ef862c8369be" }, "source": [ "reducer = optimviz.ChannelReducer(3)\r\n", @@ -1095,14 +1097,23 @@ "\r\n", "W_nmf = reducer.fit_transform(W_3a_3b_posneg[..., 320], reshape=False)\r\n", "W_nmf /= W_nmf.max()\r\n", - "show(W_nmf)" + "W_nmf = W_nmf[11:16, 11:16, :] # crop away border\r\n", + "show(W_nmf, resize=True)" ], - "execution_count": null, + "execution_count": 8, "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3063: UserWarning: Default upsampling behavior when mode=bilinear is changed to align_corners=False since 0.4.0. Please specify align_corners=True if the old behavior is desired. See the documentation of nn.Upsample for details.\n", + " \"See the documentation of nn.Upsample for details.\".format(mode))\n" + ], + "name": "stderr" + }, { "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADo0lEQVR4nO3dP2oUcQCG4R0TBIUgkgiirReIgoW1YGPnQTyGheARvEAKewsrCxFS2mhhYyuCiv8CjhfY/QmSZN7g85T7ZXameRnIMOw0z/MK6Dm39AUA64kTosQJUeKEKHFC1PZonKbJv3LhhM3zPK373J0TosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFqe+kL+B/d2rm7cTv88XB47M7R/eH+ZffZ+Nxfnwz3w58vhzunx50TosQJUeKEKHFClDghSpwQNc3zvHmcps0j/+zXYDtcXR8eu7+6PdxfrC4P963V0+F+b7hyEuZ5ntZ97s4JUeKEKHFClDghSpwQJU6IEidEec65gDs3N2/v98fHXvq2Ndz3Xp0f7hePvg/35x/G5+f4ec4JZ4w4IUqcECVOiBInRIkTosQJUZ5zLuHx4J3LK5/Gxz74y3c/2h3v766O94M3fzkBx81zTjhjxAlR4oQocUKUOCFKnBAlTojyE4BLuPF54zS9HR86vR7vv/c+jv/g2oXxfjCeOT3unBAlTogSJ0SJE6LECVHihChxQpT3OWFh3ueEM0acECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0RN8zwvfQ3AGu6cECVOiBInRIkTosQJUeKEqD/qn0dGD/xY6AAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] From 3e1742162a312dfa25f15e8692829be19549d192 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 14 Dec 2020 10:00:12 -0700 Subject: [PATCH 30/76] Fix some objective call functions --- captum/optim/_core/loss.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 928a0af09e..c05f1c53d8 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -96,7 +96,7 @@ class TotalVariation(Loss): https://arxiv.org/abs/1412.0035 """ - def _call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] x_diff = activations[..., 1:, :] - activations[..., :-1, :] y_diff = activations[..., :, 1:] - activations[..., :, :-1] @@ -113,7 +113,7 @@ def __init__(self, target: nn.Module, constant: float = 0.0) -> None: self.target = target self.constant = constant - def _call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] return torch.abs(activations - self.constant).sum() @@ -130,7 +130,7 @@ def __init__( self.constant = constant self.epsilon = epsilon - def _call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] activations = (activations - self.constant).sum() return torch.sqrt(self.epsilon + activations) @@ -143,7 +143,7 @@ class Diversity(Loss): https://distill.pub/2017/feature-visualization/#diversity """ - def _call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: + def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] return -sum( [ From 7c4bd96f11863988b345524bf17f63f12ae9015b Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 14 Dec 2020 12:55:07 -0700 Subject: [PATCH 31/76] Additional ChannelReducer tests and CustomModule tutorial --- tests/optim/utils/test_reducer.py | 90 ++++- tutorials/CustomModules_OptimViz.ipynb | 538 +++++++++++++++++++++++++ 2 files changed, 625 insertions(+), 3 deletions(-) create mode 100644 tutorials/CustomModules_OptimViz.ipynb diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py index cfe3b5e1c0..1e653f40db 100644 --- a/tests/optim/utils/test_reducer.py +++ b/tests/optim/utils/test_reducer.py @@ -1,27 +1,111 @@ #!/usr/bin/env python3 import unittest +from typing import Union +import numpy as np import torch from captum.optim._utils.reducer import ChannelReducer from tests.helpers.basic import BaseTest +class TestReductionAlgorithm(object): + """ + Fake reduction algorithm for testing + """ + + def __init__(self, n_components=3, **kwargs) -> None: + self.n_components = n_components + + def fit_transform(self, x: Union[torch.Tensor, np.ndarray]) -> np.ndarray: + return x[..., 0:3].numpy() + + class TestChannelReducer(BaseTest): - def test_channelreducer(self) -> None: + def test_channelreducer_pytorch(self) -> None: try: import sklearn # noqa: F401 except (ImportError, AssertionError): raise unittest.SkipTest( - "Module sklearn not found, skipping ChannelReducer test" + "Module sklearn not found, skipping ChannelReducer" + + " PyTorch reshape test" ) test_input = torch.randn(1, 32, 224, 224).abs() c_reducer = ChannelReducer(n_components=3, max_iter=100) - test_output = c_reducer.fit_transform(test_input) + test_output = c_reducer.fit_transform(test_input, reshape=True) + self.assertEquals(test_output.size(1), 3) + + def test_channelreducer_pytorch_pca(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer" + + " PyTorch reshape test" + ) + + test_input = torch.randn(1, 32, 224, 224).abs() + c_reducer = ChannelReducer(n_components=3, reduction_alg="PCA", max_iter=100) + test_output = c_reducer.fit_transform(test_input, reshape=True) + self.assertEquals(test_output.size(1), 3) + + def test_channelreducer_pytorch_custom_alg(self) -> None: + test_input = torch.randn(1, 32, 224, 224).abs() + reduction_alg = TestReductionAlgorithm + c_reducer = ChannelReducer( + n_components=3, reduction_alg=reduction_alg, max_iter=100 + ) + test_output = c_reducer.fit_transform(test_input, reshape=True) self.assertEquals(test_output.size(1), 3) + def test_channelreducer_numpy(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer" + + " NumPy reshape test" + ) + + test_input = torch.randn(1, 32, 224, 224).abs().numpy() + c_reducer = ChannelReducer(n_components=3, max_iter=100) + test_output = c_reducer.fit_transform(test_input, reshape=True) + self.assertEquals(test_output.shape[1], 3) + + def test_channelreducer_noreshape_pytorch(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer" + + " PyTorch no reshape test" + ) + + test_input = torch.randn(1, 224, 224, 32).abs() + c_reducer = ChannelReducer(n_components=3, max_iter=100) + test_output = c_reducer.fit_transform(test_input, reshape=False) + self.assertEquals(test_output.size(3), 3) + + def test_channelreducer_noreshape_numpy(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer" + + " NumPy no reshape test" + ) + + test_input = torch.randn(1, 224, 224, 32).abs().numpy() + c_reducer = ChannelReducer(n_components=3, max_iter=100) + test_output = c_reducer.fit_transform(test_input, reshape=False) + self.assertEquals(test_output.shape[3], 3) + if __name__ == "__main__": unittest.main() diff --git a/tutorials/CustomModules_OptimViz.ipynb b/tutorials/CustomModules_OptimViz.ipynb new file mode 100644 index 0000000000..6e70c651dc --- /dev/null +++ b/tutorials/CustomModules_OptimViz.ipynb @@ -0,0 +1,538 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "CustomClasses_OptimViz1.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "0eb9231074ff48e68349a37e319c7869": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_1555dc9cb70845098fa539cd9db186b4", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_44593fa4471948568c5462b8638d8e52", + "IPY_MODEL_db3b13c3ccd141cbb314ddc605a65f19" + ] + } + }, + "1555dc9cb70845098fa539cd9db186b4": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "44593fa4471948568c5462b8638d8e52": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_9f6e2db7346541f9b01f82d00e52e18e", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_84f23ee271e343db9c62ccfa42ec34ed" + } + }, + "db3b13c3ccd141cbb314ddc605a65f19": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_6812345efe26488f91e8224838908c06", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [00:43<00:00, 2.97step/s, Objective=322.2]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_21e29391811c46519616619dc4449b31" + } + }, + "9f6e2db7346541f9b01f82d00e52e18e": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "84f23ee271e343db9c62ccfa42ec34ed": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "6812345efe26488f91e8224838908c06": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "21e29391811c46519616619dc4449b31": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "2ylZPub2JTMH" + }, + "source": [ + "# Creating Custom Captum.optim Modules\n", + "Captum's Optim library contains an extensive list of optimization objectives, transforms, and input parameterizations. However, some cases may require adding new features to these areas of Captum's Optim library. Luckily adding them to Captum is easy!" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GWrStkUVEbOC" + }, + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "from typing import Dict, List, Optional, Union\n", + "\n", + "import torch\n", + "import torchvision\n", + "from captum.optim._models.inception_v1 import googlenet\n", + "\n", + "import captum.optim as optimviz\n", + "\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "model = googlenet(pretrained=True).to(device)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DffA7pFSFZY0" + }, + "source": [ + "# Custom Transforms\n", + "\n", + "If both Captum and Torchvision lack the transforms that you require, then you can create your own custom transforms.\n", + "\n", + "Custom transform classes must contain a `forward()` function. The first transform in a list of transforms takes an input tensor with a shape of (B, C, W, H), and the final transform in a list of transforms will need to output a tensor with the same shape of (B, C, W, H). Captum and Torchvision's transforms normally expect and output a shape of (B, C, W, H).\n", + "\n", + "An optional `__init__()` function can be used as well.\n", + "\n", + "\n", + "Note that any custom transforms need sure that your transform is autograd compatible, so that the gradient is not interrupted during the optimization process.\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hoyneR7FFTXK" + }, + "source": [ + "class CustomTransform(torch.nn.Module):\n", + " def __init__(self, val: int = 1) -> None:\n", + " super(CustomTransform, self).__init__()\n", + " self.val = val\n", + "\n", + " def forward(self, input: torch.Tensor) -> torch.Tensor:\n", + " return input * self.val" + ], + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2kjc9istEzVz" + }, + "source": [ + "# Custom Loss Functions\n", + "Captum's loss functions are composed of classes that the optimization function uses. Custom loss classes should inherit the base the loss class.\n", + "\n", + "Custom loss functions must contain the following two functions:\n", + "\n", + "\n", + "* The `__init__()` function with that must at least contain a target variable. The target variable should be an nn.module or list of nn.modules to collect activations from. Other variables can be added after the target.\n", + "\n", + "* The `__call__()` function which takes activations from the target layer and then returns a loss value." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "LQZECwPoEdET" + }, + "source": [ + "class CustomLoss(optimviz.loss.Loss):\n", + " def __init__(self, target: Union[torch.nn.Module, List[torch.nn.Module]]):\n", + " super(optimviz.loss.Loss, self).__init__()\n", + " self.target = target\n", + "\n", + " def __call__(\n", + " self, target_activations: Dict[torch.nn.Module, Optional[torch.Tensor]]\n", + " ) -> torch.Tensor:\n", + " activations = target_activations[self.target] # Get activations from target\n", + " return activations" + ], + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "K45Xg0HGF3VH" + }, + "source": [ + "# Custom Input Parameterization\n", + "\n", + "\n", + "The tensor parameters that Captum's Optim library optimizes to produce visualizations is stored in a custom parameterization class. \n", + "\n", + "Custom parameterization must contain the following two functions:\n", + "\n", + "An `__init__()` function with 3 input variables:\n", + "\n", + "* size (tuple, int): dimensions in the form height, width. \n", + "\n", + "* channels (int): the number of channels for the output tensor.\n", + "\n", + "* batch (int): the desired batch size to use.\n", + "\n", + "* init (torch.Tensor): An optional input tensor with a shape of: (B, C, W, H).\n", + "\n", + "\n", + "A `forward()` function with zero input varibles that returns an `torch.nn.Parameter` version of the tensor being optimized, with its shape dimensions properly named for Captum. The output tensor for the forward function must already be converted to a `torch.nn.Parameter` tensor before the forward function is run." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Hm2HLX9VFmAT" + }, + "source": [ + "class CustomInput(optimviz.images.ImageParameterization):\n", + " def __init__(\n", + " self, size=None, channels: int = 3, batch: int = 1, init: torch.Tensor = None\n", + " ) -> None:\n", + " super().__init__()\n", + " assert size is not None\n", + " if init is None:\n", + " # Create random input with a shape of: B, C, W, H\n", + " init = torch.randn([batch, channels, size[0], size[1]])\n", + " self.image = torch.nn.Parameter(init) # Convert input to nn.Parameter()\n", + "\n", + " def forward(self) -> torch.Tensor:\n", + " return self.image.refine_names(\"B\", \"C\", \"H\", \"W\") # rename dimensions" + ], + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x_AK29oiH9Z3" + }, + "source": [ + "# Running Captum with custom modules\n", + "\n", + "Below is a helper function that will let us quickly and easily experiment with our custom modules from above. Random scaling and random spatial jitter transforms are also included in the helper function to improve output quality." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uQ9sEz8cG2El" + }, + "source": [ + "def visualize(model, target):\r\n", + " # Define our custom input parameterization, then add it to NaturalImage\r\n", + " image_param = CustomInput\r\n", + " image = optimviz.images.NaturalImage(size=(224, 224), Parameterization=image_param)\r\n", + "\r\n", + " transforms = torch.nn.Sequential(\r\n", + " CustomTransform(), # Add our custom transform to the list of transforms\r\n", + "\r\n", + " # Additional transforms to improve output quality\r\n", + " optimviz.transform.RandomSpatialJitter(16),\r\n", + " optimviz.transform.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\r\n", + " )\r\n", + "\r\n", + " # Define our custom loss function as the loss function\r\n", + " loss_fn = CustomLoss(target)\r\n", + "\r\n", + " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", + " history = obj.optimize(optimviz.objectives.n_steps(128))\r\n", + " image().show()" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 427, + "referenced_widgets": [ + "0eb9231074ff48e68349a37e319c7869", + "1555dc9cb70845098fa539cd9db186b4", + "44593fa4471948568c5462b8638d8e52", + "db3b13c3ccd141cbb314ddc605a65f19", + "9f6e2db7346541f9b01f82d00e52e18e", + "84f23ee271e343db9c62ccfa42ec34ed", + "6812345efe26488f91e8224838908c06", + "21e29391811c46519616619dc4449b31" + ] + }, + "id": "3m5iQ2zfqV5F", + "outputId": "b3df586b-d7f6-48de-b7a5-4eb0c853e4b2" + }, + "source": [ + "visualize(model, model.mixed4a)" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "0eb9231074ff48e68349a37e319c7869", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/torch/tensor.py:775: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at /pytorch/c10/core/TensorImpl.h:848.)\n", + " return super(Tensor, self).refine_names(names)\n", + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file From e205f5c4250423185a077881ecc5db44e96a1402 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 14 Dec 2020 16:58:55 -0700 Subject: [PATCH 32/76] Move posneg to reducer --- captum/optim/__init__.py | 3 +- captum/optim/_utils/reducer.py | 31 +++++++++++++++ tests/optim/utils/test_reducer.py | 42 +++++++++++++++----- tutorials/WeightVisualization_OptimViz.ipynb | 19 ++++----- 4 files changed, 75 insertions(+), 20 deletions(-) diff --git a/captum/optim/__init__.py b/captum/optim/__init__.py index 65ebdc6e95..9d8a589fea 100755 --- a/captum/optim/__init__.py +++ b/captum/optim/__init__.py @@ -6,5 +6,4 @@ from captum.optim._param.image import images # noqa: F401 from captum.optim._param.image import transform # noqa: F401 from captum.optim._param.image.images import ImageTensor # noqa: F401 -from captum.optim._utils import circuits, models # noqa: F401 -from captum.optim._utils.reducer import ChannelReducer # noqa: F401 +from captum.optim._utils import circuits, models, reducer # noqa: F401 diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index d3fadf6111..d2eb7eace3 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -94,3 +94,34 @@ def fit_transform( x_out = x_out.transpose(*permute_vals) return x_out + + def __getattr__(self, name): + if name in self.__dict__: + return self.__dict__[name] + elif name + "_" in self._reducer.__dict__: + return self._reducer.__dict__[name + "_"] + + def __dir__(self): + dynamic_attrs = [ + name[:-1] + for name in dir(self._reducer) + if name[-1] == "_" and name[0] != "_" + ] + + return ( + list(ChannelReducer.__dict__.keys()) + + list(self.__dict__.keys()) + + dynamic_attrs + ) + + +def posneg(x: torch.Tensor, dim: int = 0) -> torch.Tensor: + """ + Hack that makes a matrix positive by concatination in order to simulate + one-sided NMF with regular NMF + """ + + return torch.cat( + [torch.max(x, torch.full_like(x, 0)), torch.max(-x, torch.full_like(x, 0))], + dim=dim, + ) diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py index 1e653f40db..a82751d0ce 100644 --- a/tests/optim/utils/test_reducer.py +++ b/tests/optim/utils/test_reducer.py @@ -5,7 +5,7 @@ import numpy as np import torch -from captum.optim._utils.reducer import ChannelReducer +import captum.optim._utils.reducer as reducer from tests.helpers.basic import BaseTest @@ -18,7 +18,21 @@ def __init__(self, n_components=3, **kwargs) -> None: self.n_components = n_components def fit_transform(self, x: Union[torch.Tensor, np.ndarray]) -> np.ndarray: - return x[..., 0:3].numpy() + x = x.numpy() if torch.is_tensor(x) else x + return x[..., 0:3] + + +class TestReductionAlgorithm(object): + """ + Fake reduction algorithm for testing + """ + + def __init__(self, n_components=3, **kwargs) -> None: + self.n_components = n_components + + def fit_transform(self, x: Union[torch.Tensor, np.ndarray]) -> np.ndarray: + x = x.numpy() if torch.is_tensor(x) else x + return x[..., 0:3] class TestChannelReducer(BaseTest): @@ -33,7 +47,7 @@ def test_channelreducer_pytorch(self) -> None: ) test_input = torch.randn(1, 32, 224, 224).abs() - c_reducer = ChannelReducer(n_components=3, max_iter=100) + c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) test_output = c_reducer.fit_transform(test_input, reshape=True) self.assertEquals(test_output.size(1), 3) @@ -44,18 +58,20 @@ def test_channelreducer_pytorch_pca(self) -> None: except (ImportError, AssertionError): raise unittest.SkipTest( "Module sklearn not found, skipping ChannelReducer" - + " PyTorch reshape test" + + " PyTorch reshape PCA test" ) test_input = torch.randn(1, 32, 224, 224).abs() - c_reducer = ChannelReducer(n_components=3, reduction_alg="PCA", max_iter=100) + c_reducer = reducer.ChannelReducer( + n_components=3, reduction_alg="PCA", max_iter=100 + ) test_output = c_reducer.fit_transform(test_input, reshape=True) self.assertEquals(test_output.size(1), 3) def test_channelreducer_pytorch_custom_alg(self) -> None: test_input = torch.randn(1, 32, 224, 224).abs() reduction_alg = TestReductionAlgorithm - c_reducer = ChannelReducer( + c_reducer = reducer.ChannelReducer( n_components=3, reduction_alg=reduction_alg, max_iter=100 ) test_output = c_reducer.fit_transform(test_input, reshape=True) @@ -72,7 +88,7 @@ def test_channelreducer_numpy(self) -> None: ) test_input = torch.randn(1, 32, 224, 224).abs().numpy() - c_reducer = ChannelReducer(n_components=3, max_iter=100) + c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) test_output = c_reducer.fit_transform(test_input, reshape=True) self.assertEquals(test_output.shape[1], 3) @@ -87,7 +103,7 @@ def test_channelreducer_noreshape_pytorch(self) -> None: ) test_input = torch.randn(1, 224, 224, 32).abs() - c_reducer = ChannelReducer(n_components=3, max_iter=100) + c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) test_output = c_reducer.fit_transform(test_input, reshape=False) self.assertEquals(test_output.size(3), 3) @@ -102,10 +118,18 @@ def test_channelreducer_noreshape_numpy(self) -> None: ) test_input = torch.randn(1, 224, 224, 32).abs().numpy() - c_reducer = ChannelReducer(n_components=3, max_iter=100) + c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) test_output = c_reducer.fit_transform(test_input, reshape=False) self.assertEquals(test_output.shape[3], 3) +class TestPosNeg(BaseTest): + def test_posneg(self) -> None: + x = torch.ones(1, 3, 224, 224) - 2 + self.assertGreater( + torch.sum(reducer.posneg(x) >= 0).item(), torch.sum(x >= 0).item() + ) + + if __name__ == "__main__": unittest.main() diff --git a/tutorials/WeightVisualization_OptimViz.ipynb b/tutorials/WeightVisualization_OptimViz.ipynb index 158aeb6fbc..d0560a4eed 100644 --- a/tutorials/WeightVisualization_OptimViz.ipynb +++ b/tutorials/WeightVisualization_OptimViz.ipynb @@ -869,7 +869,7 @@ " history = obj.optimize(optimviz.objectives.n_steps(128))\r\n", " image().show()" ], - "execution_count": 4, + "execution_count": null, "outputs": [] }, { @@ -892,9 +892,10 @@ }, "source": [ "W_3a_3b = optimviz.circuits.get_expanded_weights(model, model.mixed3a, model.mixed3b)\r\n", - "W_3a_3b_np = W_3a_3b.permute(1, 2, 0, 3).numpy() # Convert output to NumPy format" + "W_3a_3b = W_3a_3b.permute(1, 2, 0, 3) # Convert output to NumPy format\r\n", + "W_3a_3b_np = W_3a_3b.numpy()" ], - "execution_count": 5, + "execution_count": null, "outputs": [] }, { @@ -923,7 +924,7 @@ "W_3a_3b_hm = W_3a_3b_hm[11:16, 11:16, :] # crop away border\r\n", "show(W_3a_3b_hm)" ], - "execution_count": 7, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -1091,16 +1092,16 @@ "outputId": "1581f7d9-8556-44ea-8df5-ef862c8369be" }, "source": [ - "reducer = optimviz.ChannelReducer(3)\r\n", + "reducer = optimviz.reducer.ChannelReducer(3, \"NMF\")\r\n", "\r\n", - "W_3a_3b_posneg = np.concatenate([np.maximum(0, W_3a_3b_np), np.maximum(0, -W_3a_3b_np)], axis=2)\r\n", + "W_3a_3b_posneg = optimviz.reducer.posneg(W_3a_3b, dim=2)\r\n", "\r\n", "W_nmf = reducer.fit_transform(W_3a_3b_posneg[..., 320], reshape=False)\r\n", - "W_nmf /= W_nmf.max()\r\n", + "W_nmf = W_nmf / W_nmf.max()\r\n", "W_nmf = W_nmf[11:16, 11:16, :] # crop away border\r\n", - "show(W_nmf, resize=True)" + "show(W_nmf.numpy(), resize=True)" ], - "execution_count": 8, + "execution_count": null, "outputs": [ { "output_type": "stream", From 024b87ee12af205bb0f794b2353645dbe4f35355 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 14 Dec 2020 17:04:15 -0700 Subject: [PATCH 33/76] Remove duplicate class --- tests/optim/utils/test_reducer.py | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py index a82751d0ce..d8ab5a28ec 100644 --- a/tests/optim/utils/test_reducer.py +++ b/tests/optim/utils/test_reducer.py @@ -9,19 +9,6 @@ from tests.helpers.basic import BaseTest -class TestReductionAlgorithm(object): - """ - Fake reduction algorithm for testing - """ - - def __init__(self, n_components=3, **kwargs) -> None: - self.n_components = n_components - - def fit_transform(self, x: Union[torch.Tensor, np.ndarray]) -> np.ndarray: - x = x.numpy() if torch.is_tensor(x) else x - return x[..., 0:3] - - class TestReductionAlgorithm(object): """ Fake reduction algorithm for testing From bd1b4ba0b9c9d4b755cbdf5216f7c098783a3398 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 15 Dec 2020 16:28:53 -0700 Subject: [PATCH 34/76] Add missing type hints & tutorial improvements The weight visualization tutorial is now 100%! No more NumPy format or NumPy required! --- captum/optim/_utils/reducer.py | 6 +- tutorials/WeightVisualization_OptimViz.ipynb | 79 +++++++++----------- 2 files changed, 39 insertions(+), 46 deletions(-) diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index d2eb7eace3..c76a930f69 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -1,4 +1,4 @@ -from typing import Any, Callable, Union +from typing import Any, Callable, List, Union import numpy as np @@ -95,13 +95,13 @@ def fit_transform( return x_out - def __getattr__(self, name): + def __getattr__(self, name: str) -> Any: if name in self.__dict__: return self.__dict__[name] elif name + "_" in self._reducer.__dict__: return self._reducer.__dict__[name + "_"] - def __dir__(self): + def __dir__(self) -> List: dynamic_attrs = [ name[:-1] for name in dir(self._reducer) diff --git a/tutorials/WeightVisualization_OptimViz.ipynb b/tutorials/WeightVisualization_OptimViz.ipynb index d0560a4eed..770d8981af 100644 --- a/tutorials/WeightVisualization_OptimViz.ipynb +++ b/tutorials/WeightVisualization_OptimViz.ipynb @@ -5,8 +5,7 @@ "colab": { "name": "WeightVisualization_OptimViz.ipynb", "provenance": [], - "collapsed_sections": [], - "toc_visible": true + "collapsed_sections": [] }, "kernelspec": { "name": "python3", @@ -805,17 +804,9 @@ "import matplotlib.pyplot as plt\r\n", "\r\n", "\r\n", - "def resize_image(x: np.ndarray) -> np.ndarray:\r\n", - " x = torch.as_tensor(x).permute(2, 1, 0).unsqueeze(0)\r\n", - " x = torch.nn.functional.interpolate(x, size=(224,224), mode='bilinear')\r\n", - " x = x.squeeze(0).permute(2, 1, 0).numpy()\r\n", - " return x\r\n", - "\r\n", - "\r\n", - "def show(x: np.ndarray, resize: bool = False, scale: float = 255.0) -> None:\r\n", - " assert x.ndim == 3\r\n", - " if resize:\r\n", - " x = resize_image(x)\r\n", + "def show(x: np.ndarray, scale: float = 255.0) -> None:\r\n", + " assert len(x.shape) == 3\r\n", + " x = x.permute(1,2,0).numpy() if torch.is_tensor(x) else x\r\n", " if x.shape[2] == 1:\r\n", " x = np.concatenate([x, x, x], 2)\r\n", " x = x * scale\r\n", @@ -824,31 +815,42 @@ " plt.show()\r\n", "\r\n", "\r\n", - "def weight_heatmap(array: np.ndarray) -> np.ndarray:\r\n", - " def C(x: str) -> np.ndarray:\r\n", - " def H(x: str) -> float:\r\n", + "def tensor_heatmap(\r\n", + " tensor: torch.Tensor,\r\n", + " colors=[\"0571b0\", \"92c5de\", \"f7f7f7\", \"f4a582\", \"ca0020\"],\r\n", + ") -> torch.Tensor:\r\n", + " \"\"\"\r\n", + " Create a color heatmap of an input tensor\r\n", + " \"\"\"\r\n", + "\r\n", + " assert len(colors) == 5\r\n", + "\r\n", + " def get_color(x: str) -> torch.Tensor:\r\n", + " def hex2base10(x: str) -> float:\r\n", " return int(x, 16) / 255.0\r\n", "\r\n", - " return np.asarray([H(x[0:2]), H(x[2:4]), H(x[4:6])])\r\n", + " return torch.tensor(\r\n", + " [hex2base10(x[0:2]), hex2base10(x[2:4]), hex2base10(x[4:6])]\r\n", + " )\r\n", "\r\n", - " def weight_color_scale(x: np.float32) -> np.float32:\r\n", + " def color_scale(x: torch.Tensor) -> torch.Tensor:\r\n", " if x < 0:\r\n", " x = -x\r\n", " if x < 0.5:\r\n", " x = x * 2\r\n", - " return (1 - x) * C(\"f7f7f7\") + x * C(\"92c5de\")\r\n", + " return (1 - x) * get_color(colors[2]) + x * get_color(colors[1])\r\n", " else:\r\n", " x = (x - 0.5) * 2\r\n", - " return (1 - x) * C(\"92c5de\") + x * C(\"0571b0\")\r\n", + " return (1 - x) * get_color(colors[1]) + x * get_color(colors[0])\r\n", " else:\r\n", " if x < 0.5:\r\n", " x = x * 2\r\n", - " return (1 - x) * C(\"f7f7f7\") + x * C(\"f4a582\")\r\n", + " return (1 - x) * get_color(colors[2]) + x * get_color(colors[3])\r\n", " else:\r\n", " x = (x - 0.5) * 2\r\n", - " return (1 - x) * C(\"f4a582\") + x * C(\"ca0020\")\r\n", + " return (1 - x) * get_color(colors[3]) + x * get_color(colors[4])\r\n", "\r\n", - " return np.asarray([[weight_color_scale(x) for x in a] for a in array])\r\n", + " return torch.stack([torch.stack([color_scale(x) for x in t]) for t in tensor]).permute(2, 0, 1)\r\n", "\r\n", "\r\n", "def visualize_activations(model, target, channel: int, neuron=True) -> None:\r\n", @@ -882,7 +884,7 @@ "\r\n", "We can extract expanded weights with Captum.optim's get_expanded_weights function.\r\n", "\r\n", - "Below we extract the expanded weights from between the mixed3a and mixed3b layers:" + "Below we extract the expanded weights from between the mixed3a and mixed3b layers. The output tensor is in the form of / has a shape of: `[output channels, input channels, y, x]`" ] }, { @@ -892,8 +894,7 @@ }, "source": [ "W_3a_3b = optimviz.circuits.get_expanded_weights(model, model.mixed3a, model.mixed3b)\r\n", - "W_3a_3b = W_3a_3b.permute(1, 2, 0, 3) # Convert output to NumPy format\r\n", - "W_3a_3b_np = W_3a_3b.numpy()" + "W_3a_3b = W_3a_3b.permute(3, 0, 1, 2) # Move output channels to front for simplicity" ], "execution_count": null, "outputs": [] @@ -917,11 +918,11 @@ "height": 248 }, "id": "BiAXnE0zqyFP", - "outputId": "25703dc5-8584-4037-a991-c485f9bb3773" + "outputId": "e4b6c784-17c9-468b-c202-364faf6de12a" }, "source": [ - "W_3a_3b_hm = weight_heatmap(W_3a_3b_np[:,:,147,379] / W_3a_3b_np[:,:,:,379].max())\r\n", - "W_3a_3b_hm = W_3a_3b_hm[11:16, 11:16, :] # crop away border\r\n", + "W_3a_3b_hm = tensor_heatmap(W_3a_3b[379, 147, ...] / W_3a_3b[379, ...].max())\r\n", + "W_3a_3b_hm = W_3a_3b_hm[:, 11:16, 11:16] # crop away border\r\n", "show(W_3a_3b_hm)" ], "execution_count": null, @@ -1086,35 +1087,27 @@ "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 304 + "height": 248 }, "id": "rrT2Z3HiVDPt", - "outputId": "1581f7d9-8556-44ea-8df5-ef862c8369be" + "outputId": "b3799641-62de-4ac7-be9e-de5fb362edb1" }, "source": [ "reducer = optimviz.reducer.ChannelReducer(3, \"NMF\")\r\n", "\r\n", "W_3a_3b_posneg = optimviz.reducer.posneg(W_3a_3b, dim=2)\r\n", "\r\n", - "W_nmf = reducer.fit_transform(W_3a_3b_posneg[..., 320], reshape=False)\r\n", + "W_nmf = reducer.fit_transform(W_3a_3b_posneg[320, ...])\r\n", "W_nmf = W_nmf / W_nmf.max()\r\n", - "W_nmf = W_nmf[11:16, 11:16, :] # crop away border\r\n", - "show(W_nmf.numpy(), resize=True)" + "W_nmf = W_nmf[:, 11:16, 11:16] # crop away border\r\n", + "show(W_nmf)" ], "execution_count": null, "outputs": [ - { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3063: UserWarning: Default upsampling behavior when mode=bilinear is changed to align_corners=False since 0.4.0. Please specify align_corners=True if the old behavior is desired. See the documentation of nn.Upsample for details.\n", - " \"See the documentation of nn.Upsample for details.\".format(mode))\n" - ], - "name": "stderr" - }, { "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2dUbKsOo+l5TxVrzWamkKPvF97QB1R/0b1gGUvLUmG3PckZMSP782TIMsGjD+WbEh2U1V50pOe9H3pdfcOPOlJT8rTA+eTnvSl6YHzSU/60vTA+aQnfWl64HzSk740/ccq87//6/98ZCpXpYnKH9n0JSp/RMV/p3b9I5vsH2+fyy6P6tigntzf12t5oi/Zr2EvEWnSbFmbiPzp62CXlzRpUA7z+rJmZaaP6GvUO/P6MtQb8vq1VmUTaZuIbH1ZRbpt5qn367a5/rOvjzwrr1T3LOe3a7af3WbbtLrAt+kmL/mRJj/SdNu/5UeabPLS/btRfvTvdirf1Oe95F+zPqyL6pl5tv4jTT5zZ+P//f//2zL7o5xPetKXpgfOJz3pS9MD55Oe9KXpgfNJT/rS9MD5pCd9aXrgfNKTvjQ9cD7pSV+aHjif9KQvTQ+cT3rSl6YHzic96UvTA+eTnvSl6YHzSU/60vTA+aQnfWl64HzSk740PXA+6Ulfmh44n/SkL00PnE960pemB84nPelL0wPnk570pemB80lP+tK0fMGXfOiFRvsLqX5b0vZJw95hrTFPwa6lLX4fJU223N5YruqqfP5Wyo7vzDGfLXey/bT2bd6p2zRtlTb8Y10z7/3d+xwDx2kJ558P7Zjq/ua3Jk0U/9P921s3UW3g39/ep/v75mx9G/bdd8/bpl2aqO72adu/Xypk20+mKiKism+RlxuVfElTWJZq2erJy+5v0lPweZH/q2+dl/vb9+zNeTLfdqfdtrRrfyuezjfyDV+zKbxtb5RTKmdl+zGoijbtZbtdDbb+Ue1vu9vfg7i/Ac/yN2mqM09UWlJ+z+/ldJvr2usQ6cuS1COwH7Hevedcl5Zw/od+YmeaiGy9+bYBmgMMvjeNNh0w0UetS5pNya5gV9lfw4ldqNtEexnLsddO7rXsr6fsy0LL6Wsvt1mHwrJ7pSW+HnMrlrPXafIrMkUcUADigFC3HRSXX8M8gA11bB06qmfk7a/lnMCrt8tG4CBUWwdkc3AgdC0tv8lLwdfla38NJ6573xeWEw3LV6YlnP/5kZ3Rfu3bOjh26BsB2AC0CaWHD9aVYVWAW52t6zEA+IfKKNgRwv19tSUsHTwEEsGetmp5QpZvI19uHdA5hZAB55eDTdW/q1aiQmoHb7y/1qktQCg5kLty9vJq7Qpg6QRswJKCi2VMKec6g8lKGkHVRXlf5sp0AOdnZHyC1mQz9RQLSyekE8IGajmDQG8f1/kJmgMT8gZ82E07jDqh1H4hMYhEp1LmcCEwrK4vaTohal0V3bKiilagb0n5CKdXND1pI+UL8FaKqmnZ/ALgofdgnldHDzKDmiimQIibgSpRRYNif4iHKq3h/MDf7tyBMCBBLdWuo35kNdU1D2MnjKSqaYg7gQ12+QP1eUBb73Rz3GjA+XA1AtmkyR/x4GGYirAxuElorNMvhrQGsMi8XK2+eQxqYFF4O6CEcgMuUsJG9ThF7eUhTxtCxkBFED1YOJ5k0HIFzdWXFTIrP8edV6b1mPNjyrmHtRMkGlOaoo5QFaG1UDV+ZnibqKgolCO7KKjpH7D/Ea+YXrUGjJAflU8JKPbDP7Pgx6OthDVuZ8ItAN0C0FLhUBWpHMKLMEKdE0L1Y1KEHEJeKZVQS3CjOh6BdxbMfBz6pWHtJ5XToNSxPpWzAZg0xiQwfZ6SfQLnwVSfrwCpqMy/maKiyiEkKqPCODOGvOM7gFeFp7W9VllWT5EcSoLPQefVMfji2NP5JqAGQKGuBG5ZqtwbY8+/BKbwBYHKXZmuV0415dxPoA9XeeYWwcMJIvzoADaGqhb6st264B+Y/MH/bMa2Kyeq5Fjexh8VYhg9mJna0rrGyZ18NrcldflJImtkB9iAgkPaGOLquNUR1RG/A3wOUFJJqfxsFiGH55XYMjAlU7oMxBRcLsOwztsq+/m/Lh3cSvnUzkQoN50K+n4Y68GLIS52RfBTb/N5dgHJJncMzEQl0S8Jd205qmEFcQde6zDXK6qEo+VwNoSeBHOqth3wajmvG8vv22IFlaFe8/NytiNVOwemlArKNvhQ3TMyuSbdMlsr8hIc520DSlLABMo547oIb0VEQRHDJI8CwJL46Vyes6BxrBnBygAzGAv4NPpmt0nOTCbt3y2FK1M/l5dCdgxlVMqpjGPZ1BhUdF/ucEo1i2rKyOPRPPRt4fZMAipAKIWPnx2eft+lnJ/aGc1hzKCM0E2ldEqXgDUVM1PaGkyu24P4GldhAySDcZ9ZrXwY1kwFGbxVOQxtxbWOU82xHKbKxvK6rPqyTg3Vha4B9AJgEb5VsgpXGUoIixcKGiGsfbJ9EbG5hS+C8z8/8oRQDFsRPLueVnlpOTkIfQG6I7Cnkr/Gxz9k8KcGcoCpxz40Hs1hPKuoON4VO2KJCuqhNHgmSEpjQ2uXDZaVZnEB3KCmtA99hhjzq1snAzoHEqvZdhzCBgjVbWd9C6b31HEb5YvC2o8pp2D3QXCmojo1TcPbqKTH0Jnlj8vf1MNoE1YztLUx5qufsBq6HLjqOwKWwqjV+NK2g+DOtnBADlhmGBpAdeX0BKCsgipbViaoaj97HIYmoSSrpVdKsmegOvucoQ3hdIDab3v2vOvSVynn1qHQJOx1qqlZSPqi/DimdHriLggvqstDPR9ux7AU4Zgzs3X4CiFuOs7c61yV8z4xpPVwcjg6jy7YKQydM7sZiL0e7T6NfDp0G4Sw4z4nXQjmmDMbN55RUwSqAhLh24JvHIdmM8IoB9elmx7fS26lOHV8CU8SzdA2gXF8NLk18hLQgt7JUGmbcAnriNsIFbMJHoBCz8CET/mcGYuyarax3Szsfcm8lYLHgNA4MBkogDeDLYarHmx7VjZVZ1XZkjLzMm0h5gTHK6SpI0N8Zpxq9dstkThOHUACrL5uDGuvA/RyOD1sE1IXqopXVz+enFBORTWVQ2A5xH1ReGuh7YRzTgphmGtXcoQAoFIOK+tJInu2NgOs0XaqsDi/QMxva+XsvzBGpItRBeRbvqSubjwr5MewDGgIRAcrjTmtDr5nCQr6wvIFfNnMrYN2zC5fl64fcw7Vwnud8CsVMSCjLQA3YDN1xC70GmXmDO4L8k1NG9W3g4njzRIQ9Urnx4A1aNm4MgtVI8xTPVN/sVspEaotA24FYArkQpUZStE53hQNk07zjnYcM/qwVoXvbzowHWislJxnoW0GH41z3QUBpeK6dMPvOXMgN1t3KonBBADnxpQYok4A50QTAqkAngiONzcAU12NCVh6pGx1OLtWxpVKnoG9hhPX8SK2UsQdJJk+qISwPupZrPPYVUVE+o+vPXAAjcZwlseTqIAzPE4UNKguhtTZRJQ6kP0syTXpht9z7t1jbzKeAKIH4l2TNLidwv+9BEHdVRehZUDbLKfRvgGYe632DobWT+T+g/E1TBz2nglVcRybq6R/4CBT0Qy8HMZdTcWppwdUDoCUMYE0SnSglfxnaCtuXCoMhXpldCpK6paHqgzmBpCTKgZY13lfFtZ+cEJoKJV//oKBnLdSok+4baI8wfMCH7w9Msefs6OiavrlXC3bUuXiRBGPSXO4mhDcAeSqHP8qhVE0IAjGFFuALwVSoY492gmKKxJCWRxmjCeQZBMeAzogYCzJoPgJIz8ORRXNlbfYprsAqDDQV6bLf88pwsq5CYa4PrxNQB2gQb5TVL4tgusNoGygkH9kqiZBWoSjE4wKTAxxI1RZmVcoG9Uy7ofPm0gxWCIev2z8aJFHUmYoYo9yshBYhMJacWFtALbXH8JaJcgcSH7cWIejFXxeYZ1PMns7Q+wvC2s//XtOD91L8C0IXlEjkFsxntyRimEs+0+FbVSm23WTDUCowtg0xFUuE6FiUAdomqmsD3tXsO7tm400KzXFkJfDUR+dSKKAGMIGIIVVVmTc72y2NwZGDFedEib3HXncGMetW5JPs7Ogzlk+jkm/Kqz95JhzH+951fTXKv+9h7eJao4yHlA/0WMg4kzshBPHmHMcOvOPJ2d6iFuqrH9goVK9+GADwmt5q3L4Tr8FmDwuFMkVNvjpfluLQ1whP+3LbdYthU+qjA7IqI5xfJqPRbOxYwZ8GIvi/rhx8ReFtZ+ard1/lYJg2kSQh3KsK9sjhH6WlvMMQA9pUNBxy2Xrvjuse6fXCSFBJmPyJgczhsKF6mkFY3Y7JVdUO0avkhFWzfITGAVgnPeUxU0abaGsCIauCCmDHFSSZm89tKh0RZ74MWycXFqFr3xhiHLxNWHtZ54QatD5GUQbbxq8UUGn7w6fn+DBcBaBZIAJUs0UtAk+IYSQOEDHe328qnrly0CiEFkZVpzwifdC9395IgnhlHE0M9QEGDlElQpQCeANP6F6WTHT8ugnaTjrx5o+ZI3QWujJKooTSBWYifImM8joe2W66dWYTeYjejbWzACMTTQha30iCG0ILI8pcf1FM7uZiu/bkLEHCSzKwGUhaw3r8AHlZWX1dWfhLKutHdNCIfv3DFHzfFdH5VuAv0kFrvfzwCGQDFoCVQpSAhY9qBAHUJvg44Ccb8tfFdZ+5vG91k8UAtFkg+UJYhbeelDnK4IR0KmWHLZ6RcVxp9+f+fieh29O2HCYygAfgdltShNCss/a5rBWTwrhtnHMycvrbwxbA0in7TbskAN1nYG3D0Or7w7WIbQc+lYq2HuSRnva+/R6QG94TckEYzaRh2KGtAYyhrGkngv7Js2NP6OiVqBa6G3PqzJE/jZKVEqGJwFTLTCtIc/rzNXVP4SQQKkSoZIZcm7Of5bZglpmYe4K3iostiAxUU2EysGTqVsMf1NlxLJBJRnMWSeGwV8V1n7mVsoeKmZKuTkYGeAMPgQU1FKbaMgzFc0h1L6M7wC3B+BzpZzhLY8L48QRlSHQc+CyMHYFqYfTw5apKCjmgKcAroO1sV0KsIdiJv4iNHG0jU8MUz2EPLnD9zPz0BbVFMoutjOVN8J+ZbpvzKmZUiKwHOraaWHVbLK/dDqGtLMM5jGotK44IbRP9AgBmo8pGy0noSfN6uZwH4WxdUjb+sVU4TOfI0YF8zDNSaMKXh+2urIhD0Au8na7hbVTlbIJH7Tzc7hRGac9H0cibJWiZmEuQn1duvHH1s01Q5wI4jxTVgYUoc1CVQbV+6o0uN9q5f16DWCmjom6Kavfaoyag7iPRavxrQ9vPXgROBw9eXgFxofRF+GOatntrryH0U8SIZxx9lWS+5OZMgabEqBBfXksyXArlOVtfZFyfvI1JfOkozJ6qOY9yyYB0uH7WuQloaoLfZvzw5dW4H7VY816eb9yZ4p7Zgy5AZ5V2JyPS2V0rwLQoZAezA3zReDpIK/EcyZW6vrNFpRY/B+Wsj/ZkKjmkc2HwZnCVRM9m0hyH5TB9Yr7bzJbK5KooZgietWMoGG4mwGNHwBNFfwxhKZ9kC2UFQPNAVSHmfstgHwiJ4auq/wM3qP92PfXqZ0kkKnAWBHCV/JhFYxjToQwuSA4EDGA7d0cnlfN1G5Akkz05NBmYakPhyOMBK6DtNeneFTXpS8Iaxm6qKjRVxO73fvM1DNuaz6RlIHqt32kkvutgAWwpyFd1xHHpnFZhEHK1rXDt/LJx5NpSJyCupcd/grlwMcBowwbw3SkcgyiX45hK4PZ87TezpXplrA2hEpizbUCMht7emCX/r8ANRtzDhXVDDQLR+NjdTWEUSmP1JQngTI4jwHt8BXguXUFyNqRL4W5LfpOHxEeNx4r5ASIx4MeokpZE0i1yot1XpluDWsrmGoAs0mkFYD4Vy5+Ayo+wYPhaqaiK4U9gvAIzA08s9ldVNdUC1z3CqFnAlwFn3ufUzIuTeu39USpvSKqOFhpbJhBdwQ2g4j3TUMe1RXB/HdQznHCsvD090BGO8/SSlm+HvuiMq1gYhDP5uUh7UuOlHXmxXcIHSunW7a/f1qGrwXkSvYjyHXiM+FE4PKw9n1AI4SrkPaM8k7f69KtY07fHCtQpbAf5RV1aQFmUd/LAWKqWI0Tj0LZWC67RfJeCOzhPAIrLlu7QNdMQOXuHlU1yW/ZtuYEVAQjV1IHKI0rK5C8z/F6VMss/rgu3XQrpQKRla5BkzF0UUnt6aJjUDMFrcvWgHlVfKUqGcvlfiswK/W25XgrJQcx14IUPqUum8y21qEz7IOyNtH41U2+1EqZXRpqnzMQ8p77ULo+uuvSTX9lzA47mVFVtiUQCgObAVzDVtVZAZyHpyvFNATPwfcq66zArPfBw1nrQJ6fjbQSVUVMWqWoJwJHxV/9REBzBc3HlTXEsGXdxB/t6vJS1X9duukdQgigSLxXiQrKIEWIMqCysmf9sM7x4LvMmdiJglfIHEYOS3NVPA5tz4CNcKKG5JqTA5nDWZZT7O4F/M3ylPLmHDsDFkBx9xqzvSuUMM3P1XRdp32uS7coZ65cFZBS2Ou8jcq/p7Jx235smIWsVZibAXcWNK+Ir0Ow9yWRGqjY7dZ+XkPWQOeAdh/NtmWzvJs0+ZEKsKisDDAfSVXHkQ+HxVrUc1268T5nNr5UOQPLOXsOawT3VdS1f8/H9XIg42TRym8dvvrpoXrcGRU8h7MGM1PK3BfbYgV7Dvexr4q/FOTwZGpXQ1gr5xG4FZi4fF1awmkvWvxEskNtgg8PeIheDlaDef8RVwazCEOr3T5tTeap2Lu7UpnWT0EbZScIcwQ69Sza0O9V+uF6BnCcIX6V5aefwJKO45jfdrlR+J6lrE2mTd23jK1uMh9stPa187raPvtmYWz9iZeRNaQM9xGAuX2WuzYt4fz50EazZvDNgcDwA9y9qZomzZ3DvJEN/fwPsON++AfdhT7mMTu9H6laJze40BchnDYMhRlGb+FHEV69y9sxmXaoa7dNMKQ0LQI/beA/y0YF9N+1cir5e98cwErZtn50awh9GRnryWP8VG7+KSiE8Xos97SE83/aKvf3KW+iDgn/9s+d1OzD7weS/odycBybgxnL+ovC1kwrpo5OKLpNBaDzYDLIuD7LZODzmDWHNwt7/YQQggmg6QSHwbWfdFWh7f6LHrbFcWplG9vVCk4OvCt4VwrHH+51e2qwHHvn/WkJ578ugJMf6aqVFJq+TZg2OiXhnbQNy3sII5gNfm84bR6uqI6vwh6A00x9GbqknLBC1uNRDO1zoLTfs2zUBgCQHuQ3UF/NICV/W0aom43gEMgzIKIynvOzC2zsfRXIe/pQ9z+dboOzhpLU8gjeVqin5TvoDpSzeXhteaWAhsQr2AtAGUDNQWQ/VNqXZGBaWKsREJ1AIbARGo3wGUwaQ+S9/RnoRC0tr8365tTKaozJavouvCv4vgvELF0O537yzwEXm1fhBKv79vWysjJ808cpbctDXBEtQlevln5M+QagksHK9zh5Iop9RKZyIngK9xkJTHurhMs3EEkFAUI/29pmvhLQCagYsO5pDVs9iXMAo570WwK8p7vAXY85X5/Z6BrKREkdNDYlkMOG/nnYKsG2pWDOjjm7/d71z4WxR4BmsFWKui6Pj7/P9mjjxV0ImUqbDw606Yuhrxt3agKhqHsr4gCxMbwTSFTicW5VhCeBojrWM7dLyFoGJPa+PDXns/b9dLoFThE8HdAMlaK24trKStnOQBe3MzpvBmgzPDNlS6D61adQSa21M/5no+P5B4b9eLzBc65eBUc70J+98DawKyipsze4wLZZvsF2EfYmcFaPbqH0GsOTQkeKi3BVPkcJx6zXpdsnhFLIAJRx1R2dYRWGTkDX4WocX6aq3W0IkghD9RrA/h1QjxVUFv4iPwAiwAbh7VC+No9/B4vUbfgIjDtlhMGpqvIFAPMTm4jKfOa1UkewtXCWQs1R9Y6AjCDfFcpiuuVWiggD4MeNfLfLwduS08BKyJM/YTIoAbYR0FBuDQeFtvo7SKXM07cU1MacYzwpHSpUNAXARGDCaIK8t6sfR2qjcLYZsDzWZO2qlVVURVp2G6VSxyqszRRUEr/QA0fbezunMwr7d9MtyiliUKlruo3AdNA5AHO45jgzAhsALdaz2d33YJqfV6J6eVk9Rk5X21XxcILK6RxDDvAaLMtU0DnmlAmhtSOqJoa6DcawGZDVcr8Fsyvh6tlZD1+j9eyzHIuKynzju+uNoYferZ63wmlX0fSWSVBLnNDJ/bYC2KnKa+XEdbzCB3Xsx/BPQtMI5AmAFwoqo5x68HAcyWAmkIpQyKseQluev/ck8BBsKXxAuVkNI5hHj+v1Whezs34voIEDlAzk9WqJ6b6w9lAlkxDW+SBI7FdAhyH0SjlxbNbEw6PzBL4bsk4lVWEgY32Jmir65WorFXgCcGGYC8uSqSOGrk3GbzA3snN4K2M5Aon2Cs4x1tQjFe32xmoqwluLH2tPD6jvqPeNP++bEKpC1oYg5fkxdH0HwpjnZ3VBNVoW1kLwmCrikbqaAp5TU+E8zfIprEVV631tQkiq2uayNLInqrm1vdGDmhJ0s/sjtAmc4520/HOtbAKIx6MrhdwSP5k+Kol99tDR9W+Mbe+BswRvfm/OloDmAMp8V0q6+7kwuOVgVmEthpKmpqfAtJId7JcwXAewaqWao3X7/xiWTiDFIFWZbdGXA3SVOlLoKlhGMjjxYqHj3Ei/CHgwGapsPMpAJrO1Ovdgwga25vPnnobeOpau5nQN5wfuc4brXCu+BaGq8hNwU5hnXVtiGx0ug1W8Wi4BVLSr+CeBNIHPwGYlRfiwPgtvC7t1QZ1gCo8de7gq4GOzstKVdfzVMStP0O7nMYI6z+8CTrPbBYFAxO/47Czkj5d85eoprcoXt9ycjb71eiAx3furFAdcpoIII+RnChlsU/22xBZVMoFV9lDPThJDKoL2Ce7094/qTX8CVnMoS1DVA2lY4JhThCEF5ep5gupo7QjKKnYrxdYRtAxUwfUJpMCyx6OGcx825A8ZtA6fL7NQUQJz7IXi3szvbwhpRe5+CKFSzdW4M1O+RDXH87kh/CUYV7CKijRTO4VZ1zZOMIa5waYG6AyEETpnAwUd20tAFVDOGN7u+VElAcy2N6a7Z4kwN4C5AHWoruTqKJCnEi8CY12s8mSCRzbZ738ycHl4W6qoxj0cvdCupMIcMrT3cHrrbC2DybdUhBW1gHYLeWs1nFCuYJcRdhmeLqzVmZeHugCrsg+HsgZdMjYVhhABbS5PTIky6ET95JAI+PVlU8MBUgQ1+skcr7IftF5clnGRaFXoegDmKKdVWCzp2NJfUiTPwyznd126F85UGc98H8G1grrbwwSQXbsJYkGoKHyVlk4GpWGs7mNQBjOAqqioM1QN0LrQdgJujTth7IoHkImpZtvpMqgEQ9gkbBU7VwG4qKL7LjaxZ5NTOO1ichZKp7IANMzo1iFtkq+8NwChp3Ps7ZXpvocQAM5xw/8UXHKgqEdQvlPW0JknDseXY33c+2R492+bV7M/D1iBOdYVwfTKOX1ARcd/+7r2uNZN9CCo+6aCGlr/H9BaWwe/OA7tVY71AKp4OGWA6wFsfbInhbZx6OuXczD7XoTxpQwAG9th+Y5w1tK9t1ICEJVSVt+6X+HlADIGjpQTHzwQp6jSw66uXTqX45hT9os4rnO+SBG68qSPhnGlcBk3yzshNUWwUHYKhAfVAdj9PcTGSIdIZSqsQLdvsI1EYQO4+67Oy5v7lYkpYXU/c/UIX8+rnhRqvDdzOQ1v1c5fVNCr0j2ztQChnAlfHXDJrG1fFwYxg1L6g/EJ1GKQUqg7lbIv62J8KUeg2gxtEqoCpD5sRYU88ulgjvGmeMD6CXCKagrLADbz7eetH0WqmuYr5Fuu9xMdZl2z2dYESlLXkZf8asUH07BH8LQX7qXsTeLW70iX3+cUWcBINgl5BaComm3vpNMu8/E+8pvA9lnIIi+GsqakktijSk7oCFQHeaKQimVx/ImAe7sRN6O4BagIZoN8gXW7cKkkQNqJKuATnes21jVnu6BW8CFMmuQ1A+/M7zlxJ0EpB4DTZ8LqwbwjvL3lNSUiKyhRLSdQcsYvHVMSlILqOEGUMEk087w6EqiJilrXPFJQER47IqQIaJz42RXcwzrQtj5thIFiGrimdDZ+HP42Q8uKKrRu5cc59SEtj+RQo7x/AhOEug1AnJ/sJ2MAaxHatkRV557C3o0r2xePOT/6EAKHtmeVtPUJpAWEEtTP4JUUUgn5OAa1PUYQ23jhtilggFYyBS0g1QQ8A1Q55LVtoXrDiHWooAcPFRPBzUD0Ktp3VIXCXRl7jCo7lxnINuu2SgwWhqll4C0mfpTsBKH3n2k/tQmsRb+/GtR7bqUEAAsVHD4MXTssK1R25S8ILU4U2XR6sxlZUkXpYIwb3RFCr56okOs8kSwsJniV7f2gBfvcVNLdbgdufEF+g/yeQuhqPiN/bnP4kGraEQQftQZYwUR5mSqWj+rVII+8pI9n3T65s/LxdM+tlAYPHKwU1C1XEz8VgNJD1bkeVbR3viZzxpbKSIPOP+5BFqAuFHJCmIWmcVJo2JTWy7IoeSJD6bJ110fnmNIW5noFosL6OEKAsQn35Tk7ayy3kRNhArtSCHsS5DauPj7F0Bby5s5G+9WyKXcqJ0OYqOmAKwUW8gWAI2gFoXWquO9KKPeaPtL3IwA3IIyhLELoykiEF/Nx8scBp4liAri2F+N79G0IU1X2WA3DWAUfEWjgybMLdUdf9qHuvq7zYNAHTriiRWVENx4okXMhbgGlmziyRmV/n2olriG+Kt13nzNTzALYmU8KyfCJwdag7A7fxkrbL4cOXFJX6+upcrlQdqpo32QK4Z5XKOFCIQ1Qv53WtzPLiGh/Tn8qpIMQFFFgcmj2PVJRmBgZR+vGrXhkUAeBOGdmfSfQfjVrYztaAMVgdl8Cy6ui5HWE8SnvfZKi2yXpejhLxWQl9KBJWgYh8qDt76fJVFOgThV9WcGJ8AwAACAASURBVH0w5hxg7zYLkVgRReZY5DSkzt+WDdC5Hi8ECKjtUwKtQdUhw1B29NlCRd3Mro01GXDHXZuVlqo5j17Zpt1qkK5AJBjnLK6Qv4fTwwgnwO0VbY8PoH0hnJ98qbRTS4AtqigA2kTc+DGALDGsXfj6sFlhf5rb1lQqVi8LJXmSCL4H1FOD55UYYZMkTO0+NLbE/RnqCvsy+yYrKMBqG9Dop+NkYOptskUb8oATP84Pz72z2b4zmEnImT7lQ+VdKIBqWmwLQBywBoDvSbfP1noYISRN7CtfcXahvKiaww5ARqhnZ4vhbK6SA5zRwcYhj28PKMCrPCkE60oQmg891+uUsOG6HRwpZqZ+CdS7csr+oPAmQ329ykBd7mSr6+U6fO1YzWr1oTIWKjraheBrC98ArwDwfr+d/vMhXZRum61Nx5dgD8qKj9mhDcAS9jcVtO28rB6Dswp7J8TclVqvrAW7H4e6b2WbgUWKOlQS7aa2FNICjG7meDQsPCXUpi2D1YtQARjaXtaAyYmtbIqrWN8EUkThsblCGUdb2AUlAVB8HQ3qx1A4nVNOQKzue346fd+EUCNFlDwP1deBmKiu2LiSwltUzo1BHqGvBAD6LueQnlRKcfZsLCkiaFfcPiqztyNsDQHE1MB+BGtq63YOcSULasmibNPREClYtl4CnJRVsjmAI+huvxv73Zdue/A9QoT2KmRNACWwp28baumUVghU+AxYwcfO2iqc9eM+WYCYqF/qmwAayoqsw1o7iMyWdbxMMedetczXQtzEoyqZ+YZJHFE4Lg+YsyGAMOObwTu2E8ak4nzC3mliuyjdrpwRMPMpACVVm/cnsazs9ytH2amY27BpAme8LTPg7BWHcV+ilCK5gvKJ9oDqqHUvj+sKFwFx9qDqCOAJFWyF3fxjHb0R7Thetp6DnatPo6UJ5GgXbDAHpVdInoWN6mtQChzwCT/bvzuo7Ol2OEtAAcLydkqArPu9yE8OQAzbA5sgMpooJapXAopkYSzZR1+AJ4VKYNHCYW1fT4Cq7KJN2nYerCZtfzs2hrSvfhtoS72LuiGZmjWGxtoE1guA03II2oDS++D5AIcTev/5dH1Y2zs8A1kD6iFdlnvZwwX7+laEvyWIALiHE08sw9i/k/AnV08CDtRzrsuweaUW6HA4USRuParitLcQhqq0l9SKCcDZhUdERF4j0uyNDTbaBncjh6YeQWlt1m2kqK7NFMst4EW/VtQFF4O7xPOe33MWQLp1yXzUK94rrycPf2vVzC4EWMaHlP0kBgW1Hc4f5xNn8/c35xV8ZUM15ls1oHIJlA6YV1TRAdk2tzXSC+oDhfXH1PoM7r6dHaAJcoBTG66Qmu3LXvW6zfnh8dfq6G+J7Acaf0jNE0+w2bvIlC8Ia99TUAMU1l8yYNtO1pmPN2uAvUKtFTSGrbor0ZHfuJq3xLZbJuz+goAdEMeQEzoBKCXmWe0vnbBmiolquaEu4myn7Eq8NSgPdakIDuQYnuYc8fhHg7g2qGdX8bbI9OULQRhnNq4nHsNV6d4H338LqM3AjrFlFaLmSnlu+3ArZe42gIZX7j2XHzyYZdbqiX4ZjPsaK2W3K3a0HL5m9yXZLjLuWWIYO+0d6C0qYIOJIHeR6TO4rdGxWTu0NtvOjHaMzcPlt1n7pT6u0TOfeCFgcPm8XZ1uU84lIK9z+UulfOH6Ebx1+ZkMGU3go07K+SKJoorgeDGW8zDObYnfVt8+dnQDsG0i8mrdBmFspqQu7JUOaQeJxpLj4gETQw7cJtJeLea1eVnBdpmKNg7QtdGslxUtGZe2CJm/CCjNwBYXChF/QugYr0i3hrUDimLsGNZfHcgDeLNyp+GkumGvY3gmCEwSvonvhC7fldNhzVWXOppyB6cLgyme5SGUQkrqbADhq6vpBtsZkEKUAPc6xz68msimI28cR5tevi0YAhj79cLcFZ1PP3Dvw1GMAriQP1b7evP5sAuXpzWcfz634bcgOYLrtcj7C76WJixgg/HK6HYBRLoiu7LNdZgj1d39V/XJ+CsGFkHyumwzjG1Nwl/aG7eHFOoNqpuvD3Bf4suLjBDZ7TPB4FdjOO2ga2d9YluFkLU3DrazH9vK5WkJp35otlbkHCAGx8ZqtipDMFfllmrJvt0EEea0KeW/bYceVF2dlVdakdfXTc34Wynf1hss8/rO6VRU/CnZtrdPUxHdOnwN8jr8amPQrdcHF4N5NHtBYxJV1n4furPYbWOcaD77vzgMmOdu38qMkFVaa+682C0uZ2vuGnF5WsK5fRDOs9C8q3jL5TehFfggEu6EQX/cV/u7EzQBk5d/7bPvjbNjlLdJf1Cg1YBWABJgfrkF8EadrQ3oyrwmI4we23PHZg2t7ngHbOOeKNh6ZWbzkY72C0DPbVai2WZ6HeNqQPvU2xnqvDIdKOfn9moJBT/hQ7dPELRfg3qw3VI5xV9Vl3BV6hmWVfwNEWukZQvankQzAmlg2ffWd8wmbFhJAUhTRWez+5hgV207dGAfv/dWGEebUjYR2Rr8kmyiMMLqbsGLj1HiVXK348XRVrSTPGpT0ulxkmCLcAV2F+Mb0leFtbW6tQKoBNoj0H6xPMIbyeHik3gI48HZPoZ5tCJsHUwDuE7Y+A2meBAb+LfCtgKwyfwrfd3XqWYPZTm8HYBvdjzwdJNr67kyw1g7zqmS+AAGAykyfzqHt3e0n4iGwAOQu3o3b7s43aKcKjIAGLc5khnYCpo1tPEJn1ju5HIyIZSBaccz7UnYCct5XbHMKk0/Gj91dQuKiGACrCO8hANSlQmi+WbqmQA4tidtaXMKbF/KI0gBOBAifztkQORsOrZpdoV/bEyLF0uL2p2aNnE+V6YvGHO24lbHbyFrro4jCM/kG3iskgyYyIT5LTBHp/JKWNYRrplQjqF8dRBQPRFWTezwPSZzGvl2MB2oBvfWpjJieNv3b9rEP9pqIMj0DePPHt66cFe83wiNrUkMvkF6c0MO79fVVMWfs9Dmn0+3hrXrSR5+aD0HzU7oWlnfgPQVbZYGIHSiAnxN1mAmAM/1XQI4D53yPADUTQB1ZWX1tErAPqDKwtwmpJjxe8zYiuThbZMRBu/ctQmEHYIdjdqxtsQGYezIhrGttb8ikDIUVmTC5mdwRUSbj4RQ2S9O900IuQkdjbBIVMQM1BVoZyEtbeMPa/b98at7Zyvse1do56DNgMsuCmQfeQN23V/g9dohUApjtdtdqMogdqAGSAihAxHUEXyDkspUSoRy2CHcnWI3ZcspJEPWoDlU/Lh0KPE8eQ3aT6Hi3b+AsrxKfj7dE9YSEPh6EIT1GDYRORH+unJC/plSUl1u1zPAGK4EtlAugw8h65W8A/FINK6slND5IICu7B7BGBz6Emk/VGZ8t6ikHaQeoYqBOGA1JXMwtgmT+Y0LHuy/+ZtKw7YYsqmmfQtwJR3+sE3F9ZsAvUc5G6nYsBkQjWBZAejHmFhX/t1S5XV1v/w+iYifVBCCrUkB4t6LlmCuyvJAZ3GhmJXrzEDQVrC+ROQnseMyjTWjYoKSCoDIPv3Qhg+o6zjEoXrdBlcnuBuShrGsvqOtB2jNbU9aUY+1L4dFF6ZbxpwOKjEoamAmgBT+Cvu26FPWtw5x8VvEgzjWm1c9d9WVfH10Fio78t36/KNMtu00vMVllQTI3ksBVlTDACCFuNYWQz0tdDW7U0pbZlgHMlMl1d8DHV/40zEAzD2Oh+BRnsIJCbADeGObAWDxCqy+ia9Kt4W1EbAG9jysxT/Xdxbk3b/n4zhXWrmd8N33MYXpELyonmldZX4vX9ZP5U2NbEyZ3AphVRyTNwxbg048QG1z2bZvj+aJuLwRvtqsrp1rDHcprLUTFlUTVCz4LwC2fULwrC4sY/tWKeq/V1grIrKAkEEVVsgC0uG3Dl/PKq3t76hX5klWkaCkIgVoDBY07fDH5nbbdvFa/W2rW1fc7OEDXmdgXV6L+Qaegbu1uWzgMcCgiiPctWUKa2X4eHupmhj9L+yHyunsLdgdrBelG8NaU6+1Woq0RX4vLxWEC4gBCDvOI0Ab7r9EqAaoAbzZU1rL8uN2IswT0Gy7rt/gTOyPeBAZzATOQyVtVN5C17b/41TSytv6Bo/KqYSw1uwiLQlVezVYBqGzc3RgLxWV7Na2ZsTzdkW65wkhg0UEIEgeHgj5BNnIbym8oays1TOre3ysbLcjQAHKNk94ClG2vvIZ9WKPmT7u2zrgeCNB79ibEKi7ulrnc+CxkhqMdmDWRgCaU0pBKNsEt7+6ZDCnIuPvf+q0LYFEe1XGLoQFjCuI17BeS+dNY84GYGWq1k9iyGtSK2Wr65NaFTMYs/FmpY5L9eyf/WTP2yOZOqaKSXU7Fa0AFenK2X1wUsjGhggdq2gCZwxbk7xNRKU5ZcUXsYwnhGxdBN7EAOfArj+w7MNV+JWIUhkAbJyDAGNbKqc08TO0ln9Dui+sFfHAIVTmw3mujDoAghJKbp911+oZfAQ6p0wfr2pSK+Hw2QFZgplBX9UlLfjZxGwJntnsXmWhkk5J6YNha4AXx3rC8M5DFmnzdbUYkxtY2jxU9o0Q2yltUAb8Q1gcYG05jAD4yEfbRWmtnH8+eM0IAAGI0m3jwXMPzwhVez1RAWcI7IHP6pG5vSYBSoa/V+9ADWqZ+DgFBdWryh7Bu5fVcbxO9Tb4ZGAChLjux5TNlR0hMK67MLYRhBgyA2gCCguP8rkBHYSrqIwyluctGA15s/y4pUJ5Ih7cXb3hnFQwfhCHLN34bG3r3wQR3ArJ1NLbpHfMOKNbjzOnPcBYgBqAc4DEdbcfhV8AjsEkX7cc8qwN21RCnJ2tYEVof1q0A3wB3gDz3LT96yaDpOfbRRieKrJDQEcfrgJgthjGndagfd8IvjELOy4YsE0DsteD4bBT6IvTTT8Zm4H8/FUKA9NPohtf7q0VgYqTRaNuVkqhssOeqC1BECAEWwZuCmvviQ0mwFIwGWyos7RJH9d2EJupdAYkgmmg/Pg8hm+m5n1AUmpgexvbUgdzgASdv5mSlSCK4IWoDFlFCp+2HJ/att2EEsJ8UbrpJ2P9pCAMqU2ElTF7yGAvNy9vx2roIUffCuCx20ndGVTBL9hhcNbyOpxdZl6prk1kDPrOAJmoqW4yn51lQHE9KGL32VoN5DS5R/l8yNkcrM6ntaiIUG6OV60tenuRqk7YwE77VynolemesNaBx6o5Ln0+RBV1HSS1CYA8oMxsQnXhPi06PoGSAZgqJfq6OnWGeUcXAYCb63bA8piz+qzgNfgGpB52D2xLbLaO5eBhBbilYuDhWw/wWwGg5vL6drPwE8N7VD2wT1Vs0W+k6g8xXZNuus8pYq09lcyrpgiFmdaiAEg2Ds3HlB3Q4VOVLZQT8pdQBvgKyBAoHC8yaGc/QssM4k9dlqGyYxhnnn3sHPrVbou3S/YqWmIzw75BHGOmsA6fk4CB3T9D3BK/3R6eNc7U88J0462UDoyDwVoSofIdGMEbZRB0AT8CLI4zYV1se7xP4iDLQKtCzxWUMW8PRwOYr3FIa8gRnp8EcLv3mU38MOgSbRPGWX4NbUts0659GR/hw/A0HSOazwhfYefEuk6bPgPYJscgZn4iovep58GY80O7NQDsJ5pC2D1PZ8dwKjeXA1Qigh3HQ1mAx2Uklq+AzGB9C8oX5+UTOCslrcaqUzXnGHT4Vko6zo9/Xtbq0x+GsdXQ0ikfMLIdx5egii58NT9bxxC3VMO+V0q2AaJfr0Ek9bww3TTm9OPF0QBBNXFdDvJ4trW36Ao0LBPy3gcyhfJ1EtgBqg9zHXyvWDbUqRJnabPwNgt3Je7fGETLbBNgU+wC6b3mE2CNyw+PNg0qPoTsG2ri153K4RhSDEKGDdSwDHWhjOQqK8rHd026OawV8Yq3t0gOXMxLw2Iey7px5Qr4ZF3AXkCyVDV6y0IJ7CspO8Ly5sodbldkPc5k+49MlUyO14PYJoy4PaE6IGXjzgGviH+EbxTYbWMcGiaFmvdHsBHaAWEENFPZ4D8OHFT5wnRrWMtA7edkAiVindP8ecyZzdiKX3fwUj4s79tK/AM0fl0TNavyHJQJkAj13DZcnF5zGxnw1nQjr4I0AXSeG/qwTeZ5meD2DtydJ6SzgioqHGFtPxmNoDMo+0bpUboJnYN2BeGAlup2ofGEVQjWDxGRptvCWhGBkLJ1GHSRn4w5BeAdsBXrvZp4MZAloPzJoGpgS0PQIygBuhpc7fXQwwvsKxLhyyD9oTLZ8QqopJBflSeolpm9+X8hrBUBWFG9lGFKIERobVxqoJ2CcPqN12omynqleN70Y2t4JhTD0Aq87uvg5fEph7OuXlkAGGeAh4/ZzgBJMA7YLLQtoCyVNlNke5Jq+LQIuXWoM0DycgHsUL0sz/pt6CqZWs7ePV5EYj/OZsXE5SZhQsig8U/6eNh5xhfrGzO7nG+bVzpQBPyidOMTQlMVcTIozLyCr1e57petOz+G3GxzecAB2ze7+SFoFZANlsWFprWvq2cVBqcXAA/q6F8/ltdqIBHG3h6NbHyxmt0VV/aFnYOGpmF3nkkHV7S72dgW7AMSBy1ACePLOPtrkOEYtSX5+3JD+w3ptgff4+2P3hIthq7Tl8Fhv77fVJ8DO9v22Acs7+2VqjkFRciOlDSFLfpWM7URdv+Io4PyB57lzWCl43fnaK6UYaylfFw5N6Bga5xPoChDw+PSBZQjdNVY71ROu5DABYCWNbNfmG56qbSFnNZAfmyZKtgAFiAOnayXTzse376Z37EemfWLOHCcOiJkrH6ZbxW2QvkSyoOLw9gPBb+fg+XkeMcZr9rEFj23w0lh2f2SQ8FZbRUQzVQSl9tc1pbbcbmh3QEK2x/Q0YUAlkc9fncvSffcSsmUUTQqHvhlyuehtby+DSof8k5DLceAdbga2Y7U0UHMoXACO9fTMn+RNYi8/OPXhzryDK74dYMr7a88rmS/oEL4sDsABcstUb8VoEH1BvCznlAn+vflO9Xzxj9kZJfpDLI2L7tO8bz9PaDhG7dHeSmgR6AUynmmbDPgf1uOfayDAqCt38scY1HroHiMA8YWFbSfptnuM2F/9wUk+vXGbZr4ISAIk4MNwK1C1QxKhBe2oy3zhwOi2dz8yD6X7nsTAgCnDJZIAFEJSu5cqbKC/0pJ03oI5hQWUsx0cufguwIT1bQsl+2PygTTxpp8rAgv5sHyCEmTvJgyNBE0mcsicAUUB0XD/AxGzGOQXR6WTYC3Wd6VAnOe7euF6b4xp+AsrV16dTYA2JXGmhPiWU5JiaW7he8A8tpXRJZgrgBLyyR57U+0B9CP6kU4O3ytiejPXC+hTAAc4W1wWNjU/73L/VQcbAygUYbKdqIYNy7DUleW8yyMhs5g9Qj5CuRfrJ333UrBUHWhnGPgztDRuY7haFJvsg09AfMShhMQtQO/APdZsLP9EBH7najiePLMN9mwfN0t1+AqrTt1NAeELwApDkgENDywEMobaEIgGtxUryRl0fZNcH70VkoC4lhOx5K8XpRxdjnfMWlb4X5pAkQaeibL6S2WCq6zy0W+7ba7x5qpZ9YGbhmVw0N2PrqDOlCxZoXzRWIuJJ3+/mdgDCjYyomfel2bjB9+z3xohADqV8H5qZ1Jxo+CvxBpUo8NI5SZX1RcgvadbwaiCmd/A9qfk/6FrZFtPBXD4esPDgPAB48zS5in7ovcWvBzjuq9QyWFemoFXwYoA1ipYWvT5yXw8D2DWnWIa9L9YW2poDJtYyy6CkGP8vevVF3DN+WfCTV/u14p8QrOP3NZOU8kKiRCmAHJfa7KayLyLzAGZRUfDrpMemcQD/yzEFPJzuFuBa0kdmm5ErZ+AdiKMljXN8H56QmhVVi7Vr3Ef+TJQdlffp8B8x1bkh9AW5Wp/FA5cd/RhsfGyyGPMv9UjkJKCQCb4mKIilUwcG6sSR/bpyPFPAup2V77enPHBfVmx/vhtIRzTDD89bQAkBXs1JgzyxdJO+C737bMH5FzsJy1//kHdWBeSBrVbAXqqnyIZ40gyuNlpeUXfOOfDmQFrJTxlGJCXoAXD9rnaRgD8xX6urSG82P7YgAhXFlICmcZfULZRR3B53jXRkc5689X+3eS+bOarHzfTZVKtmSHXfs23yeHq11YsQxEQy764fq63cq82v5uI9cQ7Xff4Ske2KbySTV/yrMLR9qGWcbn0gGcH96ZFEKCrrKNdY12lw6OIYOxsmUhV5V/JkRjVcG/l1nVmdntj+RyXeX+KKgK153lZZ2bG5BsLfEPAJvdtg/5ZrTtuvq6Pd2VI4hh/1II7fiT738P5RQplQ+XS0AzILVYJrOVX/Yz9eeUfSv4qrwjQDN7VhdCWNmO9qHysw7PoOKBI0D8ducq3BjnK/E15crAYyCDn9RlS0ClWIZ90aIcXjQvSms4P5YALnwvRUvyUxCLvN8q6NG5s+UzoK4UcpVvdZl6ZnWftamIU8AjmxCUA5DCjxsus1XfDlaAghUzA9K1fQXt4kKB+8Bvo2Z/d54Q+uvSfWFtUEpJlmn7b4exyf6fBdG2x0BmsLH9N4CyLdsW2zIlXX2yOl0+wCtgOxvKVkra+Lv7sHJqUgbPhfmcCl15v1b7B+3DFwzcn+w20QfTvWFtpZS87UNFPQJ2vRsulMXtZdCsIM3WM98KUPM9E75WsIocjDetHHQ2rsvyWVGdehJMvjFldPIlQAQCjzUb1MkQp74y6y3hFXHOrKK8PxhpXMvmjbO1Yxvq7W8De3JzWBcCGfLFn8MKSPavAN1kv01SQrJYPwLxlawL2VaQjg90Qjz+cWoA5LSXZlBSCuGsGSvoRGJYu/DFE7BS18Foku/ApOMfedele2drHXQLYNm2AjqrT5LjWAHJPgwkd272OQvomVD2DMjZbG0FX1aH+zYQupFDOeefwUENF2ZtAd4RuiZAYF4KKFZ7AGRItj07PoPPtg3tgLO3F0vnTRNCUgDIPlm5Ez5nUyUCWG8GZRayHgGa2Vn9slD3CMYjqCtQBZZX8I9vBBUaJZ21xWUGVerlShmzmdq0YSsg+aSd8UN4qfhF6d6wNq1foxI6X7QlgIdlMFUX0Wxf+DxWAB7lI1AV5CsITXkrGP/apBB1fAQYlZSX5cQyKloIZ2XWl00Q4cTQqLbwOQUvbou2y0Bacg8xXJdugJMOcAVYAHIFtRR5UKdqXRY3fRTacsc+A2ilnrJYl8SGMGbjToHlfwIrbztts98AKhEmVsgAn8Ay+eK2xmIBJoarkvg5cYXtufuu16XvGHPacqaOnFKfE9BysdWxMahVv7P1s4CuAKzyVqqJyzghdHoiSHxnzZaVDno59soAhMSA8i0UBNONLRlWgkol2irFZEgHhOK37cBcHPIH0/1PCK2WG65X/uh7wi/LWh3nEWxVnhTLvL5SUi63ypdFGYNwTArhcvERibDimLOcvc2uZBW0kJ+BuYQOFxOf8vYKLLtIlepgaL8urP1Y0nMqedQY7YTPqd05qOMdQN/1PwNc5rsKb89+uH7c+fQah3kZZOTXJIGr25oUQBKYqGAV2EdK6b4l5oftJMf8fQ8hfPpKwfVTj0jb4rcw/8NjyYATWl9Bib5ngcRlnlDK/DaynwUUoQvbhoN1ZbBRyI/zmi0mcLwDJoefGZCK26qgzfKT48q2fWH6krCW16u8VZmj+k/mZVkVfBWARza+7ynJcjbWrH59wj9zGvvXOxXu77bIwwq0FesLCJcAiLifipWAYn4GENlOl8N9kpl/6mJg7qs+9ffT/U8IhXWlxapB/iGo77Qzg1gBmqnmClRe52sQg5Ot2/cm+xvg2e/0h2AVXucGQTVleEQiTLSM74vKADurpnhL5AzQoy48rgOYeYLqonRvWBvgo+2Vt1ni6qnMU4ej0beCTsAulJ8BxOqZzcLyN+U3C11ZQS2/f7s/SjvyufPRegAU94Py3ARRUlcFZQbvWTAz+FZ5btvV/mXg0kUghfbz6b4nhETW8IkuYFJq5xPUrepa5kt9rrM+kcH4jjL274b51eN5C3vry4q+DGwGMB7zWwAu1i2UHWEtrA+3E2Bmt1mOVI/BcxcH2D+lMk9YS+tK6w3WOQ/LhsalfKX11a5keRV4uHwWxuTC3jI/+z6zbJDyQwgZpOHTOyGvu0Z4d12mzc1yUh6CcBZMTG891sf7ysAyxEJ+yfY/nG6erRV/NRpyYXmwPuK1oh4H6JntvmGvwFtBVQDrQMyUj78r/6oMlkshZRizY/4NsOJt7lUkhf/yIQTJwTx6iugMmOGC0bytejroAhww3Tdba+A1MmIDWE92NiofK12sL8wr20oZF3nuWnMWQP5+J6QV8kGwbJ8GpFgmATZrDJ4wqsLIhj4CjSI+tOXfcZ4Fs4Iv3Aul/cqU2/2wmn0p5P2uNyF8aKuj8dFmJw+cXFsm4LoqNFdP9skyzzB+AtDlb4uP6pCD7+yhA5wceuv3nCpN4Y8OpVACjKEhzJc7e2UTAhLyM3U6AjM8EF/AWqqoJOvFvqQAX5MOJoQ+dKUI51LJRqCGC7DSepaKjBWIR3nJuTYlcv6/+ea6Kz8EcxXiHn2EVNQ27nzI5na2sEliGxdSDnulBu1jYNrBF/CxUvJD7x9CIks3PoQg0LiwjqC6RkqWbR9PzaJpbNgKzKw67tRj/09+y8E32478sVy2vtF38O0dT6EJ+dUlCKjbtwpGET82AwBx3f2wGbb5DphuPyyPbCVsfBwqp2BlEflwunHMSQeKoI7GFHEq6paxIKSzsKYwamGH8z72VWYHPgPgEay/hZNDW5EEyAliDmrvt9Y5sQNb+RRQoc7OB4w27Oh4HgEqfiWmSg3makLo1K0WgpB9GVZulwvSd9xKYTBHW2nabmPfzsBqttDpNbony9nFOEBZAbiClvN+A2c29sT6FjCONoBxZVBQZkmLYwAABj5JREFUty+w466JMxjNTmGsgt9oI7Bnry05ArMMZVe2Yn8ZVn4I4Vo2b7qVMo5fffvZNkMH1rzD/439wG9YdkpZQZfZMiDPQPoOnDz5Y9/2SSeCALiFfe6qgcL7Yxe1E4oZ+o+p0qy+Vk6wrcA0wI/CWzwm3Gd+DSbf+8Tx7V/reOfSPcoZZlotadKWCaxNfdsP51hdsA/FSIoZmFleBd87QJ4Jf8/Amdk2yjv1ekxbNjD2RRfijq8KRpE4jrNEKunARLDM5pypHqVFULdMbStY0z5BJ3fUn9muS/c/hCAi9RVJk0U6SRaLpYqqVLZOTcmXyzCEeAF5F8gzkGa2TDGzWyjlp3fWDFKBPJnNOvcFOzcnbhRJzksrzlmilqdhw3QAtTORoqbhKx1vus3Pphvvc4o/ea69NLGRv6us2khmUvGdMlHKDBQGkzt3lp/Z5MC2ghOXK1BtPfus8gxekQEpngq3IZzRdSmB1JKLljj0TcDMJnSqkFWxnqQ+Z7N9IZ8QhRXKfGH6ot9zgp3bVCv/f34lG4e4ggTXs4uJJvlcx9n8s364jKCafQlgq493tPXCZwVh2EnywYuyGZQO+qyKvg0mbGeEBpAXZmWhjoufqxW58yGE0MG17vhD4t70D0ndYhmpZFBU51wTuyyWj0A760fL7i7U4S9QegdEG28bVNSFuK69FhCiz2gvgwmLJjCKbbCA9SyYqQLTdjWpNwtr48F/PN37EIKISKWU2CPCuVk10kEDUpW7TV1eWs0KNLOZgp2B9CgMxu3zm/X6ckvso3lsfypAUSFCHu6Ddr5a3k+VDXZA4hs5u6AKbJ8boLpVwrc6TismgbkMW4+2cU2699nask110XHV20PFRR4AHUJZXF4BegQUh7ir+t7dth7sNyyP2dbDDwEqlO/qh3Ny2DGyhqNVBPJI/bDQ8uGCIzCxLsobpqP6rkv3z9aGtqig1TUQS8UkMN+BJKtmuR/ynoJW24XrTLmfvAwTQuXvOIWXe3vzn2VItjObGjOSThuONblo8r3MCrI0LD0BpvWlM+q53B7Ut+xjfz/d+5MxvFplbWL7cCaMTZVUnDF/8YIKd8LxXQkAd17eNitoBSPnIZC87RWQr8S3f06rqFWqfQ/OXAxCOTwoWi0vpq2AaKV+CzD5Od20zDvbs91MbB9O97ymZAVlWCb43IkmsEKa+WmznumAuD/YwTK70Hr2ZrwFqEdvbRmJgcxma2G8GQCVYnmsw8boOdvyGljubE8N6nIXuXcUUQ7yG1zZ/gaYWf516aYx5wJKEQljTvSzE3rYS4pMpZUVoJnyrcLTIwVNdqsEcgXn0XqijEsF5TK4XinjMaExZb8oegc8Z/ttvvi8MvSt6r4u3T/mFIHjV1qXeN4yMAOofr/DNeZMx073L9ufJI/zqUzLfLL9wHSklif+VooDVChfyFati0hTPeimrb54hraCxv1r4e0if/UmhVVYe4N63vyaEhF/g05yCESi2grkH4GZdRIex2ZAHilktT9s68ttud95mcN9xPTuG98zX7Yd7UNqswOWY0jfCV/bQf5fB5N8L45s7//JGF+QMiir5E68JraD7VdAVhAweOyXbbsBlNkjd9l2zuRzfexXQJeOP7nMqr6eMJA5TMuoEBr33RDznZncxp3sAMzy9s516f7XlOBmXPtRT8j8DnqH2wxDXKw6ewWl2Vb5Qhd6LFNA/DacIoeztdknHX+uymf7UeWt0vJin0DS0L4A6oyiuhBqVc+ZbV6T7nsIIasfAcrU1Mqc6BRv7fpRfenFo95Iue0KzGwfzoJYlV2oZwnob4D7W2k0WqVkZ8v/Iv+f1v2hlJ3qa9JNB/yP0t+4KJzt/O9A8ok6n7SnG/vpfXA+6UlPWqYHzic96UvTA+eTnvSl6YHzSU/60vTA+aQnfWl64HzSk740PXA+6Ulfmh44n/SkL00PnE960pemB84nPelL0wPnk570pemB80lP+tL0wPmkJ31peuB80pO+ND1wPulJX5oeOJ/0pC9ND5xPetKXpgfOJz3pS9MD55Oe9KXpgfNJT/rS1HT5R4Ke9KQn3ZUe5XzSk740PXA+6Ulfmh44n/SkL00PnE960pemB84nPelL0wPnk570pel/ARrqSk1gBdwTAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADp0lEQVR4nO3YMWoVYRiG0TsmCAZUxNhoJ24gRGystbKzchUuw84luAVrGxtBRMwGtLCwsBJBRQNBxw3chDsY8j/COeV8zds8/DDTPM8roOfc6AHAeuKEKHFClDghSpwQtX3S8fale//Nr9yDw8ejJyxy8ejB6AmLfL/6fPSEje3/eDp6wiLvDl9N6757OSFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6ImuZ5PvZ4NE3HH2MOVjdGT1hkb3Vn9IRFXq6ujJ6wsa3Vs9ETFrk/z9O6715OiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0RN8zwfe7y7Px1/jPm4N3rBMpd/bo2esMjum/OjJ2xs5+jX6AmLvPg0T+u+ezkhSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiNo+6fj60ZWz2vHvrn0dvWCRzw9/j56wzJOd0Qs29+Hm6AWnwssJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihKjtE6+3vp3RjH83vR+9YJnp7egFy/zZ/TJ6wuauXxi94FR4OSFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6ImuZ5Hr0BWMPLCVHihChxQpQ4IUqcECVOiPoLNE0znAiOBdAAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] From b7c067c54b1aaae53e9a5b329fc5dfde5ed55208 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 16 Dec 2020 10:59:58 -0700 Subject: [PATCH 35/76] Add ability to hide progress bar & weight vis update --- captum/optim/_core/objectives.py | 5 +- tutorials/WeightVisualization_OptimViz.ipynb | 187 ++++++++++++++++++- 2 files changed, 186 insertions(+), 6 deletions(-) diff --git a/captum/optim/_core/objectives.py b/captum/optim/_core/objectives.py index 1a59540556..8fe1b1c635 100644 --- a/captum/optim/_core/objectives.py +++ b/captum/optim/_core/objectives.py @@ -147,14 +147,15 @@ def optimize( return history -def n_steps(n: int) -> StopCriteria: +def n_steps(n: int, hidebar: bool = False) -> StopCriteria: """StopCriteria generator that uses number of steps as a stop criteria. Args: n (int): Number of steps to run optimization. + hidebar (bool): Whether or not hide progress bar. Returns: *StopCriteria* callable """ - pbar = tqdm(total=n, unit="step") + pbar = tqdm(total=n, unit="step", disable=hidebar) def continue_while(step, obj, history, optim) -> bool: if len(history) > 0: diff --git a/tutorials/WeightVisualization_OptimViz.ipynb b/tutorials/WeightVisualization_OptimViz.ipynb index 770d8981af..645b3efab1 100644 --- a/tutorials/WeightVisualization_OptimViz.ipynb +++ b/tutorials/WeightVisualization_OptimViz.ipynb @@ -869,9 +869,21 @@ " loss_fn = optimviz.loss.ChannelActivation(target, channel)\r\n", " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", " history = obj.optimize(optimviz.objectives.n_steps(128))\r\n", - " image().show()" + " image().show()\r\n", + "\r\n", + "\r\n", + "def vis_multi(model, target, channel, vec=None) -> None:\r\n", + " image = optimviz.images.NaturalImage((60,60)).to(device)\r\n", + " if vec is not None:\r\n", + " loss_fn = optimviz.loss.DirectionNeuron(target, vec, channel)\r\n", + " else:\r\n", + " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", + " transforms = torch.nn.Sequential(optimviz.transform.RandomSpatialJitter(1)) \r\n", + " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", + " history = obj.optimize(optimviz.objectives.n_steps(28, True))\r\n", + " return image()._t" ], - "execution_count": null, + "execution_count": 5, "outputs": [] }, { @@ -1090,7 +1102,7 @@ "height": 248 }, "id": "rrT2Z3HiVDPt", - "outputId": "b3799641-62de-4ac7-be9e-de5fb362edb1" + "outputId": "4e405033-a92b-43e5-b2cf-209185d3537e" }, "source": [ "reducer = optimviz.reducer.ChannelReducer(3, \"NMF\")\r\n", @@ -1107,7 +1119,7 @@ { "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADp0lEQVR4nO3YMWoVYRiG0TsmCAZUxNhoJ24gRGystbKzchUuw84luAVrGxtBRMwGtLCwsBJBRQNBxw3chDsY8j/COeV8zds8/DDTPM8roOfc6AHAeuKEKHFClDghSpwQtX3S8fale//Nr9yDw8ejJyxy8ejB6AmLfL/6fPSEje3/eDp6wiLvDl9N6757OSFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6ImuZ5PvZ4NE3HH2MOVjdGT1hkb3Vn9IRFXq6ujJ6wsa3Vs9ETFrk/z9O6715OiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0RN8zwfe7y7Px1/jPm4N3rBMpd/bo2esMjum/OjJ2xs5+jX6AmLvPg0T+u+ezkhSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiNo+6fj60ZWz2vHvrn0dvWCRzw9/j56wzJOd0Qs29+Hm6AWnwssJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihKjtE6+3vp3RjH83vR+9YJnp7egFy/zZ/TJ6wuauXxi94FR4OSFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6ImuZ5Hr0BWMPLCVHihChxQpQ4IUqcECVOiPoLNE0znAiOBdAAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADm0lEQVR4nO3YMWoUYRyH4RmNqEiqRS0tbCxEUnkEj+INPJQH8ARCCisRtAjYKhKijSIi7HiB3ZDBkO8NPE85/+bHwssHOy/LMgE9N0YPAHYTJ0SJE6LECVHihKiD844P55fX5q/cs7u3R09Y5dHvo9ETVjndHI+ecGH3v5+MnrDK5+3bedd3LydEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUfOyLHuPb+bD/ceYr9PP0RNWeT5tRk9Y5f30Y/SEC/s2bUdPWOXVssy7vns5IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBA1L8uy9/js6bz/GPPlyegF62z+jF6wzubd6AUrbEcPWOf4dJl3ffdyQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBB1cN7x44urmnEJbo8esM7Zdfptp2maXt8bveDiTh6MXnApvJwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiDo477h9fFUz/t/ND6MXrHPr0+gF6/w9/DV6wsUd3Rm94FJ4OSFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6ImpdlGb0B2MHLCVHihChxQpQ4IUqcECVOiPoH1DEyxL8sENoAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1200,6 +1212,173 @@ } } ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lyur-Elwddv6" + }, + "source": [ + "Seeing how different neurons & their weights compare to each other can also be interesting." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 479 + }, + "id": "SeM38ex_dcgv", + "outputId": "a6a269e1-2b05-4798-82ad-120bc6c03275" + }, + "source": [ + "units = list(range(320, 340))\r\n", + "\r\n", + "A = []\r\n", + "for i in range(320, 340):\r\n", + " x_out = vis_multi(model, model.mixed3b, i)\r\n", + " A.append(x_out.squeeze(0).detach())\r\n", + "\r\n", + "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", + "show(grid_img)\r\n", + "\r\n", + "A = []\r\n", + "for i in range(320, 340):\r\n", + " W_nmf = reducer.fit_transform(W_3a_3b_posneg[i, ...])\r\n", + " W_nmf = W_nmf / W_nmf.max()\r\n", + " W_nmf = W_nmf[:, 11:16, 11:16] # crop away border\r\n", + " A.append(W_nmf)\r\n", + "\r\n", + "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", + "show(grid_img)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CgumXN3krbpu" + }, + "source": [ + "NMF can also be used to describe multiple related neurons with a small number of factors. Below we demonstrate this with high-low frequency detectors. The weights have one side corrresponding to high frequency and another to low." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GQJufN1DrYYK" + }, + "source": [ + "W_p_3a = optimviz.circuits.get_expanded_weights(model, model.pool1, model.mixed3a)\r\n", + "W_p_3a = W_p_3a.permute(3, 0, 1, 2)" + ], + "execution_count": 4, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "3u0pjw04rgY6", + "outputId": "30ad9413-47b3-4176-b7be-d06bb9ce0ffe", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 509 + } + }, + "source": [ + "highlow_units = [110, 180, 153, 106, 112, 186, 132, 136, 117, 113, 108, 70, 86, 88, 160]\r\n", + "W_hl = W_p_3a[highlow_units, ...]\r\n", + "W_posneg = optimviz.reducer.posneg(W_hl, dim=0)\r\n", + "\r\n", + "reducer = optimviz.reducer.ChannelReducer(2, \"PCA\")\r\n", + "W_nmf = reducer.fit_transform(W_posneg, reshape=True)\r\n", + "W_nmf = W_nmf / W_nmf.max()\r\n", + "W_nmf = W_nmf[:len(highlow_units)] - W_nmf[len(highlow_units):]\r\n", + "\r\n", + "A = []\r\n", + "for i in highlow_units:\r\n", + " x_out = vis_multi(model, model.conv3, i)\r\n", + " A.append(x_out.squeeze(0).detach())\r\n", + "\r\n", + "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", + "show(grid_img)\r\n", + "\r\n", + "\r\n", + "A = []\r\n", + "for i in range(len(highlow_units)):\r\n", + " W_x = tensor_heatmap(0.9 * W_nmf[i, 0, ...] / W_nmf[i, 0, ...].max())\r\n", + " W_x = W_x[:, 23:30, 23:30] # crop away border\r\n", + " A.append(W_x)\r\n", + "\r\n", + "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", + "show(grid_img)" + ], + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/torch/tensor.py:775: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at /pytorch/c10/core/TensorImpl.h:848.)\n", + " return super(Tensor, self).refine_names(names)\n" + ], + "name": "stderr" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] } ] } \ No newline at end of file From 8b03cc2de91f99cbcfb9821476f2a1a7842572ac Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 16 Dec 2020 12:59:29 -0700 Subject: [PATCH 36/76] Make tqdm optional This should make it easier to run tests on CircleCI, among other things. --- captum/optim/_core/objectives.py | 24 ++++++++++++++------ tutorials/WeightVisualization_OptimViz.ipynb | 12 +++++----- 2 files changed, 23 insertions(+), 13 deletions(-) diff --git a/captum/optim/_core/objectives.py b/captum/optim/_core/objectives.py index 8fe1b1c635..e698cda843 100644 --- a/captum/optim/_core/objectives.py +++ b/captum/optim/_core/objectives.py @@ -10,7 +10,10 @@ try: from tqdm.auto import tqdm except (ImportError, AssertionError): - print("The tqdm package is required to use Captum's Optim library") + print( + "The tqdm package is required to use captum.optim's" + + " n_steps stop criteria with progress bar" + ) from captum.optim._core.output_hook import AbortForwardException, ModuleOutputsHook from captum.optim._param.image.images import InputParameterization, NaturalImage @@ -147,24 +150,31 @@ def optimize( return history -def n_steps(n: int, hidebar: bool = False) -> StopCriteria: +def n_steps(n: int, show_progress: bool = True) -> StopCriteria: """StopCriteria generator that uses number of steps as a stop criteria. Args: n (int): Number of steps to run optimization. - hidebar (bool): Whether or not hide progress bar. + show_progress (bool): Whether or not to show progress bar. Returns: *StopCriteria* callable """ - pbar = tqdm(total=n, unit="step", disable=hidebar) + + if show_progress: + pbar = tqdm(total=n, unit="step") def continue_while(step, obj, history, optim) -> bool: if len(history) > 0: - pbar.set_postfix({"Objective": f"{history[-1].mean():.1f}"}, refresh=False) + if show_progress: + pbar.set_postfix( + {"Objective": f"{history[-1].mean():.1f}"}, refresh=False + ) if step < n: - pbar.update() + if show_progress: + pbar.update() return True else: - pbar.close() + if show_progress: + pbar.close() return False return continue_while diff --git a/tutorials/WeightVisualization_OptimViz.ipynb b/tutorials/WeightVisualization_OptimViz.ipynb index 645b3efab1..270e06a17c 100644 --- a/tutorials/WeightVisualization_OptimViz.ipynb +++ b/tutorials/WeightVisualization_OptimViz.ipynb @@ -880,10 +880,10 @@ " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", " transforms = torch.nn.Sequential(optimviz.transform.RandomSpatialJitter(1)) \r\n", " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", - " history = obj.optimize(optimviz.objectives.n_steps(28, True))\r\n", + " history = obj.optimize(optimviz.objectives.n_steps(128, False))\r\n", " return image()._t" ], - "execution_count": 5, + "execution_count": null, "outputs": [] }, { @@ -1301,18 +1301,18 @@ "W_p_3a = optimviz.circuits.get_expanded_weights(model, model.pool1, model.mixed3a)\r\n", "W_p_3a = W_p_3a.permute(3, 0, 1, 2)" ], - "execution_count": 4, + "execution_count": null, "outputs": [] }, { "cell_type": "code", "metadata": { "id": "3u0pjw04rgY6", - "outputId": "30ad9413-47b3-4176-b7be-d06bb9ce0ffe", "colab": { "base_uri": "https://localhost:8080/", "height": 509 - } + }, + "outputId": "30ad9413-47b3-4176-b7be-d06bb9ce0ffe" }, "source": [ "highlow_units = [110, 180, 153, 106, 112, 186, 132, 136, 117, 113, 108, 70, 86, 88, 160]\r\n", @@ -1342,7 +1342,7 @@ "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", "show(grid_img)" ], - "execution_count": 6, + "execution_count": null, "outputs": [ { "output_type": "stream", From 6bb6aa1c86329fecb727f55f8f3bc319d0a073d2 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 17 Dec 2020 07:41:39 -0700 Subject: [PATCH 37/76] Change description based on comment --- captum/optim/_core/objectives.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/captum/optim/_core/objectives.py b/captum/optim/_core/objectives.py index e698cda843..d899256764 100644 --- a/captum/optim/_core/objectives.py +++ b/captum/optim/_core/objectives.py @@ -154,7 +154,8 @@ def n_steps(n: int, show_progress: bool = True) -> StopCriteria: """StopCriteria generator that uses number of steps as a stop criteria. Args: n (int): Number of steps to run optimization. - show_progress (bool): Whether or not to show progress bar. + show_progress (bool, optional): Whether or not to show progress bar. + Default: True Returns: *StopCriteria* callable """ From 40e26e6533a6a6f374e12f3e42e1ee7f8be9f7fc Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 17 Dec 2020 12:34:59 -0700 Subject: [PATCH 38/76] Fixes & improvements --- captum/optim/_utils/circuits.py | 11 +- captum/optim/_utils/models.py | 14 + captum/optim/_utils/reducer.py | 9 +- tests/optim/utils/test_model_utils.py | 18 + tests/optim/utils/test_reducer.py | 26 + tutorials/Miscellaneous_OptimViz.ipynb | 1589 ++++++++++++++++++++++++ 6 files changed, 1655 insertions(+), 12 deletions(-) create mode 100644 tutorials/Miscellaneous_OptimViz.ipynb diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index da0093bc8c..974d4c07e2 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -3,7 +3,7 @@ import torch import torch.nn as nn -from captum.optim._utils.models import ActivationCatcher +from captum.optim._utils.models import ActivationCatcher, collect_activations from captum.optim._utils.typing import ModuleOutputMapping @@ -22,14 +22,7 @@ def get_expanded_weights( See: https://distill.pub/2020/circuits/visualizing-weights/ """ - def get_activations( - model, targets: Union[nn.Module, List[nn.Module]] - ) -> ModuleOutputMapping: - catch_activ = ActivationCatcher(targets) - activ_out = catch_activ(model, model_input) - return activ_out - - activations = get_activations(model, [target1, target2]) + activations = collect_activations(model, [target1, target2], model_input) activ1 = activations[target1] activ2 = activations[target2] diff --git a/captum/optim/_utils/models.py b/captum/optim/_utils/models.py index cb0b3856a1..1eee8a24c6 100644 --- a/captum/optim/_utils/models.py +++ b/captum/optim/_utils/models.py @@ -157,6 +157,20 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: ) +def collect_activations( + model, + targets: Union[nn.Module, List[nn.Module]], + model_input: torch.Tensor = torch.zeros(1, 3, 224, 224), +) -> ModuleOutputMapping: + """ + Collect target activations for a model. + """ + + catch_activ = ActivationCatcher(targets) + activ_out = catch_activ(model, model_input) + return activ_out + + class ActivationCatcher(object): """ Simple module for collecting activations from model targets. diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index c76a930f69..9ef4796f56 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -72,7 +72,7 @@ def fit_transform( x_out = ChannelReducer._apply_flat(self._reducer.fit_transform, x) if is_tensor: - x_out = torch.as_tensor(x_out) + x_out = torch.as_tensor(x_out, device=x.device) if x.dim() == 3 and reshape: x_out = x_out.permute(2, 1, 0) elif x.dim() > 3 and reshape: @@ -97,9 +97,12 @@ def fit_transform( def __getattr__(self, name: str) -> Any: if name in self.__dict__: - return self.__dict__[name] + out = self.__dict__[name] elif name + "_" in self._reducer.__dict__: - return self._reducer.__dict__[name + "_"] + out = self._reducer.__dict__[name + "_"] + if type(out) == np.ndarray: + out = torch.as_tensor(out) + return out def __dir__(self) -> List: dynamic_attrs = [ diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index b353c71c07..86e1bed3bc 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -316,5 +316,23 @@ def test_activation_catcher(self) -> None: self.assertTrue(test) +class TestCollectActivations(BaseTest): + def test_collect_activations(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping collect_activations test due to insufficient Torch version." + ) + model = googlenet(pretrained=True) + try: + activations = model_utils.collect_activations( + model, [model.mixed4d], torch.zeros(1, 3, 224, 224) + ) + self.assertIsInstance(activ_out, dict) + test = True + except Exception: + test = False + self.assertTrue(test) + + if __name__ == "__main__": unittest.main() diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py index d8ab5a28ec..90d9a49d8c 100644 --- a/tests/optim/utils/test_reducer.py +++ b/tests/optim/utils/test_reducer.py @@ -16,6 +16,7 @@ class TestReductionAlgorithm(object): def __init__(self, n_components=3, **kwargs) -> None: self.n_components = n_components + self.components_ = np.ones(2, 64) def fit_transform(self, x: Union[torch.Tensor, np.ndarray]) -> np.ndarray: x = x.numpy() if torch.is_tensor(x) else x @@ -64,6 +65,31 @@ def test_channelreducer_pytorch_custom_alg(self) -> None: test_output = c_reducer.fit_transform(test_input, reshape=True) self.assertEquals(test_output.size(1), 3) + def test_channelreducer_pytorch_custom_alg_components(self) -> None: + test_input = torch.randn(1, 32, 224, 224).abs() + reduction_alg = TestReductionAlgorithm + c_reducer = reducer.ChannelReducer( + n_components=3, reduction_alg=reduction_alg, max_iter=100 + ) + components = c_reducer.components + self.assertTrue(torch.is_tensor(components)) + + def test_channelreducer_pytorch_components(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer" + + " PyTorch reshape test" + ) + + test_input = torch.randn(1, 32, 224, 224).abs() + c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) + test_output = c_reducer.fit_transform(test_input, reshape=True) + components = c_reducer.components + self.assertTrue(torch.is_tensor(components)) + def test_channelreducer_numpy(self) -> None: try: import sklearn # noqa: F401 diff --git a/tutorials/Miscellaneous_OptimViz.ipynb b/tutorials/Miscellaneous_OptimViz.ipynb new file mode 100644 index 0000000000..23fedec5ce --- /dev/null +++ b/tutorials/Miscellaneous_OptimViz.ipynb @@ -0,0 +1,1589 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "Miscellaneous_OptimViz.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "8ac1934dd2a74116aa92e7e0f89b6866": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_1619e2ecc1194ceaa27b03204ce9e119", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_1b27274c717e44bbb3465f8b180fafbe", + "IPY_MODEL_c7490e5b0751438dac835b01cbe2f52a" + ] + } + }, + "1619e2ecc1194ceaa27b03204ce9e119": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "1b27274c717e44bbb3465f8b180fafbe": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_d52357a2a3314020849b5953253a4a43", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_23423a617f8c4149a1bfe232b040b817" + } + }, + "c7490e5b0751438dac835b01cbe2f52a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_60983f5ed4a4424cade5cc9fa54a1b70", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [00:16<00:00, 7.56step/s, Objective=87159356784640.0]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_7907b72c9b614515be23215053bf61dc" + } + }, + "d52357a2a3314020849b5953253a4a43": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "23423a617f8c4149a1bfe232b040b817": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "60983f5ed4a4424cade5cc9fa54a1b70": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "7907b72c9b614515be23215053bf61dc": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "32d789dbfb4f4a3baeabf116bc91f7a0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_ffe6e767db9f4d38b59e1c5a9d5c10ed", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_a9060e1913584e719d325695658615de", + "IPY_MODEL_9052569286ff4650b8ad9ba61a3aa15f" + ] + } + }, + "ffe6e767db9f4d38b59e1c5a9d5c10ed": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "a9060e1913584e719d325695658615de": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_68d5449317e041e98e33616550667e24", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_cfd379157c144f2882d2e1b429f6b325" + } + }, + "9052569286ff4650b8ad9ba61a3aa15f": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_bb093177f1cc46f0816172ba5967b424", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [00:32<00:00, 3.98step/s, Objective=4033437184.0]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_3ce2f130d504444e9d8331afd7fb41f1" + } + }, + "68d5449317e041e98e33616550667e24": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "cfd379157c144f2882d2e1b429f6b325": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "bb093177f1cc46f0816172ba5967b424": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "3ce2f130d504444e9d8331afd7fb41f1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "d2d81bfb52f04ce79e3c440d338a5c29": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_b8326c412b084ec697df5b0ca05e9ccf", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_48d1fbc1a02c45bcb7fb1ebd2cd34dfb", + "IPY_MODEL_6efbfd4891f746cca643654566ee743c" + ] + } + }, + "b8326c412b084ec697df5b0ca05e9ccf": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "48d1fbc1a02c45bcb7fb1ebd2cd34dfb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_2403e147ece043a699622b9372012670", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_160db01ce9354f5fa04cd11f81df9743" + } + }, + "6efbfd4891f746cca643654566ee743c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_395e68770d8c47b697a517e861cb935a", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [00:44<00:00, 2.87step/s, Objective=24491804672.0]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_52c7abe1e9af4a628823d675eac7323e" + } + }, + "2403e147ece043a699622b9372012670": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "160db01ce9354f5fa04cd11f81df9743": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "395e68770d8c47b697a517e861cb935a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "52c7abe1e9af4a628823d675eac7323e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "b2d90f4e80f24206bd89ea9681d7b775": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_62db6cd41ac24cd5b89a60f7d836193e", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_6dff3e1dd3964cfb908f2ce4fd71f78c", + "IPY_MODEL_521accba1df54a95aaa787780c5b7162" + ] + } + }, + "62db6cd41ac24cd5b89a60f7d836193e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "6dff3e1dd3964cfb908f2ce4fd71f78c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_8eabb94361ab455f96c13a6784f36289", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_3b2af960bf19426586add01e1e4299b1" + } + }, + "521accba1df54a95aaa787780c5b7162": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_3484758cbb5e48efb4c29b4cb2276528", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [01:15<00:00, 1.70step/s, Objective=10076947456.0]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_3c0c231696a84b2d9a2b84bc1ff1089d" + } + }, + "8eabb94361ab455f96c13a6784f36289": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "3b2af960bf19426586add01e1e4299b1": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "3484758cbb5e48efb4c29b4cb2276528": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "3c0c231696a84b2d9a2b84bc1ff1089d": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "VWy2Woand8P0" + }, + "source": [ + "# Miscellaneous visualizations with captum.optim\r\n", + "\r\n", + "This notebook demonstrates the use of the captum.optim submodule for visualization tasks such as neuron groups and caricatures." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GWrStkUVEbOC" + }, + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "import torch\n", + "import torchvision\n", + "from captum.optim._models.inception_v1 import googlenet\n", + "\n", + "import captum.optim as optimviz\n", + "\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "model = googlenet(pretrained=True).to(device).eval()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rzb9RtdUfE_H" + }, + "source": [ + "We'll load some images for testing, and setup some helper functions." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "1Fj187brzzkT" + }, + "source": [ + "import numpy as np\r\n", + "from PIL import Image\r\n", + "\r\n", + "!wget https://storage.googleapis.com/lucid-static/building-blocks/examples/dog_cat.png\r\n", + "image = Image.open(\"dog_cat.png\").convert('RGB')\r\n", + "catdog_image = torch.as_tensor(np.array(image)).permute(2, 0, 1).unsqueeze(0) / 255\r\n", + "\r\n", + "!wget https://storage.googleapis.com/lucid-static/building-blocks/examples/flowers.png\r\n", + "image = Image.open(\"flowers.png\").convert('RGB')\r\n", + "flower_image = torch.as_tensor(np.array(image)).permute(2, 0, 1).unsqueeze(0) / 255" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "D46o5t8a4iVk" + }, + "source": [ + "import numpy as np\r\n", + "import matplotlib.pyplot as plt\r\n", + "\r\n", + "\r\n", + "def show(x: np.ndarray, scale: float = 255.0) -> None:\r\n", + " assert len(x.shape) == 3\r\n", + " x = x.permute(1,2,0).numpy() if torch.is_tensor(x) else x\r\n", + " if x.shape[2] == 1:\r\n", + " x = np.concatenate([x, x, x], 2)\r\n", + " x = x * scale\r\n", + " plt.imshow(x.astype(np.uint8))\r\n", + " plt.axis(\"off\")\r\n", + " plt.show()" + ], + "execution_count": 5, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rwNBGUFJ0Z_P" + }, + "source": [ + "## Neuron Groups\r\n", + "\r\n", + "The code below let's us visualize Neuron Groups, so that we can see how detectors view different spatial regions of an input." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Sc7gVr-QUQIE" + }, + "source": [ + "# Helper functions\r\n", + "\r\n", + "from captum.optim._utils.models import ActivationCatcher\r\n", + "\r\n", + "\r\n", + "def vis_direction(model, target, vec=None) -> None:\r\n", + " image = optimviz.images.NaturalImage((80,80)).to(device)\r\n", + " loss_fn = optimviz.loss.Direction(target, vec)\r\n", + " transforms = torch.nn.Sequential(\r\n", + " torch.nn.ReflectionPad2d(16),\r\n", + " optimviz.transform.RandomSpatialJitter(16),\r\n", + " optimviz.transform.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\r\n", + " torchvision.transforms.RandomRotation(degrees=(-5,5)),\r\n", + " optimviz.transform.RandomSpatialJitter(8),\r\n", + " optimviz.transform.CenterCrop(16),\r\n", + " ) \r\n", + " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", + " history = obj.optimize(optimviz.objectives.n_steps(128, False))\r\n", + " return image()._t\r\n", + "\r\n", + "\r\n", + "def neuron_groups(model_input, model, target, n_groups=6):\r\n", + " activations = optimviz.models.collect_activations(model, [target], model_input)[target].detach()\r\n", + " \r\n", + " reducer = optimviz.reducer.ChannelReducer(n_groups, \"NMF\")\r\n", + " spatial_factors = reducer.fit_transform(activations)[0]\r\n", + " channel_factors = reducer.components\r\n", + "\r\n", + " s_max, _ = spatial_factors.max(1)\r\n", + " x_peak = torch.argmax(s_max, 1)\r\n", + " ns_sorted = torch.argsort(x_peak)\r\n", + "\r\n", + " spatial_factors = spatial_factors[ns_sorted]\r\n", + " channel_factors = channel_factors[ns_sorted]\r\n", + "\r\n", + " group_vecs = [spatial_factors[i, ..., None]*channel_factors[i] for i in range(n_groups)]\r\n", + " \r\n", + " x_tensors = [factor.unsqueeze(0) / torch.quantile(spatial_factors,99/100) for factor in spatial_factors]\r\n", + "\r\n", + " show(model_input[0])\r\n", + " show(torch.cat(x_tensors[:3], 0))\r\n", + " show(torch.cat(x_tensors[3:], 0))\r\n", + "\r\n", + " A = []\r\n", + " for i in range(n_groups):\r\n", + " x_out = vis_direction(model, target, channel_factors[i])\r\n", + " A.append(x_out.detach().squeeze(0))\r\n", + "\r\n", + " grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=n_groups)\r\n", + " show(grid_img)" + ], + "execution_count": 10, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "4ZTCiTE60Lvn", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "outputId": "f87d542f-b0b0-42c9-a31c-37a753b3b8a9" + }, + "source": [ + "neuron_groups(catdog_image, model, model.mixed4d, 6)\r\n", + "neuron_groups(flower_image, model, model.mixed4d, 6)" + ], + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAGWUlEQVR4nO3dT2ulZxnH8euc5Ewyk046TEWKLtwUiiiCbl11Uxe+CH1v7nXjRuhGcFcQClXrHwSRoqWtM9NOk0lOkuNamByG52fob/H5bIfruTMn+eaBGS7u1W63G6DP+uv+AoCXEyeUEieUEieUEieUOtz3h2/9dBX9U+5bz/c+fq/t9io5ev72YPnsZyfR0XN2mgxnZ8/TcP6rYPYiPDv5lqf/6bAKZrMf1dn9affS0705oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4odTehcuff/QwevhPtteLZz+9zpbkfnOzfPZ34W7gh4+Wz15+Izs7/nWbfOzBZz4z2U7m17nPeUe8OaGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKHU3pWxn/3rKHr4u+fL76P7VXTyzPvB7O834f7Qs2B/Kb0C8M1wfhPMpmtbiXTla/ltlTMH4dm38OaEUuKEUuKEUuKEUuKEUuKEUuKEUuKEUuKEUuKEUuKEUuKEUuKEUuKEUuKEUnu32I7OP48e/iJY8PswOnnmg2R4G/7OCq4+nE+zo+N9ztNg9ovs6GQlc5fuVJ4Es8ku6B7enFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBq77LLb+dR9PBfBrO/CO9VO5ubYPp5dPZMsDKWrj4lV/jNzPqfy2cff5KdfXK8fPbf4drWxdvBcJbJrbw5oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4oZQ4odTeLbhfzw+ih5/OdxbP/iH+vfH+8tHNn7Ojj4LZ9Aq/e9n4ycfLZ6/DKwC3wS7rUbK+OzMXbwTDj7Ozb+PNCaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaX2roy9N9+LHr6aHy6e/c/sorPnILjG7zDcfXo92Lt6M9x9Cn/dfrleBdPZ9+xJcHNi7DKYPfu/fRX/w5sTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSokTSu3d5/zk6GH08OuL5D66TXT27L4fDAd30c3M/flg8ez55d+js+e1cCnywfJrG+fpd7Oz58tg9ml29OVfl8++OM/OvoU3J5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5Tau8+5ug535Ca4p3KSeyJnDtcXi2ePVt+Mzr539vbi2fOvws/8/rNs/upHwfCPs7NnG8wmP2szq7MXi2d3279EZ9/GmxNKiRNKiRNKiRNKiRNKiRNKiRNKiRNKiRNKiRNKiRNKiRNKiRNKiRNK7V0Zu7d6Ej38en28eHa3zq5VW62eL5+9zq4f3Ny8tnz4Krt2cQ6StauZ2QVf+7yRnR1cvXgwu+jk0+ffXjz75Gm2rnYbb04oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4otX+f89Efo4fvNv9YPHtxcBadfXWxfB90vT2Nzn5xfLR4drNZfnXhzMx2exXNz8lHy2fPsj3YuVz+uV9vPo+OPjgOrk68upt3nDcnlBInlBInlBInlBInlBInlBInlBInlBInlBInlBInlBInlBInlBInlFrtdrdfnbZ65150r9rqImj/MLvS7eBm+fzN1So6e3WzfGVsfT+7wm97fBPNz7Pl1zbOZ/ezs4MrI2eX/b1XD79YfvTj5bMzM7v3bl76A+fNCaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaX2XgE438p2C+fiYPnsebbPeTXB/CY7e1aXi0ev19ku6ezZz30lh8H3/FG215h8yyb4UZuZ2S1fwc2+7j28OaGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKHU/pWxl99M9sp2rwfXsmW3D84s39qaCbe2JrmNbn1H+0ev6kFw/nV4dvK5hTcfRs7v5rHenFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBKnFBqtUuvjAPuhDcnlBInlBInlBInlBInlBInlPovJJfYCNTtHqIAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" + ], + "name": "stderr" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" + ], + "name": "stderr" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m-rMQZVnzKei" + }, + "source": [ + "## Feature Inversion Caricatures\r\n", + "\r\n", + "\r\n", + "This an image visualization technique based on research by [Mahendran and Vedaldi](https://arxiv.org/pdf/1412.0035.pdf). \r\n", + "\r\n", + "Compared to their work, we use a dot product object and transform robustness." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "-gi3O0ZhpzOa" + }, + "source": [ + "# Helper classes & functions\r\n", + "\r\n", + "class StackImage(optimviz.images.ImageParameterization):\r\n", + " def __init__(\r\n", + " self,\r\n", + " init: torch.Tensor,\r\n", + " parameterization=None,\r\n", + " ) -> None:\r\n", + " super().__init__()\r\n", + " assert init.dim() == 4\r\n", + " self.image = torch.nn.Parameter(init)\r\n", + " self.parameterization = parameterization\r\n", + "\r\n", + " def forward(self) -> torch.Tensor:\r\n", + " image = self.parameterization()\r\n", + " return torch.cat([image, self.image], 0).refine_names(\"B\", \"C\", \"H\", \"W\")\r\n", + "\r\n", + "\r\n", + "class DotCompare(optimviz.loss.Loss):\r\n", + " def __init__(\r\n", + " self,\r\n", + " target: torch.nn.Module = None,\r\n", + " cossim_pow: float = 0\r\n", + " ) -> None:\r\n", + " super(optimviz.loss.Loss, self).__init__()\r\n", + " self.target = target\r\n", + " self.cossim_pow = cossim_pow\r\n", + "\r\n", + " def __call__(self, targets_to_values) -> torch.Tensor:\r\n", + " activations = targets_to_values[self.target]\r\n", + " assert activations.size(0) == 2\r\n", + " dot = torch.sum(activations[0] * activations[1])\r\n", + " mag = torch.sqrt(torch.sum(activations[0]**2))\r\n", + " cossim = dot / (1e-6 + mag)\r\n", + " return dot * cossim ** self.cossim_pow\r\n", + "\r\n", + "\r\n", + "def vis_feature_inversion(model, target, init, init2, cossim_pow=0) -> None:\r\n", + " image = optimviz.images.NaturalImage((224,224), batch=2, init=init).to(device)\r\n", + " init2 = image.decorrelate(init2.refine_names(\"B\", \"C\", \"H\", \"W\"), inverse=True)\r\n", + " image.parameterization = StackImage(init2, parameterization=image.parameterization)\r\n", + " loss_fn = DotCompare(target, cossim_pow=cossim_pow)\r\n", + " transforms = torch.nn.Sequential(\r\n", + " torch.nn.ReflectionPad2d(16),\r\n", + " optimviz.transform.RandomSpatialJitter(16),\r\n", + " optimviz.transform.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\r\n", + " torchvision.transforms.RandomRotation(degrees=(-5,5)),\r\n", + " optimviz.transform.RandomSpatialJitter(8),\r\n", + " optimviz.transform.CenterCrop(16),\r\n", + " ) \r\n", + " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", + " history = obj.optimize(optimviz.objectives.n_steps(128))\r\n", + " show(image()._t[0].detach())" + ], + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "es6vyxRQrOXU", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000, + "referenced_widgets": [ + "8ac1934dd2a74116aa92e7e0f89b6866", + "1619e2ecc1194ceaa27b03204ce9e119", + "1b27274c717e44bbb3465f8b180fafbe", + "c7490e5b0751438dac835b01cbe2f52a", + "d52357a2a3314020849b5953253a4a43", + "23423a617f8c4149a1bfe232b040b817", + "60983f5ed4a4424cade5cc9fa54a1b70", + "7907b72c9b614515be23215053bf61dc", + "32d789dbfb4f4a3baeabf116bc91f7a0", + "ffe6e767db9f4d38b59e1c5a9d5c10ed", + "a9060e1913584e719d325695658615de", + "9052569286ff4650b8ad9ba61a3aa15f", + "68d5449317e041e98e33616550667e24", + "cfd379157c144f2882d2e1b429f6b325", + "bb093177f1cc46f0816172ba5967b424", + "3ce2f130d504444e9d8331afd7fb41f1", + "d2d81bfb52f04ce79e3c440d338a5c29", + "b8326c412b084ec697df5b0ca05e9ccf", + "48d1fbc1a02c45bcb7fb1ebd2cd34dfb", + "6efbfd4891f746cca643654566ee743c", + "2403e147ece043a699622b9372012670", + "160db01ce9354f5fa04cd11f81df9743", + "395e68770d8c47b697a517e861cb935a", + "52c7abe1e9af4a628823d675eac7323e", + "b2d90f4e80f24206bd89ea9681d7b775", + "62db6cd41ac24cd5b89a60f7d836193e", + "6dff3e1dd3964cfb908f2ce4fd71f78c", + "521accba1df54a95aaa787780c5b7162", + "8eabb94361ab455f96c13a6784f36289", + "3b2af960bf19426586add01e1e4299b1", + "3484758cbb5e48efb4c29b4cb2276528", + "3c0c231696a84b2d9a2b84bc1ff1089d" + ] + }, + "outputId": "03ed0d6c-37b9-4159-8161-fa35c9d4af47" + }, + "source": [ + "size = (224,224)\r\n", + "init2 = torch.nn.functional.interpolate(catdog_image, size=size)\r\n", + "init = torch.zeros(1, 3, size[0], size[1])\r\n", + "\r\n", + "vis_feature_inversion(model, model.conv1, init=init, init2=init2, cossim_pow=0.5)\r\n", + "vis_feature_inversion(model, model.conv2, init=init, init2=init2)\r\n", + "vis_feature_inversion(model, model.conv3, init=init, init2=init2)\r\n", + "vis_feature_inversion(model, model.mixed3a, init=init, init2=init2)" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8ac1934dd2a74116aa92e7e0f89b6866", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", + "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", + " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "32d789dbfb4f4a3baeabf116bc91f7a0", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d2d81bfb52f04ce79e3c440d338a5c29", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + }, + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b2d90f4e80f24206bd89ea9681d7b775", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3gV1dbGf3NKek8IkFBDC70K0pSqgiiKFFEEC0VQEctVwAIqqOjF3q6Aih1EEQHpSO+9d0iBFBJIL6fM+/0xEfEKgoCi9+N9nvWcc+bM7P7O2nvtmbUMSVzBFVzB3w+2y12AK7iCKzgzrpDzCq7gb4or5LyCK/ib4go5r+AK/qa4Qs4ruIK/KySdVQBdnNQRNBFUEFwr6C+ofUFpGSWf9WyGXK5lF1mu/5Ibh2j4zkQNkrRb0qvapinK1zWaqv56WneZE+TMaKn47OFqv6+1DPtZymj8Ir+XXw3Q1LZBypsUqS3vob1bmsrrHSnPyvvkfbu8tLuBpG6SOkr6RtJ4zRxZSiPboCkvoaK8qyWzu6TnJN0or3ewXn3CuLRt8l9SelSY/K/y+VPz+CvF4XCoONelu3ldYWFhSklJ+dPzNEAYhgzj1311Vv6dk5wtL7QwJQUwbMJoJYxGvxw7h9jtdmHYZLPbZS+RRb1Kvjsccrl2yrBdwsHYtYnu3bVOnSRtljRe0jil6F659alMheQPEuZQkfyueGSIsP82b19fZJo+8pooNe338+sehrw3I83qIB2+Xc/djcra0YSGqHBRNUn1JVWUtFhSF0mbtfP52prSHuUMQ95/IzM/VqangtzuinI4Lv0gGvNCKz08rLEMG6o10aahsw1VmxUi6jllu5Rtf5nFDmoPsv0Fec354HF9tHSp8t3pcjgcp45fODn/iJy6IzQSth7C2Vl0Wy9eLxI3fiBixwqfVr+fhs2hjIwMRXafoA+K3PLIgkuSaZoaNGGTPF6Pnvr2hUvXcHf11NUH9qqTpBsl9Zc0WFI35auCFqi25upavaF2ekrG9u/F47bfpOHrgwpOogl5aEkJOQ2n84z5RYFeuhXpB6RnHNKcYMnlJ3mrSmYFSRGS7pNUU9IiSe9qyn2l9EA39PD16NvBqOhhVHQj8j+LFv+lT/54ezzZ2pIhr/fRfZM6aubyz9T9tltOzQhWvPe06lSOvezEuhjxKalLACgF9N5flG9GRob2Tn9bDvsvY+jPJafdIaKiRPNWwu4n/APE/Q+KNS7RebTOrDF9BLZf/Tb8/OXfe50yc3+mpOSRZEq6S5Jb0kFJkqmCguxL12g3+ururTPU2+vVwzI1WKZekNRQ0iOShpnFCjN76xE9Lsf8p0VV4zeD3uZEvRfYNWU1SkvzkV+V8mp34MBZ87ynJTI/RfoR6RBSUbi0LFjaY0jqJamupDmSrpG0TtkP19ZjFVAZG+pVHX3bDzXyQW0q/zLl/80A9EP2LiggAPkHIF+/89cQTgONf3Wc8vLy5H6lpxZ/10h1W0dddlJdCgkMCJCrtf9fnq+Pr58CAgLUv3rZX/XDn0fOyGhx270ygiNEYBfZuu+UcbBIPJUlePEc19tl+AbJJzhEgSHTdVVCkTL0ayyS5C0h6CJJy0soW1Dw67SdF9Nw7a9X7EO3q/q+raott56VqZaSnpL0hqSy2cOVbRaoh3Yq3u0R4/1FPL8iqGFD7W9HvYf662D+Wyq3s5e2bNlyxvwMUN9eKH8Hcu9G+gjpLqTljpIpbQVJD0saIelJSTOlUXH6IQbdEIT8DKu+Q6sj+1k0Y6A/+nIMGvCQ1Z0uObQ4MVjXlLPJeS5tC3qmHhpcA/mCPp7goy5d7JedVKeLP8hxgddmZWUpIyPjLy/zB98uVkZmlvJzs/+Caa2Pv4wqUQoee73K7vcqYF6+qi09qrI3vHLOgtqcgQqJ6KSGLx7QsyekTT9PXfVb5P/quCkpWwUFCxRkoMhIFOVE/QNQVCCKCkaRvjaF+f2BzguNEQ0bqMuyn1Tb49ZwSc9KeqKEJunK13GZaqetilmfJcf4vtZ10aelYUe2x1Gb+1DVMefOs1pDNPwltOIN5FmNpFDlF96kXFdtuTVQ0uOSPpDUU9bas6Pm1nLqiXqopQO1wVovnSntEAM9ci/qH40KXcgjpywD0zEdS2yoW5qf/4D6F6jDXzyIz0cmgjpexvxtnH3G8vvSSHc1Lq+A026ql5achk1GqSoK6jdKoSc8ajc3U8RvEdc8dV4FDAgJV51eE7XgQK6KTyOheRZy/hpeyXxcxZkJGlQlTBn7DL3dHmWOQKnPI9cHTuXfUVa7nw3TjWXLKio8XD7n02h9BokH7lODrRvUr8ijcqaltw5IStHrqqYiPSRpjPqo7ok7ROkA0fnCOze0OmrzMHrzY3TgAEo7HqNnJ5TSwysCtU/PS2ohaVrJLeIZSUnSM3GaVgpdAxrI2WcLb4HsDvTGp+jdxWivO0bSt/KaR7Vp67OXnVj/dHFiWdzrYK1Z/9i1SxTH0+rPn7HmNGwirqmiJrn04PpD4qZ1gt7nVbDgsDBFV6igpybM0dh90sGC36dhUQlZC0s+80xTLk++PF6Xcj6pp8N73tRIHzS8LVpxDarkg3bVQ2v6lVFGwnh5s5K1a94M3VWpkiqVjlSE8xxlfKy/eOJhhXy/Rw/muXWXTFWXtFrSYUlTlKlYLVHE4/eKVT2F/4V3cPky6Kre6JHv0Cc/omtuNlTz5dL6/mRpSW0lVZd0laSuJVr0HWlZXWmIXQNDUG+Q3+/lYaBKN6Nut/nqk6UjdOhQX23f1UOPvHj5B/c/XRqBvgQdBt11jnNDQBWiULQNxYahhs40GYwRBJ0659KQ02aTs8HVsr/hVkzfhb9bqNDQUNWoUUOVK1ZSUGCQwK7Hx72sBfm5Sj2ndrSwxdKTWldCzjmmqaT0RTrh9erbFV+r/TXVFRQafSrPMgHo8zZobHUfPVIhWqlPVVfqwS+l7DRp2VRN7lRR1auEKiLU8Ttlryc6D1e55evUKr1Y33tN9ZDURNIQc5y+N92arIEyrosTXSIuuINtDnRdV9TzOXTTKLRmW4Ayc25XXs5QeV3tZU1D7y0h5gpZa9DZUueK2n416mBHcVzo1OqKXIz4gV6OjNS/Is7d//eATkwtp2nhNs17EPk51wpeFnQ8dc7Fk9OIl1HzasUs3SzKzj97gRw+iihbXi+88IIk6eDOA+o/eJiq1W+nadPmnSctzw2vV1q7z61HR32lenXqqJJvyKkylA2qrFcbP6tPI2P1bHwFHR53l3ITEyXtkjv9eb056nrVr19f9etEqn4cql8K1Y9CEc7TB/u1YsA8tV61SSuOFsrjNVU2X3oqI08b9z4qo30f0e2+i+rkCo1Q4yHo0U/RlBXo7R/R6gUo/2iopEqyNGhHWTbjZyTdJX19swra+2hYKAr/GwzU/49SB/TBoEHq16/fOc8tDUre9b6+qhCqsFPHr9PpOxgXQc5mAodwThEjF5yzMH6lYjToxTeVdxqRNkjacclo+Vu4snK1uPcTql+/vgBFgq4jVk1DH9OkGoN0h72qPrn5Zh1etUXm1u1S8lapIFPKHietvlp6o4L0ulMv3hKv1pWD1Kwc8j99Y//Or7Vg6Sr57feo90cr1blFd5V5rvvFd3QoatQNjXkPPfIFmrUDFWSivMK28micrAcQvpc1d3hE1ir4IaV39VdmS3St7Yrm/LvLfaC1b6MPm6BKZ+mvs/HPKCHhGWEYNsECoMNZz/lvlAmEvoP60H/8Z1Q776suDZKSkujerRvbN2ygsORYZWdL2vp0ISl/PDUIoluVmlRuX4SnVTu8NVtRsWo8fmFL2b79GcqVG4D/is/xOVHEvdPFkSxfVu/bgyvVYzXjtDlQIOr+GEu1auP47oUvL77QwVD5DmhSM4oeVT3UiczCp0IUZWPC8WMYu5OW46OZVCxbDh9nDSAIFn3H+keKeDoHFiaCefYuvIK/AWoB+wDPWf6XZJzp+DnIaVxQt/fp04fPPvvsQi4tQSJQjj/yXL7b4yY5NQUft5dH+vZj9pZt+BRkE2hCPJWpShVgPTu4jnY48AZsxqiUT8u+PXDUbc/0WbMYODCBBg0ceI7XwR6YjeEfSZ+3t3BioQs8C5k/34O3z0jQAvjRDcYWOH4R1fwZ5WDwyBY0qRJMXIXjNCsXy0lXRXbuzuLtVXNoFJvLQw0eJLLaKnCWhkPrGTy4kE6RJ+kxBVzmJSjD/zMYhsENN9yAx+NhwYIFl7UsZyOn468uyNmRDDkeCPIF2244eBgqtwLbAaA6cMbyn4LL7WbT5g3EukTT23qwNiGFcq5s9rpgEYdZSREtieZWvmEJ0CS0L2Gpqfww7jWSPK8xfOIInCfak5uZzpLJYykqc5ROt1bg86HPwtAwIJQ77nCTlvs+i6efhLrDwHmJyJkMU75eRdigTpw0u5Cf9B3r9s9k5zrICIRqrUPx2/EmlPOCswYrUksR5nDTfWoW7v9xtVmlShX8/f3ZsWPHJU3XMAzuu+8+ioqKLjs5z4ZLRs7SpUvTsWNHEhMTOXz4MGvWrOHqq68+94XudHCEg3EUcosh5xCUbQWHvoP8fKjjhYx9UKoJGGX4NUlN4AQQRaB/AM1q1OHeZs3wa9kcZRwg0wWZJWcWkcIiYFHJ7/yUTzkJNI2DxoVw8seX+GA5PNEfnp0A5a+7iWs738jcOY8TVDGLijEf8vnntUm01WbU3UeYn/4GqXMuVevBiWWQXHEze/wOsrq0jc2zgul+XS7bt4JtTTaFVeBQNuycV40f5i+g3IZi8F66/P9M3HnnnXzxxRcXdG2VKlUICwu7YHLefvvtTJ06FdP89fTCNE26d+9+QWn+Vbhk73PGx8fz2WefMXToUNLT01m3diVHkw+d5eyTQDE6cRQVH4ftP8Dm/VAqEJbOg32LoH0PSN0NVIKcLcBMYBuwFmsBmFCSVh7gBnbjDA2mVr9badSwMaZPCHuBYCD2DCX4CdgCfHgInk+B5yfD3EPw+ctQpkwZXryjGQtmwtIZ4vnXICF9LXuPPU+pXWX45ONPeOK9QdQfeP2laj4APvsslc0HTPZtLIuzchTvfOZg30lYfwhmZcKi9bBkySwKi4p5I8uq9T8BLVu2vOBr58+fz9SpUy/4+ubNm2Oz/TNfW75ka84qVarw1KMPEqAC3KEVaNumBQUFuUSVs8xC4d5ccPiCfxgU7eLwT2swj6dwIsePWoULKXJsYm/b7jQ5FgEny+CsnonKt2P1oTm0aN4Dw9iEpejDAV8gBvDBmvK6gE1AE44d28Fzw19iw4+L2ZSbQYQLorAW5OeLlp3jGBCRzJPfuxjcD3zLDSS8Tg2WrXmRZqWqElSqJ/f0bs1M9vPswHfx2baN9evy/kAO50bV3mGkry0g55ALgBr3QsNsqFsPXnoV8i5tdldwGfGXGIQifOGBu7rx/IRvObhpE7mZmdhDrCTqxlcDRwAcW83uOT+Rk+8ktLqHtP1+pG1bxbqCdfhXqsgTQx7FZ8VSMorCKfQTh2Lr0rFmIkb5Vgg/lu0yubb2CuAGwB+LqJWxJgEJQHny0taxfMq3fLt/DytnJZBzZC/H/khFgCbADqAIGDlyJPuOj2fGkmKGPnM34U9NhkEdoYwv9Xo8hnPNajpdP+IP5vD3RYsWLQBYtWrVb/7r06cPixYtIiUl5a8u1v8szkbOS6bvywXBgPbVcZSvzzfffMOR9evZPns2kYGBRAYGwrEtpH70GumvPY0nZRPVK3qJb1OFa4c/SnDbuwhOCiZ1+j68hT+yZfd6ZmVVZPOK/XRoXw7DKIuOzGTNfjdwCLgF2ArmXkhYAKQCSaeqFFS6Gp2GjmLss48xbOid1I3/4/XZg6WPnwyBN156kcyNxVTNhIx5izmRLJ5+ej7QjMbZ81n6U/YlacMr+PujGZZa+CtwyTRn6QB44q5O3PTYmxw8eJA6MTEUnDxJ9aou2LUQ1i3h0Kp1zNsHNXu2oGmzegQcSYfuL0JMDQrn9+e7J7+g4pA4xr6ew7VNy3DjzZHUaV8dI90XuUvxbmIcD1b/CirfB0W7wVkD1i2DFh2AfVAUCwfWQ51rgbZAISczD7NwxVd8+FUCi6dMASwz0rkQABQC9wXCgQJwCA4Ch0v+f+2110hISOB46pt8OeV8W+kK/ul4IK4VrQLCGb5j5imrx8Xikm+lREZG8uJzj5K0aTxfrAxl+KPDKV++PNWqhVGtWiXYkg6pP5K5fhvsX8judNh4AELrV6FUnYbYm90DgUdg1QfQ8TH8r3uEW3dtYvR7W3GHmXQJS6ZWg2oYnkDMo/DpwSLaNssA/+thzXrwzoT0RtDSCRwFGoLNBsE1ADswk5P7j3NsXQI33dmEijXqsq1dI7L2ruGIuZMlOz3sXGAZrOKwrLrZQGTJZ0FJPSfmQw1+mUAbWOaoXbt2MXHixAttviv4p6LgBIVe96mHXP5M/GHN6fRx0KVnG/re9gC3dGnPyaSFrD3ozw0dSpT98c2w/GvY78K7byn5O/aR6s7n9RQoGwaDnx9FqVgf2LgX6tSDsGiI7wL+CWS9N5Cn5mYRVuYgz952Nb7lEyGhDOt2RuIpl0nzCrkYRxpDViI0KA0B8VCvEiQvhfV14LargHZAJri+Iz8hjewTpYhpFo2lL+dSkOpkx5o0ls614ygVwHdLFrNnRRL5QEUsO3JDYBWQ8191j8YyQ2252Fa/gn8sqgOBwOZLmOYl0ZwBAQF8+dUXVK9ViZpVGwAQXvlWbqhcckLubtg7G076Mi9lDsnbj1EjO58PkyGxAG6qCaVWzYbyHWF/CNg+g96TwT8cPImsOhGIT/IReg6riKMwGdJKkbE3h+zwKDpUy8KIiYbgBrDre8hoCTf0gCVfQKMqEC/gHcicCEtscEs9AstXILBaDNamw7eAHwFlQqjZ5ADlykcSWrEMrbuO4PDenax9dSrzth4nEMusVATUBPbzy2NX6ZzrUYgr+F/HH7H6XyzOU3Ma+PrWZ9asV+nQ4UzP2abB8RmwMpWs/T+RvSYNW9EhlvxUzDYbnMiHfKBuBPSJh4oVq0DvV6FeJJStB2kb2fafN5m7Zg3tm2VQv891OLYksnVNEUv807lmaB+qHt1LUF5dDG2Hun5Q2AwtzsWz8Cuc/WpBh+vBaAFFx+DoWohuDscmQuXmkLwRth2E4jgI3gsNroeY+oAvaAumpzFpW46y96t9TPxsBkkZ6RzCWnP2Aj4u+X6hqFKlCkOGDOGxxx67iFSu4J+GWODFlyYR/eqT9D6RQdZZzrsoa63D4WDhwsm0a9eegwcTWbezm6VGAAoOwN5hcLIQlnxAwPENmEW7+WZFMd8UwtF8S/tkA6EnoGg7FO8/CMmfQXAsrJoB44ez5qO5dO5dSP2b7Dhy7Lw+IYVvdZSqbbtRzT8EvxrtIHkNm+cuY29iNlO272P3ns+x/+t6qB4Pi3ZA+gIYPwGqFMCxr2DWIdiQBM+shJxCaF4ADQdA+B2AE9K+h5yl2BwzKXtVU6594hZGf/0Jo+OqUB1rmrsYy2r7M14+30YrQcWKFRkzZsxFPmt8BZcSP0146y/J5wTQ8qsPmJSXS/4FXH/ucWYYNLzlWa4uk8TXM6dRtmwpalR8Bpf9GLun9QCXL6y1wWdvUOCTwrqkPD5fDbtz4DqgK1ANKI1lthmXC5uigXXzIG0VvD6RtyZvpoqvm2qNfXFkdWTH9HUYTXJp26ML17a6nsDjbnp3nMSMtVupUr8+5arVplXjKmyPjsAWHIoia2H+tAZeedta82YUwOYdcG0viC+CJ2Lhxh5Q4XYoWwn834It4yHzBATeDMb9QEOMHW6qeo7S4osPaVOpEjEl5Z6Btc4AuHfJPRi285/cpqWlMWbMGLZsubJSPScaNoS1b8Irf242T7zx3p+bQQkKgVu3recHV/EFPc11zjWnzTB4674IGna+n2KbLzc3i+W1Ox9i1PyWxNbsT8qo6/GpkMY2nxOU2grjloI7x3osYCPQE2gKrMR6+WxwaFmqbsjFc1MejqnHWLchjXVZXm7qBD4xV8G0TczfnUlQh8rYo9uxaVoyU176nKvGxnJN0xGEZObCO+MIuCqU67rUo2jU53y124/ILgXcfO8gCLgLQjPhOicE9Qfn1xC+u+S5XBNYD+RAtUCw3wOOG4Fg2DYNqtaEsOb47pnO4O++wHVzLw4lJzMOeAB4HWj7wHw2bByGzWZSv/6b52zgoqIidu7ceQFd8/8PzuB9BLjfIPvdPzef9Tv3/LkZnIbtF3Px2V701GmeEOIqWK5AgmyGtjWK11vL/6OvHumvJ1tUVfoH0frmTjSzCxoVgMqA+oL+U/I5GjQDdD+oEugTW325QkrL7I7ULUrPhzrVFHT4HZu0u4FW3exUqxB0LOlp3T+ij+7p84B27n5HWUVHZJq5UuET8ryM3o41tKNPsLwLUeYWX2Vl9JbMN6WcJ6S1taWtTaW+VaU50VL2bbICLQyT1EZSX0mTpJ9fCc86LmUdldzFUsIMKXOv9PUIZbw8R8uCozQGy2fMG6BIDPWvFiXTe1x79tx52V/m/Z8Sf2SL/RuU4y+Ws/LvfMj5sxigMjZDcVWj9e1DQRr3KFoWZ9fk61FFPxQPuhY0BYuUXbFcOnwNWovl9r48PppXfbjMN+ZJHetpqi8aWw9lrLxZ+ihM40qhA6PQTe3C1XnIg5q07zttNlfq7eLDeuqr4frskRCZb1TXyW+cKkp9X8p7VpobIPPkULkfD5euCZRqGjIfcsp8JkDKaydtv0v6LFY6UqrEm8BxWQ43S+DxSKa3xK1CruT1SDkZ0paVKu76sqo6A/QFKDscJU54VQcibTK9Xplmpg4dOnTZO/eyyX2IzYFigKHmU5H9IhyeXYx0/naiImpVv/ztcYFyScgJKCIA7R+BRgaggUHoFgOF+qBY0BuVopT5TAfNvrua4rHI2g7UHdQL9AJoFGi8I0jbQ6JUPGumCh9soJ4R6Mj39XXsTh+18EVft0B1QmLVZeI2LXIXat7mObpn/Id6euF/NHfRIK38brbem7VYw4b0kWtSsFaVMXSgQoDMG5GGIE2PkHnybpnZg6XdraXPKkgHHpbcKZJyz9P5SZJ03zN6KqSMfsBQLsg0UIWwULmOJskcVFYyZ8o0TU1LfOuyd/BfLY+M9ldUQ0MkGeqRjQYUI2fwpc3D54475P/886Ktv+hwuof21oJKp377RYTL5vg9p21/b7lk5DRA4f6WBzJfUAxoAOj+li1VuGSqtrZw6pN2dr3ez3K86wTVxCLljaAGWI6KDz4wRWafrlIfH30Zjk5MsOuLqijMQA3sqFLLnuqXUKBlpqkRGzL0Tn6h8l2FcrnyVFxYpIRp7yt3VVWZhb3kymwoz/EWUirSAaQxhvRieWlKL2lGJ6nwTcmbfyYGngVzpebxOnlrbeU86tBSfzQL5K6HMhKmyjS9Us6XUr9gmaapAlfeZe/gv1r8A1Cf9aidBwUJ3SjkuMTkDOnuq1pHhin2k2dFU8SdTUWzeIFD3B4naoRc0vwul1wycp4upUBPgDpchQp/sku1/eWpjIqrol0tUc+S8yqDHsNyhlwKNBQ0waeJUmatkf7zjsaWLqXUIWh0iUe5OFBqapoWek09v/0jvTN3rYa9PkRPvhih/VNv14E375B39U1S0ZvS1LJSF5s02i5N8pfS20qpvaSijyXXJsn1pvQr19XnwKz2Wl/TX3lP+GttvF3D/axp+f2gmTbknb5Lj4SG6c1gf5mPIpmmTNOr9PRvfretmjVrpuzsbE2ZMuWyD4ZLJWF7Nsp5eIyMgidlb+cnbJc4DweyBTllNPYVn44U23aKW24q+c+49PldJrnk5IwAjQQ1qhug/KW1lOeLNhvoo1u6SsdWy/vt9VpyveV9/CHQLaBXsbTmPaAaGHqiejulbdmjV+vU0Ty7NTVuB+rmh/JzsnTXBy/ogfcP6vUHWmnH6poqdq2U1/2dvK4iqShXGny31D1ASntFKh4rufMls0gyM6TET6VpI2SFPzoX0qSNy6RmTaU7bfIMiFfDKD8daIaKg9CtWB7W82fPVM3AYI0DFX+OzOLnpOOBkrwqLPzyjO0UUjpcIyaPVWFhoX766Sf5+PzvxLjEz0+81leUDhHhf1Ie4ejqcWU12j1UI7w71GDBDtmadBA+XCHnmcQJaga6Owy5eqKtDkNtQRNboLR/G9rgdCgt3NDaKHQTqCHWtLYv1vpzEGjpzdcr4d4WKhr+oDxJSZpWrZoisQLUfDphklwul17o9ZDGDB0pV/HbMr3Fkrwy5dUBr0f64gFpX1fJ9Y5keiTlSbnzpSmjpVGlLGJ6z4OYm+ZLu/ap5w03a8kthmbHoI9sqD9okIHCsKbyVUFTGjlU2Bd5ngyV+fwQJfnYZfoakkwVFuafsa1q1qwpj8ejlStX/ip4zf+M2H8bDvFSi2FHo8fYtORQuDq8U0POWuG//B+KuMTxSc9H7r6uuQ6vXqD777//otO6pOQMBX0Vgk7cjd4y0NMRyDMSeVeh5GZo/Z3IfBeZ7dFHXS1tGAdqDGoFuhp0B+jTO/+tk7P3SnnFSh7/b9UNCZENdPz4XL01YrheHNZKqcVFSvvkBplzbtU319q1aXkZ7TffkbzjSkjplVQgpb8t9WsozRtrWVu93tMYmCEroMJ/IWWDdPCQdFMv/QdUsaSc7bFuKoGgT7Fc6vuDch+7ShmlDfkYyG4YegJkum+W5JTpmaGs724+1Ub+/kG6q89gjX2zjyRp14oVan65CPQ3ET8HOvwqGtYLrfwCbX8NNTqfrZNAZMQgWwjCQI9//I5ad7/5jOfu27dPMTExf3pdWjYrrSULP9IDDzzw9yFnmC/a3R0d8rOMQbOCkdkDmU+jY73Qylu7yZw1WXq5nPRhvKYEWxGxOoBeB80GPYrlCXvmTSjp3gdUnJQm0zT1TN+5SmodJm/iQtVvOEEfzFugIc2d2vnKM3o12pDpHSDTfFLmr0IeuaWC5dJXj0mmaYn0y3czUzL3nfbbEvOn+TI/nCJzUieZB97XuBvbKxprTXy2AEFflPxXDuQBmfu7WTeChjbJnMXNV7wAACAASURBVKjc3HGnzg0OQ2PfDtfXL7wlSUpO2q2B97WSFZO0ZGrr7ycCAy47af4KaXU1SpiAzJeRd6K/CqaP1uHlHTS3JXpqBGrZ9txpXNULLdrlr0VFN6hRtypnPOf0kO4nT55UQMDfv30vmpwBoGLQx1harwqoCHSoDNo4AN0O2gea0ihOeru9NLyh1LKjzGvQkuboGawpbTSWF+xJDeprelSYTj5UW2bafsk0NWelqRm9VihpVoaCArppw5Jxemv8PK1bcLdM0ytTU2TK1BKtKyGmKcklmRt/S8qMBGneu9LyLdL2YqnQlDIKZC7ZJHN4D82qbW3vjKkYrbFhQeqB5Sn+TI3nW/LZHcsC7aqA5JkocykyhyGl9ZGm+Kq4IEdPtLDO9fND9w+Kk1lSLtM0tXChFV+mZ8+e8pguucwimaYpr9erf/3rX5d9kPxZMuJRlPQtMt9H8vrJNCfLND+Xae6R58Qk7XxhlHr37qJ7e8WoQ8zvp9WoJXryi2aq36H8/8y684LIaTcMeYuL9QjWUz53YhmCZoJeA72IZeD5IQSpG9IrSIOQqiA1Rxr2sJSwW+art2nhjei9WPQh6GHQdaBbGgzT1p5D5Zk0ytr0l/TDsgIdOmhqyhdb9OP0d/XmqFaaM62NvJ4BGqtP9Eusa69FTC34ZZpqmpKnUDq0VZq14VfHzYK98k4ZoWl1rD3YRqBqpzVQa6wbx+81Yj2s9ecrIG//5nq+pD3UC2m4Xd7iFlo7qd6p8+PiSks6e3wYr9erceMsbfvSSy9pyJAhl32gXGrp1QXNeQppPdJJX0kjJV0nK0jHKsl8S/K+qazcSfrih/HqdGtXEYwoe+60R82cqXrt2v2l9RkyZMipPjtfsZ0S22/CMRhcIDk/BcmO3LXQ06A3QT+BJmFNTXNBC0AJYCUFUk2kW5HujpJeLi/VNrSvtk1vVfbVxL4OfdkFXRWBrgc9FoeebtBBqaMTrGVhifI7tMajA2luHZs7WvfeO0TVW3bQu80dMs1PZUV+dsuKwPXlaUPdlNxuKTP9NyQwk4/qyItjNaBqpVMN0gvUFivOYtQFdNJYkAvkY0fmBLu8eV9J1/ooP/M19Sk5p3JlP3m8d8k0TZmm5zfEfOutt+Rw2OVwOORwOGSz/fnGlb9SDAM9fR/S60gzbZLul9Rf0vOSXpUVFNhbcsM9IWmBEg/9oMF9e8o4S8TuU+KLpv8wXW3btr3s9TyXHASZIBkZ+ojAXy2bNnCB5JQT6TWkNciMR2l2NL8ks2OgE6B5WOsvnS42i9S6raY0oKE0ZrS0eaq23VBH/7ajpTeh1ypaVtw7wlDClg0yZ5unHnUd+lWa8gvd+unHKXLWGqA53/aWaa6UNEanprIySzr1Z3gkZZ5BO5k6umWjxt9yg6ph3cE6Ym0D9cd63tfAKfhjxMjHIrg5FnlXltdPDqRXfFT05Qi96GOXAQqNDNRLnw6TN++QCneO+1W5Jk+erHu6dVLGno1yuVwqKCjQoEGDLvtAupRy5w3o+xeQtoZL8pPkK+mQpD4lfTVA0meSRkv6XFKypJnatuo73dXRoarVLn8dLpWkgMxb3lWQw/dXx00ukJzmU8hjoLzeSMOR9150BLQcS4t+BMoE/QhyYxHTA3JdgzTEIZV3WlO+sda01xxiKOEe1DEaVbehe+3ovdLoteb1lJmYILfbc2qNtmzyNCUlulW9rZ88njyp+HbJnC65smVF3CqWNOs3ZPwZpim5PF7t3ZSsUZ1HapCvn65xOHQbqDeGwJCvr6+CgoLUNOhbxQZ1l80/yAoOfJ4N3qKkcVNAyaWROTdAauirjI3DVB1UOhotml1amzYOV5sWHeVyF6uosFguV5GKi4tUXFysnJwcjRgx4rIPnkstTica8iTa9pS/3O5IWaGQwyQ9Jenlkpuru0ROSlooK5rat5I+1oLlrym+qSGb/fLX5Y+Kv7//b2ZBC0EnsXYATj+ezQWSMx+03c96mF12a23lAq0B5ZUMTIEyQItLvu8B/WAgtblZGvqQVMkhXeOU3kGeu9DuCmhkXTS0BfrwGj/1C7Ppzuirlbxzr+bO2aGcPJdMU4ou95jW5GZrw7I2OpHdR0WvB8g0O0ifR0paJiug7BlIWdLdx/KkmeuOaPl3Hyr9u++U+Mk0PXP7QDUPCFAnn3iVcdTQe+9MUmGBlJUlfZ4tNZgjOao2P+9O6AsqANUHbcOa5ivcUNFghz6yoWAfNOy2eG3atEoNrqqsSdPGaOSgF/TpxCf02ov/+sNrl3+S9B2MIiL85Er+UXMXh5YQTyUkHS0rXvkPJf24vIScc0q+L9DqZT/o9juqqlZz+2Wvyx+V2bNnnwpHeT5yQeR8EVQ8GCkEKTpI5ghrAJ4APYJlvf1ZY56SQKTo034/3EZ6opNU31d6Dmm2n/SFUy80RgPD0T0N0DOjh2jNm/2Vl5miOdvdKnabeiXF1Gt73lFK9meqeVuoptweIDNvhqSCX5HwdFK6JGXJejlsdsnxAkmb9ktzpni185vlOvbJp/ry7kc0rPM7Gj/cq/Ejpfq1JNt1UsATkr3c+ZPzLdAErL3baaBXfJA5NkKFZVFSDLomGH32TLRSE4drcPfKAtTimo768N8fqv7fYBD9mRIUHazszEe0YqKvpKWSOv/XbbRI0hJJOZK2STpQQtgESa+ouPBjvff2ePn6Xv66XKxERUUpOjr6V9s8F01O0x8tMpB7vF3F00crFTQGa731OWg71vZJDsiLpVVPkdKG5IfkRIpH6onUwCm900N6uZE0zKFn2qNh7dCzA1rqx+9f0bxlK/TDzj3K9Hg0YIlHKz0u1Xq+ow6njZFpPiVNKC9piiTLjLCvpJu9ktIlrZX1luaZ4Ckh89a1hXrjo0KN/Heq+t5/QtXqSDExUqOh0qMfpKlClUZ/qOHvApkhQTqMtc3ksqMfsKYxH4Oeq1lV0gqtWNFcNqwXBi73YPnTJdiuEYdf0Mu9Y2Sa3SW9JinxtN7wSkqTlCLL2r5D0vuSPpdHbuUW7dHcqQ9qwK0B6nIjclzu+lykrF69WgkJCQoNDf1D5PxdB1+ZnQwdnGtFykwCVhjQKgbqHrVcSA4EXgWWA3diRcP72REfEVju6/IMyxtzU0HtePAWQ++msCGZyXN2srUoh751anLSLxxv5evxvfcRtgQEsgOowQHuzfNn030VaPj2B4SV6gFGHjmUI7SkZq6SfD8Fbi3J8kzIwHIbUb7k98Z1R9ixx4+TyaXZFAD9Wh9j0rjuTJ+5hqKiszbJb+AECkb1ocFzn7M9HIoDoTjZckqdDWyuDh1X1WZTwnPcfHN3jh49/7T/qQh8OoaYqSab1k4jMPQAhlEfuANpBxnZBykV5gQeAuoAg0BbQBWQ9yeOZl/N9G2zKJiXSpL9BPOn/4C5xxpC/6vQhTj4+mIuXIXlrzUBeMQP4kbDTn8IDbdckMzGCi3kBCpwWuSrE1i+SQp8oGMAFNrhqz0w9zDeCaswb3iKfv2HUNunPCpVzPbN60hMnUlFVxFeid3A7VRl0ievcLRhWWZNfhtYiIdwFmIRMx84AMwFRgLxnB492A3kIiznJFH8QkyAxk0rEVUvlOrV99Gj1k4SPhrBvwdvp3t78HOeb7NCkAEOvx/ZXjaEvLqwMhmWlJTvkAEVs4GXTtKo0TImT448/4T/qQiG60ulsX7ri2xZNJhUvMA6pK/ZlbCJz35sT2HiO+hIFN7D6yF5NBxdDCkvoMR1nHhrCGnTjnPgaAbvvvQD+//Hifl7+F0fQqFYUUgisIhYXAjTB8PAxkA5g37rg0hOzGUyv/h3LWVAuCzNAVC0vxhCg/CLcQJW3LrCzXn4JiZja9+WMptT2V08ja+3uRhY6yAH9h6ioHEY5ex2wgz4+q2JrNn9CTZ7d7IoJJz9dKM+6Vg3jCAsN9LCCleZB4QBlt7aRyEtyC+pg/20uqUkZhJSsJP09e8QGLGGrtc9Teimw0y++xDYM9ib4s+2bbkUF589eEMYcGutGHisNSo4zv6xi1kIvFDSsE19sfZqZh/DGPQdISE3U7/Gd6QczCb9bDHI/+moD81y4li/Ywntu23lDeMrhmkjySn3M+C1Crx7+y1sfSSNRubnuAttBJYxIcIXs34dikLq4YpsQObib1mxMfxy1+SiUKtWLQ4fPkxh4YU7Vf1dzXkPsBQrDAFYGijJACJ8ILcVRV3jyHfA0AjLC/r7BmTYIZkSd5IOyHRC5u5C8HNDo3CICyWodXucB5eD28nJ9HTW/+jicCEcXppJ9rS3ScgppDlWgL+e/65HUkFXkg/vYIWOIOpxDC8bsDT2CSAOAQUIsHmL8JzYhzvTIN/dgkIgDSjGmtbmA2l58M3ULXzw5W4WHOzE0HHRTPj4HbauzSTB3Z63H41gyqs1iY7w5UwIwtLEg+Jg4pSOqDAX1+rF1HFax4tKJN8LZIHSgcHHuSrqAPO/6M59TS6or/4RqO2JokfXTlQ7uJrUgkPcmd+WxOPiqy9DaBbfkRs7vs3GxM/ZUghHskxWHoG9mcVkHNrIkckf89OiT0lKz2JP0eEzpl8VyyPi3x3Dhg2jTJkyF5XGOb3vhQMLsXy4GjZoURHwhsC9/cm5dxDT29WiSdYuvl8Ho3xhSSDUyATTB+JjINYLOCIh1wlX1YV6PnA0Gg5tgyMz6NO1GQWJ6yiVVESauxRHEk4SliXahEGKAUERjViZ5sJ3+RQq3j2IFGADHppgpxBohDCVQ56Zja8ZwtGj+6l4fBVe82pS4yMJD7Wc+3o9kFCy97PnkJew+vVw7NvH96tWkZN3ghEzDrMCiPlmN9WBDaRSxC+xUU5HaaBfy2CeHhaJUSsF7bydrO37iQjZj3HcuhGkAk43lE8Adw0bvkfsMC6X6PGNuWFcEutGH+XIkZ0cPPMY/Mei58PxLJ9dlQ59erMtcz7RBDFxTR4+h/34ac1HpBfArK3wo7tkTQ5cC3QOAb8a8Pl6K0Ty2dAJK67NDLggX7B/FQYOHPir323atGHFihV4POc/ZfpdzSmscGfjgNXAqw7odA2wMBseH0B096Y8dGMbCndDG6BuGYhvDpOALX6wKRQKI/zBXgD7j8NGNySGQey1cPuT4GoMIUXUbVaDk/Il4tbKfLBsHtULk4jH5OODa0lYmEqXOH9uu2cM1Yzy7MegMb5sxNJOOXgxSSSzMBzf9R9Tc+Ni7I16cbJZM3xCLS2eCqS64HghZKVAlOEm8+gREo+6KfTsp7QnhRCs9fNC4BlgCpbm7lTy+TPigTqt4Kmvu2Hcdh8wB2PpesrcOgCjkrUUSMSKtVIRMF2Ql+mgKC6U4qQtZH71EdeUGc2sGf/mxWeb0/XGWOKrh553h/2dEVQWln25GVeHQv79ygwiE4I4ZM8lKTqaxKI0GgSJun6wzg0/UmKSwHLc/VoODF5vBXj8PSyjCnWJpu6fXptLi379+uHre+aZ2NlgHz169Fn/fO6550bfAdyEpUHHCEbkA1E2aFAPb+OKuMd9T60+bSl7MoW1hW5KB0LtDCuI9dTDULpCGOWaloIWTcAnGRK24jViIKYaRpO2UL0C5XdnsSctj13JW4nLd5PjCKdjy1a8s+Fbnr9vPAU2O8dZwjGKiCOKRCAWUZkMwjEw3PmErf0RY/9KqN6SgmgnW+xlyQGqYE3HPU7IdEFqMhRlOyiqFMt+v2oknihD/ey95BelkI1lADsOlMIgFfgXFmF/9vr+fhMY/VEMtriPwIgCKkJ8J9gyH3P1JjZmu3BhDbLWgM0BPqFeCgvz8Nbz5fD0IrzJK4i4ugG1r27NLc2dRAcLj6+Hgvw8cnL/UP/9rRBZE2b+OJjpCw4z95tFrPl+OvsDfekb3prepafTtUk0DaLiiK6QTlYqpJVYxUtm/5j82rv+mdCZq2mIyVrS+ScZvmfMmIHbfWbX0qNHj37uTMfPSc4HgXeBI0ATA66PgSnlfKl3VXPMKWvJruKHt01XEiMPsmLFCSLz4GiwHd+yDlKLwqgYbaNSQSJFpRpg+gbiaFwf79F0bEXFGDXrQmAcHFlBOb8YXp+5Db/CYsLzEqhYPZbEa+8l1O6glgHLeQkv5UiiCmUQEeRiM/fjl5gEe46ghLcouOUjiAkhza/eqa0MF5ACHAO8J8HpB5kC20EoG3kc3/KxHDJDKEzxpbgojf0UEg9EYyOV0iykgHo2Ub+Ck9Z1gnhs7B04ruoBxg1ARTAMy1S9bx/ew0f4KTmVdVgxVmKAfBO2F0BcEPiaAdibViHNyCI/4Xtm7hPZh+2UCs6lRafGVK8RRFTBCbKLfMgqEpjnE0n074O8YzB25GIydhaQkP4DSQfAP7yQOxZ8TK2naxJYbyCVu9xOqxsDKO+O4cjh/SSXhHI7Xx/6WzjAd/8wYp4LF0zOWVhhUaoBb4fD9Mp29nviabd6P7ZrI/E7mUnx7o1UqeZD/aAgDuzPJs3fgULsRAWVpZEznJzYMHzDgyE1H2f5StgjAzCqdoa4auBrh9ptyJn3E5PXrSHH4+bactnMWbaKW+98EJfTSZy5lxwMjhq3EoeBPxBMAfI4cC2ZiJ+5HbPLHRTmN0SOQ+zyqUgBEILV6WWwrLh5xyE7DeyREBsLvpGhVAk0qFO5EWUCKhNdOZLsNBvXB9dkRXE+dWI74vL34ab4xlTzPc6Y2xrjc839EHq7RcqfYQD1gjFfW8nWuLIEHUvkCNba1AT2m1CjCIh0EVjeQ5noaA4fO8GsDYmERgUTVKsDq9cG0LZ9c+5pV4mwSlWpVKsa6UFestNzwOW96AHwV6D/IEhKCOc/E8exekc2pYMhpCibgdeXw7diNYh6D4xU7D61ibu6MRUDctiYJjJSTmDjt2v7/y84GznPKwSggPnAdsHiVQaf9g2iqH4BO7Yl06RBP8JTvgJPCKpdndiD6dSpV0RiopsiVyauQAfYryI4qhY52kHOgXkEHg/DnlMRQtzQsAkEBFMj3omPj0HISWjR2caBl1JoU/g9B3x7sYdFRNKOAMAXUaQjuDOzSdo6j8pV65NYLxY/OlNcGkJoTWWstczxEgnE2kZJKoY1CRCVVEy5sgY+hg8hjhBKR8HJVpEE+TxMhapXox/X0aV1G3IPbqV8WHcWB0K3mo1J98YQW5yL9TbTf93rHW6cj3fl/m/n880N8VRatIejbisS9j1gmYr3APnp4EqnTs8onq1RiWJHBKFODwX1FpOf34a8clWIDt3MXTUqU6tLLEdW72LmF8vZuyePP2BLuCwoUwb+9cS/aNSkEvjA7mCoFwEhtRrCERPitmHNZ9w4/Yu45p4HedL7PS9n7WfPuRab/w9x3gGzPMD7uXBPGw/r9q3jo+AIvG1H4r6qFRm7TYjuSNgJJ43qQNkwB4WFfuS5TapWcxAUmk7GttkoKBiVbQm1BkHjJhBo/+V22bEbcQFBxDogNhyCDUhfNIoQZbDFVgeXEUojwYqiNVSTh5Q9s4iUcNcbQAqdyfdaNqdELEnHImYs1npm/TE4boOG7awlc84xUTpKhAZCogFHzeqkOkOoXa4M13aPIyiyNMkNahMfEsLNbStgBEWidjdA1Vsts/UpCMgFWy24LhSfFvW5o4mDep2jOWH9w/slZxafhMxtWPs/szMI/iGBsNTtmAvHcYNtGS2cs5j+5ng2b1qP1xPCTa5cnht4C2PGPMSg5zsTHOF/UZ39Z2PMc+Bxw8bcI1bUKhs81h1IS4Dy8ViPi8RibYhE4O+bRudrunJV09aXsdR/X5x38FwT2CIIN4GrTUJW5tFsQDXc6WuxDXwaswyYSZtxdHyUk6v2ERq0kPByvuwDgnxPYHoqE+qMwHM4E6PyNvDkgc8tYA+2MijfgPZlffk2HRIPBTDDlUfjifu5vqtBfVtr/JmI6EYTw4fdRgZBZVuSFdeWldleQtO2k+E5gFG6O4lY+7J5QFkT9hTA3mIIs0N+MuzceAJHoSAogqZOy5vP7kxw+LhpVMlOlL0UaUHNKR+0m9jgblRPnk+xfwD5tmLKNC59lghjJWT1D4IRJ/HMqMSGzf7MbpHLK8cKmRAGb2+xHne0AaSDby7ge+z/uHvv8KiqNez7t6clk95DgIQESAgJvffem5SDhSIIKiIIKPYOKtgFj4gKAipNQZDeew0tlEAglISQQkhPJjPJlP28f+yAcEQOeDzveb/vzrWvzOzZZe21173Ws571FCguRe1dG/TxcOY01b1TaffoAGJjO1GUuBnlxwwqzMGMfyaa+iEd2Ji2hc2f78du/St5q/7voFcUoEBkbSg+ATnhp7m6DPYXG7lh2MnQHp7UD++NKcYPr9gQ+g4cw4H9+7iS8b8u+f9b+Ldzzjt2CDTOgtBwI20iYjmz5xTVH++D2XkDKc2EiFpISCTWS8fx7OJCPIIocdioWTcIzwa10LlKEe94lOb1UPb/CmevQHx98Pbi7A0ItKWy7uApbFbhQqaTnAJ4emok1fXNKKUcP6pyrTybEDc/vAJaoACeLiHIZeWy0YVXWCQWoCaaFBkFFKuaYsYBJNnAz+ikQaSOLvXdybpqZ+lZIbPExkPR4G41cL7MlyhfFx3b1SPrnJ12fUJxOYWuw7rjbjTeMdXUoABGUArA8xCoFuTSOWw30qkyxEojp4s62VDkA4EFsFc7mkAXmrYq005OqQ5rgRmvghxqD+1HUIP2cHgn363ZT4hvIq7w3sTWdNG2VWPiWvSiUWQrjmfuoPS644EnaqGhIUye/CznM87QcXQsbqVBDBw4kBMnTjzYhf4Ez7z+MC90SqZrs/Z0Uq+SVA4HkmDf3hyuWrI5cvwKkpGOwa01kY1vYDS6ExRQjyvn95GYdOPf3+D/h/izOed9ibUK2rKA3QTxT8K0A964DZ9EYGcgxBsCy9BF1EVfVoCiNxJUKwhPv34YKzyp2b06169mUkg41A9HTyK6ZAs0eQK6doDr18Bmw88dGo2cTHx1L04ftfFobygqAfZ9CCIc3rwDBW+CjSH4Eweqi7y0nVjc9ZxUaxMS0ZGqgBkIrCxzkgLXzHCpHK5dhaE14anO3tSO8+H4wWKW7rLhVkXH0HrlBOXeoCKvAl0IxLYPxj/QSJuuJmz2KrTp2RQ3478TMtzBWQt2pWKoHUu9l6vQv40BzKDUAmOJVrYaaJxMFrAL4AXm/CyurthO2okrcP0y7NwMv/1M3aTreHd6g8796uDjfQy+fo+G877jyUdymfvZHOq3c7tLZ3F3GAxQOw4QG/qKJMpLHWScKyAiIoInnxlLm06t6NSpE8OGDbu/C94FDUPgpbH5NB08n8aD6lDdCb4N4boJdMFw8jqUm8FS7OCqdSs3LqpADv4BdvoMmvyX73u/+HzhewAoisKiRYuYP3/+f/2e/wnui5yC5pXickHyGejVzkHKgp+IjCiHXRehRi/wzQZLAbqSYxi6Po3ZFU1YaioBp1TMJZEYyjxB9YBG7UCXC4YsaNAUwiPBYCDjFLgH1cTLx0ChAvsvwVUnbNp9jaO/LaFZVFsuAjXdalMI2BUFg28E6QoEeMKxVLhQCrkVsNMKeQ7Ql8HpTLjmAcYIuHQdPlsBnx+DpIoShrew0zbsCmWuCip0fqSZDMT7Q4gBHIdSqBuuIzhMh84IJoV7EEGAtaC7CjXLIL4KGEpgezdoCua6UKs1lDaE/WiL78XAQYEEO/gWQ2Qg7LsB2987SNlLG8GYT/cXnyO0Ri9IXsrFZxOo2HMS6i4Dw28M6DCYrz5ZSvDoHvcq2C2oKhTmgbu7Nz36juaVKW+Sc6qCjp07YHSVUjOmGgMmv0zz5nH30yTuihAHVAt8GsUsEFANUxVIPQz552BXCpw5B5cuwskUJ972fXhkHQHycXNPpW59P+Ia/OVb3xeefnzCrc+jRo1i+PDhd/weEBDAl1/+38l6fT+4b4VQGqBXoJEPBBcaCerdm+x0L2jdE0LqQUAsBJWBXzRUa4GHP/iEeaGPb09gt6a4H12PI9UMmTlQJwoKjDDvBXAUgtFIRCgY9PDcew8R62HCkQyd2sLrS6GaupXaMV25WNkIrwHXFR1KQG3q6MDfH0IDoJ4bhBqgnhG89ZBrgka+YM6Fc/shvwzMDaFDLXi3WyDWQF+OHzLim+HBseQk/P3zaRKaQNDRQnyrB6EzGQgMA53+XjVzE0bQ7YDa4eC8olkhBJ8GP/CMgLrB4NcYOgyE6NaaC5sncLwCni2E/TkQcw2ij8DsE9DvV9j5yT7sGa/AzIMEeTkwTAG6LADTp8AYOrRYwNK3ZqDX//sCqirk34C8/GLmL1xDgFlHpy59eWR4VyKj4mkc14Ib55O40x7qwRDpC8rlhUATIBSGQNoa2HIOrmVrx9jLwBUBvi4Vo6kEzSWhELPZn6gaf3JhTzSD5rDKw/3BzXynI8NdEcMdSvVHBoxk9AQfRIR+/foxePDgOw63Wq2sXr36AZ/6v4f7VggB2Fzw/AkIrSgjofMxXuz8DAf2fkjbJ78Dn24QURMiXJBzHBq35dJVG3ZrLHG9r2PyCULx6w0ZqyG/Ahp1hUYNwJUHjuroaniQJ1C/y2sMaraJH/emcywFCm9AaHExub+8QsDDH3FKUYgDRIVlabDscDkRZcsJrDkaZ1uINYFFrz1YZx2kG2FrEXiFQj0PuJoHN67Ah5czOHjlHBPaxJGadgDP2GD617fgvnk958xjiW5cA53pfmRGAT5FW1U1AhtA9QNrKdRrDbPTIFgH0e54X7QSrsKpS3AOiEdrP+6AtUxzaVsCeAPPJ0O1CyeRTKAI/JcEQbPZoO8FTIa8tXDYQdfeZWzdspFu3XpyL99cAE8P6NihjNXrVnA1bw+Xkow8MfI8Zh8PCq3XSU8qwtPT80GaxB3YkguuNSo0jAd9CEQ+y3GTcEPVagYAPShNwFruwhCfhqa6a4fYP8CZpx1i0kNYALiMPvZAqAAAIABJREFUkJEF2KFqDc2SKM8bWtSEanYwtezOzl+TuJ6iMb9+LKRcgYqbZkbXPTA2aozj5EEQYcOGDdSqo5Vkw4YNfyh/eXk5u3bt+svP/3fjvkdOAJfA4VJv5J+f4tizmyu14jH5VfoI+PpAo0akWtzZfeYGztIsgqINBASYKUuzorf5ojt/EuL7wOW9sGEV+MVoo67eDT8T+BlBZ6hBv0/7U+RuZMLkNpTrFSzth/HOih1kAZsOaHNKfwWqhcIjHYw079aFsFAwpcPJRI0uRjStbTnwbig0qwsbQ2FwXXi4KTzUtyo/jmuFR2gZbTtFMb5TfQ79dABb9Z7UaFcFo/l+bVZA02VfB+xg/wTWpsDafPgoASJ8oV9fUJ049WBMgx69oU+cJt7+AkQCp4DBaEQNAZKBRBW+Ow6fXoO8Za9gf3oxkt+bwr4ryOjlQF0EnTrspkOHcJT7EG3LKyDpAkQ0dZByLpPwqDT2HTrMniM7Obb3HFlZWVy8ePHW8ZMnT2bAgAH3XQvpZTDm20ScrteAn1EzPXloLdAEnAp0fgyenaqjRy1oPUpB72NGs34+gtlclboNIaAF+LeC4Hgo9wT/PkBrHdbqOloNghcnwaBe0Ksj1KuVi7upAoBHXoASB4wf14J6E03o3KFrRAU7vu+F0aA18+VV4PKF/3e13P+KBxo5AaxlVg5+MoePu9ci+vJliuqE/X4lA4SF18TlMpJeUExkk6F4XzkGhEDrFrD+FygJg2GvQLkHrF4LA3pBdR/NLa2yffn7tcWifM/ReUnYXUL7IW/z669rCARa1YPLLpV3vt5PkdVIeXgU7YdEMFaBFBdUd8EpF7hXwB4PTUsbYYRqPvCWAHpNRC/L82LPeTsphdUZX9OXxd//TLN6dajepDHu5gczUNb8UAxQoYPnp8PjVeCFL+HiQGjsDekHwNOOvr0b3g2q4nfCTmDDQqKqGVmwrZiv0CJJDEcr21m0kbUhmuH9djusXjSHgY5Mgo44+PA8FDih1SUoKQbZO5Cgdio39t5WpA5oE9z2aKEqQoFsUDLBooMbmWApgkBvqFEVCkwGQoL1HDpacesSkZGRWK3WB6qJ33JyWdhiHmOPm9AFf4K94FseHXuSAKCiHLpHCCGdqhIYFIDmKr8eGIze/ShV6kCbCpBMqGsBj16QFAhbk715rKtCmwtFVAuHXSrUr1qDfjXHsOGHhaRRwNAecHQdjBw9gLZ5F3jiRztfvOPC9+o3KKJZWE0r+L2cej0cPWrEZttN27ZtH+gZ/wyff/45P//8MwkJCX/L9e4ZpqQyINEd8PPzY/3aNUybPI4t+4/i0NsxuQXcccy1w6souHyUhsNncmnvJgBqd2gKmxIgog6EnQaPxlDqBzu/gm5jIbA6lzIgMgwMzlIu7fiFwYPG0+Xhnuiv7+DTrRZQdBwGGouQnmshXVU4Igq7d22jefWBeFaFawaoaYOm4dDYS+P7dSABzQje5IQAgQIFdDYnIaKQunwpvrUiqdOmBeb7JqaguVW/CTyj7VIDIWMv+B+DU9FQ1w+2HYKDqmbFYQuAms0hIx/sCkSEkpe0g12rbCxDMyDqDgxBCw2zGc1TprhyXwgwEI3AzwNngGFA62EwbB04bhrNK8BjwFI0j4WmwB4w6SCmLqRlQ2BnyEoAHxvYijVln8GgUKaIJk+VQmhoKBUVFRQVFd1nnWgIBoLqwg8fhrOjRkM8I00cSTjIx81ceBsbo3qn4UNVtJgReqAu2fl9WHXgY7xd4LoI3uFwowSMLWB7SUdaeutpXrGLJvWgGMHbNA1vt9Ms+n4jb71jY/UayMmHjm2Wo9PF8+pX7flwXBEGAe9QsN/For5uXQVVjeHChQsP9Hx/hnfeq87a3wpJPP5gzmx/Fqbkgcmp0+lo3LgJ38z9mtQTCxk67us/nOe0leJylOPmE4zdZoXzRzH5+sIVC1SvCtE2UMJAFwCleeDhC3ojdgdkGSBcgflzn+H7yfOJqGlmd0YZN0qcDF6qY1JT8A2HBp7wXi7U8BUmL7pOTPYC8gwN8A3xoX18PMF+QTSL13z+qqGNQga00NH7AEvxdaoV2snLOk1MYBj2qHpUd3PD54GqNRdNyO4Erl7w01cwejk4TsL+2bAsWzOqDTbCGTMMbAxbc6GJHtxfgBbhkHwe29xdnNy8kl15WkeSCIxEs2euEgM5GfCCVVOztEeL29QbaOgOU8tBNUPevzjc6/1hxv4AVjxSwNkceHws/DQf2r8MW18Dgyc4bKBTQQ1GG1lPoRFbQZPU/0OEBcPQ8R6k1IokpJkXT8XVR89KWmFFQY826QAw4HT5klVSQlapg5oqlJVAQCTozXU5UB6IQU7Q1t2Km0lznvekM968wsODpjF81CH8I6FeTfDz3oxO8aSgtB9+XsUs2QQnHoLZzv++7a6vH9isd+8I7oW/jZx+3t6snv01r2/9gW1z5uJZfgWq9vjjyQVnwV4EVdqCowKUYsrXnEBfy4GxUTMgFBK2Q50m4Bd06zQnWl9qsRRSvmA0tV5aR1hkOJ8tep9fEyMpKlxMWbu5+B7+jYNrErAZ/aFlV6qZLLTrX40i92o8HOtOtE5PjhFaoZnvJaGJuKFo0Qr0qguzKni5HBgNBkRvRM/9TcKbAUcQdMxGc/tdDjILirzgp9lw0QmNS0DvCTH9IWEL9B0ICdlgOgFez0BcBHz7MlyrCpN64txxg5Wfr+fXvDyi0YwVJgEDDKAfUJeCXam8XlhOCpoU4Fa55f9JGU0mHZmFY4gN/4H9Bx7i+akrCR0IG36Blv1AfwMedg/EGRbNzszD7NkEQdXg+Kr7qIAHgKcXPDNYT+hwHZfEjS96BHG2MI3mdwhbXkB9VDmB1eGDzZFLkQlsRjBgoFh0xGDHXdEUty5A4Rl0NGD7vln4eaUQXRu8vUCnaHGaFlBAQ4QYm4koPzv5D0iYv4rWUXAhBxxVoWEfOP4TTB0GsxaC5U9mCH8bOfXubtQfNRZT0BNMeKQJfmYHA2rfRRRUnSAqljxNNe8VqiIVTjhYgVLLXZsIOipAbyT5aR1R74B7OFy2QKSntmyzesRLzFr6OSEDx7Fl5084nDpcajni5o9uwNdU8fMj/fuHUZ79AkNGGfFto5n8ZBfcKxSifeBqIbhnQ6+43wOP6So35bbvD4oCwJ93UXgJeBboATwDMhFs0WDdC7t/hZCBcHQvdHwGsm+ARzEE1wdnC/JnvI2tSiTV4yMhfxv0bUHFTis53+zghUsprEFriEZghpuex7aPQx5fzqOpBVRDizZY8WcFBDwGGCn4bS+T85fTI6A6VUszuOTeil62k5jcg0HdiLsyHtH9jMNVm/xTaWycu5z16eDUgakcrhTAub9B4jO7gcEDnvgIujTV0aeRiqrTHNI744Y24bABjyNyBCEJUSIRblBCTfaTjL68gHZKCQY3zXbaB2+uMhpb5haa+KXg56Et9+airbbYgX1rYMyzkJn1nz/D/eLd5+FgGrz92kvUi3uaJg16kJOdytHjLWnd+jgS56QkgTskk7+HnIoC0XHohnyAb1UzQ2NjsHWO5C295i/Z8S7XEBUo3Iti8ADfZuAUOJcJ1fwg0AsAlxV07nBUB/VF01gqCtit5dTz8yFNFBxOrevz7zkTi9ObZp8+zag6CuVZJSTnXmB5YjGlXk1wS1kFkf0Iz3bwYsMoRvfR1k8fRPf6OxYB/0Dr2f8VNrSSjgFWAB+CNIac5yE3FWrPhIzPwO8xyEqBRCu0bgqHbBDbCHXzo/DY4+iiXoeZs2DnPHjrESp+vMLOnw6wC1iGpsv8GFjkZWLt/jE4+i6hc2Yp1+9Rar0eskqMBHsso4TR/MBIJnAFl+qJyX4G3PPQZoYOoC1Yc0g9cJy1ewtYmwR71wMCahSoFrjnze4TtYBr7mByhzZjoVM78KwCWWehsUFHvJtw6pIJ1c2FtcJFQJgOa4zQvIGOaFdN8AcDKaCASisUwlHxAnU3eiUNuyIYgZMpUC8KHqsDXx+FmhHwgDqt/whuJm1Vw93NjYQEE19OKePlr7oQWXsM7Vs8xeHTZaj/ojD+S+TU6RTZuxc6dlYYurg7P4/aiWF6Fxo38sE/dBkXHDoebqbjRbSZlx4tIl462tzo97tX+iMqlcvGqqqx71/U/y7uHNW4NJ0qcdPIcWjdzNjRz7MwZAoL3qlC6c5VvLq4iIG1PdlRFMD14h2QZwYfCz6mC7TpPQTPsnCKddWIjqjPtEYQHPzvqvZf4UCbqd6t7gQt7upv2tM7r8KXEyH/DGrjFylIPoupbTabDjbhkdZOUH2hdiQVGRbKt/+M7xtPwnoria+/yu4rDtp0GE7L6oVI7VBmbzyN8VACaWgjZCGauP+N2cCIk08zv90iXs218mdx3fR6HQ7nPhTmIYzEyTaM1t2w+iiuaiqWnYLvdAXN6ngshdkRFGRb2XbkJBMmLkC96T5687H/hsna7bGYdAatA1EUrSnclGZEbpvuKtpOnQ4tcZ4CkV2Fro2hdlMdviiYCxTCvFyk6YUqDrhYDEV+kPUdnH0Cjk/WVBr/K7i7w7T34Nnxm/Hy7IjNZiE4OJKPl5QxaYimhIM/J+c9I753fAh59CNF5m8aLm6eikxeiqBXxKeqj3x26UtZcT1TYma9LntFS8b3rYicEZFfREtNk/Mn0dfvG6pDTEajtKhMBxff/XHpvU8V4yBV2p5wyK+nksXo4yvxc34QXZ1hEvDmavGamyhUbyZB/7wiLXdsloZ7XbLJJXLGIrK7+D8t0O0YIaI+J3LhR5F1o0TaGUU+NYtYfxN1XV1RC98RdddgceYuFfvyoXIleY1sXDpTNnz9jlxc/oHseGqMZH31T3kO5J0aiGvJQHFN6yDq4CCZG+0pUWhJhmugJSYORIt8bjLp7hkBXVGQ9HKdiOwVu+hklhhFRC+ieoo4h4nqQlSHWURiRUunuFJUdbqcSxwoL07QSdwwRN8KmTYEmdjjLvdoj+CH1BmOuI1H8EI6zkKMnsjDVRG9oiVarn3bOb3/rujpCqLTI3oDYqjcjLd91lduOgVRDP/7SO+ALDuIlDtfEJESkZRQ8WqCGEyVv4feO+L7Pck5fw1S4PxCZu8PFUtZqvSahEzpjmxfhbz+jK8UqO/JeVe+qLJMXLJFXPJ7WtvbE8P/W1wRLWlYJSy3nWs0Gm97OYooOr2g6AW9XoxevtJ8U6qgMwjmOqJ7bIHU+E2VpwocUmunKo1+yBCeny+6qR9J+D/XyJz7LtB9QP2HyPzvRTZNEJnjJeJMEHGtEHEsFTn5logjXxwnn5bcz14SNe+8lOxZJDtmPi7vPFJHeuh08qSiyJKx9cT5Wx9xbfinlL78kryhIB0U5Fm0/Kc10BIWh91vY4jVyKlKN3HKE/KVGMTpHC8llxEpR2SvIn98zdVEZLSo6hhxOgeKw9lNHM5q4vrKLM7pyIK+SM1/uU+bAUjI00ijusi2NH95Yaoie1YjK/sjPz6KfNIeeSFC61yONdXyoVKtcvsvEED/X7hmY7SMeq+hJXoeAPLYfZ4bNxzZth4pK06UZZdqyWJ7mthEFTnfSRqO1ImlbKOYDHr5vGLbXyfnmn8idlUvWeo2sTsnyieb60tDtAbgWw2ZeCVWJqqqqJIjSZb3ZEbaw1Is+yXzFrXuzQYt3V9lmvjbssYfkN+TFKVMGCq6eyVSNfuJ71vnZXGZS4bsUuW7kyKHTyUL1duLe+fxEp1UKGPWp8rMjaoM/F6VaSdVSXT8sWQ3Uw/es9Q3U9oXthL5/BORpxWRuVVF1C9EnMtFlrWUcudsWZJ8XdT5gaIe2CTlDpekFpZK7sVfZPGUpvLcU70EtFjTo0BWtOsgV7p0kz0xOpkUrkjDygYxGMTrLzSqxPOIyMfidCG/7kNUFVEdiFxGRK38rmqvWPuvq3zdVUUk7tZ+VUVSJiMZHZDHaiNPGpC6le9h2WJkxyaktARRf0TUUpN8MAexnUNUJzKuI5I8HTnaSsuHuuTpf581/H63ZiBR/wUy3r4FgUwBeQJEjUNcy/zEdfgJSc3ZKl+e3SJP/fKcNGgcdM9rjFSQ7DOKqOr7oqqZoqq/iahPiMt1Q1Q1WlyuFFHVNHG5iv8aOVVVJ6pUiCqq2JxZ0nFTkhD7ewHcvJD45xpKD1WtzN58WRLV9+RHdYmo6mpR1VmVjV37kzs2kcydNrHljxdR54moJSKqKuWHRVS7SHHlUfO3fC+K7u7ZmUxeZnnt2kZptVSVGZmqdF6nStSXmRI58TUZsmCJPL72kGxUVfnlSILEzPpcGiz6QRq+ulb6zxQZdVCVg7fKLfLNtktyIatEVFWV46oqZXcj5rUPRDK3iYweLDJ9lIg6XUT9QES1iVw7LlJeKhUTPeXn7Qtl25FakpOTLi+/+pBcyLgoe79+SbKvZMoLIybdKn9YJUlbV/bMvdBGyiEg7UHiQcwP0KiO2ZBhT3UQp/M5GTYCySxENi9CZB8iqxFXAlKQgFw8ieSUIBvO3kZW9SZ5w+RqUoSc/hAp+SfyVE/k2SCkmVm7x+7dyJA3kfNX7zyvQEXe3ISs2IA4XS/LkrWKdH0YWfozstwHWd7r7yNPVzTposZ/kaBNFESNQORxRF5qJqIuFlVdKKq6XRZ88pW81u9ZGdGj+V3PbcDvHevsX5Cy8iUiZX6atCUGERn5e6eY/xdHzptEUlVVSktL//xhor2FzzpLrwlvyIoVK2TEiBHyTdpcmZI0RVQRSZGVkiYvi0iiiBwSkWsiosq+KR0kf0lPUV+vIZI+QVRXwa0R7Obo9ds/nxfdbanTak6bJM0WLpPlR1zS/6xFhnXpJ89+XSihY0fL2FVn5ex1uzSanyPrKom38aKI/8h1Et/3FZmRUi7LVVWWqapM3btXvty6TObuuCYfXVPlssslLtc5OfDdEinKyhVVdf0+mqqqyMl9IpZTItmrRNSfKkdRl/Z/zxzts6SIqBViLV0mP7w/ViN+RZk4ss7cuta1wxvk48YGecKAjFCQniAjzcjQkDh5o3EHeTcsQKJB+oBUf4DGVODsK72GaIRZ+CGydj+yxYq8+hSizkXUxxF1HOL8Abn6IfJ+H2RrOtL7K+SXjYjrCKLOQy59h5ybibjWIxfHI5+0QvqHIq29kFnDkdbtkOOnGouqhoqqNhARk4gME1XcZdlupMSJzBVE9wYy9zjy7iBkWaU4qxjchGELJdATyXlD65wUBVEU5U/T4/0vtiCQGSB7fBEZpa3uiHSvbLvHRNRLsm3vN9KyQ7x89SKivo+oIxF1NLKkGrLIDVkzHSlOUkS1KyKiiOxAxN5RRPR3Uuz4X8wyJqpTUPRUlFsJqu9F2X1mlBk+wIOF30xkb8j7JOt09COZSIxAKSjBaCmPVkLiKhK+3UxcvUi8PC5wOeJdItpPxGjyuKUpVBAMBiMug6tyYa/yB8Mg3N/qztznn+KthTpWTVDYWgLP+8Nh4DhgvgaJ+6Bzc2gQDcYK2J5WQtqe9fhl5dG5XThXLh3HYRFuXFrF9pO+dIlrwJPvvM6x5X1pP2YNXoFRKIcWoLR8HAwmOLQOWvXTypHaGaJ2geoA/VJgdOX71cqpVjhxXM7HLe7OBAKnTqXw2qvvcGLLz7SqGoavXke9bp0IK87HtmYzSU5hBVpIz/uBwaDHWr6SDpMHceBLqPM0dHIDcwrMWA5fxsCgnmC+DtN2w/FqMGs4dJ0HQQMh3BPCD8KkznAxDWw5sPc0eNohRYWiCi1gWqdm0KoOtOkH0c3BHJGMTt8TBR0oexGJY5liYanSBE91CMv2vcHqLvBRIx1nuj/C9OkLOD/zGT5/NpUOtU5gm/AP3hkXjj4zjJwbwrrvNrFv20aqqUKwCEfv8/nvhbtF7L8fNAmHhNcrNckRraDXm6ALBFrCjT24rq+A0NPoT56CU6UQADIXeBJcw0DnAYohEYXDgBuo34PuMCL9QNkOvADMAMWFwl/Q1l74vrVYrVb5rO1f64Em9jCIdecgseUdF8ep50RNfVHEtUBETRbVuULUubXENau7nBwdJtaZ1SV95Sey8UyplDtVyb81eiaJXn9bCu8W/UWJCRWdm5ugMws+z4jPwvOyyKFKpktLw1ogmlKqWEQui8hF0bI/7lJFdhWKTPlpj7y0eIc0HzdGGjz/jVRpMVAeDUSadXlInp8xTqpWD5TN7zwj373+lvywZJjYym+qeQ9XXvnmgKpKhbVMZJrnre92u1VEboiqqlJeXiIO14U7RGOXyyVOl0tOJpyRt0e9IK+07yAjo2KlnbufLH9vhGwZ21lmuOmk7gPUs91+Wd4v1MkTfXSSbkMq7IjFgbSagfj4IL/NRLrokUQvZEm3yvPMCJGVn4MRJe7Oa3qAhIPUBwlAE7VrK8i0F5FfnkTW7kImnfpENu8Kkkuf6cRemixf7POVkc44yXJmSPk3OpluUGTaZDfp9s+35WtnhZzeMFUcnxhk31Ph2ttVXSL2UpHsg1Lx0VjJ+fRFsZ5dKWcn9pSXGxskyqgXk06RaO7U/v67TXfb5yH/8v1+Nl+QgSDtI5G13yDOzd4iO1uL6vinuByHRXW+Jao6T0SGaaPiZkQ9jRzqh2SjTUnmguTvRhwpSIUlQspf10tFAVL4EWIrHSY5lxWx2SbJdftfFGvfa1FDTM37/8diQn035OPeUXLh+2FSljBXrDmfSeo3j0n+nN6SOKur/PqMv2S8Giz73n9U1q7aIicr7OK81aLT7iCn2/Q50qakTB4vLBV9v+WifJIloSfzxPOrazJue4WstKtSYBdJUUUcLi1pbqGIZIrI1RyR7akiP5xMkNdmvSwDXvpIOrZuLyHufyxzPIif2SyZmZnyRzjlprjfz9vjFjELC3LkyWFVRUQkIyND6tWrpxHW4ZCKCoe4ykolOSFBftt3VEREUrPTZPF7n8n+L3+UOa9PkMnmfpL03VHJHzlcZhl0/zKnMt61bg2hiN1+Xtp+ZZTSM2Pk3XDkoUlIp2JkgBWZuANx90N6TkEwINxLuXbbVpfftbSGygbeuRlS3R95wYxcP4qUVyBOVScW+0D5eVkH+cQ+VcoqbsjBhUbZ2cpTXn6vpThUVVTVJUXnPhYZ4yuS97WIqorqsoo9bZ+UD0VKn/MXq2W6HN+5XYY3rCP757wr9uULpHTJ65I8Ml7muBuks7tR3IxG0eu0pRL0iGJC9KY/PlN/ENN/2GYbmpGTDZDx9ZG1/T1EndlOMmc8K8nTnpbytYPFfrmFiNpJxFFLJBcpHYpUGJDNIE+D/FjZoXwE0hYkvDrSR4d8+wziqUd2zNFE+vjRf5Gc/ykp77bFoqVpb9utplQL9RRPkGf6IB+PqS2z+3eXz3+8KNby30cnEafo9XqtR/PzE6Onp2CIF11cR+k8f6Xw/g5h8CPCe0ni1fd9GfRFrkxarMq1QpesuyiyS7Sk51tFZIeInLgusuKEyLLdCfLoO9+IR0xbUXS6P5TT29tbrly5chdiiogckd8VW/tFRMReUS4jB2nEdLlcUlxUJCIiRRaLfPPbRpn+5Ro5f/KczJ02Wxx2u5TbrJJVWioT3nhTmrq5SytfPwk1mWRRh4Zi3/uV2B9vLx95KLdpOZ8VCP4DSadeQGzl3eWLnd1lbuLrYrEhH3+BvPslMnwiov8RqbsQoTHCKIQIBCOCqfI/CLq7vyttPqgtiTQHcTci7ypI2nZkRy/klQ+Q9bltJfInX8m3fSZ2y2KZ85anrJroK6rLKXYR2a2qIsV5Ik8H/S5AOMsk78AEWYCmsXYHaR9qlj2zH5etG9bJoA715ccZY8XNbJZx4waKdc84se16W156cYqM6u4hHRoYJGwIEjsdGfAhUiMecfdE3N218t56rv9wrVMH0ssdsdZF8lpWkR0tH5I5w8fLkQ97iGxB5FqklK8NE/skxL4McY5EDntpyzA9QaaD7ADpY9AURG0qr/khd47mf8a/B7at/TthRLN88QSqeplo1W0QtZs04sUXJ2A2e6HNGM5gMDTC5VJJzS/k1ROHWP3xAcyFV7Ck7cXVfCzUMqGU1cCjNTjz7cTFPka3kAoea+qHv5vmWhUDlAAXgGolkHn8PFsTt1JYkM+p1Wu4lnwabquLE4mniI2ujZjdMet0D2T+l5eXR/+uXTl06hQ5GTks/XIZUz6eggDlFXYObdxAevJp7IEhTHruOcZMfoV3p73F9Jef55c53zCrUTv+8XBNbEe20X97Ngcs2luEOkADYB1QjtEdigsCWfdDPrnmUQTrf2C/QMpDmv+quGDDdihKBHs4KPO1MC3WPLRoYxbQ7dJCO5EJiqCZW+q1qg8KAIcdSkqhrRPa94KV5yAnHQ4OgoAZ0GnTSPaMboq3PZWdzy+Ggf3pO3geOp2BAyK0UctRRtTUPHQAUVWuXbzIuNhY6gGb9Dq8fXzwLSwipk4tej/UjR9O72DGglf5bHkxi15/jUkDuuItTkLbhDB2Qm9OnVnKV0sPsWO9HctDNr56QuV0KnifgwXfQmoLcGxFc0XahWZ69hcQjTYzvAp4E8N1IrHV3srMBhCUCvaq8H2RQrhZ0F+BmCtaALdVlW+pKjAFzQzzSeAYmi6kP7Cam+8U5K9ktv5vw4FWQAuQYrFTVrwSXZUQXOpppNLkLytn/81RnKguDxMWW592C8fz9a4lRPyaDAEheFwtxs07CNcVX4xtB1PkdoFVdj+e3KYphy4AOyrvOQyt4TbsHMtDjdsQ5dWEmrW7UCWsNnrDzWAaBpZvOsKSz2bzVeYNcktKuVcn9q8ICgri0KlTAIRWD2XSx1OwoSlVfth+gHffmktURB1qRvjSv1szcs8mc2TPIsR2mTIFRpzcz6rQagzKD0Fn0TKXabgAxi3cNHkf9BQ4DQc5tt7A+KE/sGQ/jO8GUc9BhUC6C+J6QqfnwSMIdKuBEDDXVG2WAAAgAElEQVS0A7cY8I+CKmPAwxPcBmuRZjxbgLk3mIZBRSx4REJoD0iuCV9uh7CG4BEB18Jh6Uswyf8n1HNTmNV+Oa5h39Jn0Hx0Os2Hvy12lLydt4gJgq3sBiNjY9kHfIqCEhXN2vXf0wDYeukGxYsO8UqtNnjvgWovT+XVwR2pFubNlsxEwht1xXWijLrqk3zz0nKunH6fzmnNGdXGxM4jUKWlG/uOKwyaABGLIDRN8wv9q7gIvIYWsyqAFGLYSqdLcHUVlCfCrg3gluvFrrNm9l3RXMfPADOBumhW1x3RBh8dWg7bOtxJzHvhfzpy3g3T5nzAiC7eRMaMQ6cz4Rdnoji50lLYGy2Eus4AHyXDoSQ8nE6GrxxCWqYNW3oJB/Zk4h5VD49QN1qGwsQGWg8Wo2rjsEWnuZAFoDXxM8ch++BWcqxOFv/8ORcvHqPCGYpUXOXRZp2xRjWlfh03xo8fS9UqYTgUBSO3m50KYEO5lcv77nA5nZSXlXPy6An2bNyCV2QkP3/zFk/1HsXe5AoWbprNa8GQXAG/lUA3tGgItztUeOvBu+fbuC79imK/xvHdJZwwT+HML4uYEFXEsCXQZBR88RP0+xFOJoG5gfaczdECI3QEEkXzcfXJhnOnIaYxrN8DEX7g4wfleyHSCA1UUI5DXglUbw7pe6HuZTjXB34+AyP6wlA32DI/gpZ7d9PXPxLDbTKGcAikFUVWBUzgb3ThLPuRjfHTWXk1i191ekZV78SgplcZsvocfSNCWDZtKgzty7V5r3HypXVE945F8fFA4h8i9vlnyfpyMme/WEpEuInwTxdSGNWGSQefY8emrcSOa01L42WmN8jC06RywQrLCuDnblHkOyyUWQ3YS7MfOLFnE7Ts6clAZzR3hzA0Z/hCNKnMgead2gTNUSGfm95LmpDyGvA+mtP8HDRXiuKb9fR3uYz9t9HQC349m0RUeF10Sikmr2AcZZXkHAzs9IWiYqgWg2H4+8QN6kEtXwOrF++E3KvoSyMIbV6HDsPqMNJbi1B/2qniUSEEeOmJ8NIWcpwqeKC5R5UA3y12UFxwjFNJ2zn62wLKctPRTLB9aTe6F3X8g3lpwssoNasTrSgoaC/GD0HlAHra3fO5iq/nkbjtCL7hAVSkJvL56uucz07kzLF19103r7eqxdB5fUmv+z4B5bOp/vkH/HS6HMebw4lPXUJOFjRpBV/kQVYXqGbQiFkFzbtFEajhApdB26eg+dYcLISoIpBAIx52Hc95VnDKAidSwSMLrmcq7Egy0NzDSR2HcLmGtkQ1pRvsXlKbOWsPEnAXrwJBi827aDdk6WB4JNSsAZZiC/HNh6FmbuVJo52CYsFkNvBF/w6o33+B87d0yqa+j1o7ncAJtZFyC7j1RAktJOmNb3n/CPiP6MyALnF889Ua2k2bxY/TPuHc8aOE/DCJX1p/T2iUk7wjNvba4MVON/heN4/t+xpz9tepsDWTzMwSSkruu+oJRRNHY9F8bW1oBMtDSy5xFogDjqK1pznAq8AEtFF0CjAIzX8pHxhR+Tmd/w+R87H20Or1V3ii2zSKsr9iyKSFHNuVhjm4FtYbZTC0I/57ziAf/ERA62gm+l7hhem56JKvE9i8JZ5vVqVDoVA928rmhDyuOTwo1vtQxcNBkw5eNPCCYAUwQAs3KHXTKnsomkiSsCSNI4vncWLP11TYfg/P0b1nJ6yGBnz72WTiYqJAUVgDPMQ93NFUAZsdzAZw2nEoZkotFjLObifn4hlSivL5/OOF2Gwq2cWWf1s3KSkpuHSpFNdoT1ODOwb60rLbFia+phITBK16weYMmLEedB0VWvoJi9DCCQUB/i44UAIf+GtkNaERKB+toV0lDD88yEm6zEXgaJg78SaV2t5wmgDSLtiwp1jpdErHAJOd6/tiGDZvJz5Vqv6hrMVASTlUd9Om8lP7CYvzylj2rRfxEZBQWMi8RwZhy75AsTmQ2S1DaPVEK0rSCii7UB17dE/8w8/j6cpFf+4b7E2akLfiGq/MO8jhGuG8OW8eDTq04vrE/kT1fIb1O0+yaudyki5nYotW+WhuAzp7J5HfsAE99C+RXDCSOP9PUJQeiCzljTfXMX9xBrnp/z4Eix5t9KuCNg81cCucGza0qBQGYDlaipj5QCPge3dQK2C5wEpfsJTAUoFuejjkgtEm6GT/c3I+WDqG/yK80JRDZ9Jh7uw1VHh588W7U/jwhefZ6hZA4zeWYDW2w8fLQdsRHxHQ3J+o8254Km4cnjuHmMcf4ulx1Sg5WMiGTaXs/mo12T//hCNLxbdpE6wuPck/ZpB2o5CCXD+6B4EzUBN5H0aLz1Mf6NXAj+qBYaRnppGVcQVXpV/PlctpxEbVYs3+JNq3jOKKxYcu3ro/iXqnAhaw63FcusENLMiNSxw9m0PSeSHDaUQpVzmzfxcdor3wN/mRmH5vp8nw6BieHPMEs+ZOo2ucH5ey8ggLmMCvJasZdSSPouawxKjF+j1RBYoDggErjYASgX0q1NHDELPW25cBtdGTjgelOLAChVhoQiFDQyAzJII9bnU5V2GjfX4xxhILhlB/jH5ueF7zQ3fci5gn1lA7riZGw511UA58lwbztkL1Ui1xVO+nYc2iFD59PxQ8oaFNwXlOIa3MxENPvEBMy57k/bSakmNniWnpRkDbBlhzvSjZfAm/lr1Iu+7BgnWJpOotzPziNYY0bYrbue38NH8jSev207VeJo0bVyGj0EFmsoWtC6+zc7UwsPlisrPO89bxyzxq90XxfxvFuIHOnYfgVke4evkCeZn3lnMFbd7vhzarKkWbYYVV7juBpnfSo5E0ygNWVoMpQZBZrKUEmfoIRCTDwTAj3RWVk+UwsSlMz/zzdAz/10bOYD24C+RW+u/Z0ch4EzGABGs90tLzebQKCGTVvG+wX/mW7CGf4+7pQ6p3A8RioDBpFymuMHoOjmXb0nKUKgk83LEDNfanMWrUL9DNE1a8DO37EPDM5wRaPLi4+gTkLiEquCqdxnzI4/XAP1LzQ61+WzmyHZCoB680mPnaCHb8tgLHbUFhDH0m0ivwHJY2c/huYA1qVzFzU8GpqipX0vMpK/aktGQRdnsdCi1l7D19gmhfGz9+uYTBHVoxa+E+cniwvCBzVq/n4fYReJiDuZjyEG+vPMYrj8/iox9T+KTp10z9VOXUo/DZRBh9wMBj7Tpznm10wBOrlJFh16yGCoBcFFpioA3epBJNAsn4otCdYkKBYmrgcI7l+4qTLD+/iuzD4F4Ir0aAZwoc+g2adHuTsW9NxS/QD7jTF3f5rl0M/zYK9ecaAKwYtZP2j/tSUb0ZDUdr4Tq6d4Xp8WVUvfwL8w8ksj21Fn0DMnnu4XI8MtZB+6ZgHgoFDvDM5kJJCGUnkohpUYQxIozCDUkcWH8cl/4Gfh3iMaen8vieQgZOGMj3326mSlgNukamsO+QipTD+FfG0f77b8mbAUr4Drp06YKKkwTLZ7TxfvW+3oEfmot6LtooetNd3csTjA6optOIWCcOJoyE1MXw2WU9g6q5+Md4qFgK3nUCeXFxPl2CoEdP6LUBduT9j8XaJmboHl+f65Z8CnItFJSUc8phxwJ0CIfM69CiBUicwogvcjF5BtIF0LOFfq8spFuNGmyt8RaOul48VhOuCBhLwcdHaxQlBVbefm4RbHgDWvWAQ+cgpgo8vQDmfgenvwRXCdXbTaTHyzMZ0dGL1j7a5B60oFHnLlZwOOMINa3FZGdpncWSj2Zy8mjCrRH0Jp788EV0bo3p33sA0XW8CARSnS6SViVwKCGYoyefxC3rOkcvpeDlD+W54INC3n3p6e5Eu3btWLx4MblJL5CX34a63S9y7tRC9hZF0qv0Il9nCyuXw2PLoEcDeN8WwACPMHSkU4UAknASj4UgikkBwvGiH3H8Si6NqYGKjfN4EE8iZvzZxQjOJ56nkdsKvMNh0XGFsPOQN1soOA+vTW1Ln1cX4xEUCYDr/DactTtyNiEbY2ESb8/7DodrOGzw4DKCF+/wkD6e9st+YktTOLUF8lZXUK/vXnqFt+TocW+smzJokPMZYe6HqRbhgyk2ncgeA/Bq1gWO7AOLGZr3xeHmR/G8lVzYuwLVB6z105myPJdGN1TSwqJo1rEVGUUWGjdpw4yZHzMmpJDoiGheTbhMP6PKKpuWK2Xt2rUYdTo6dO7MwIED2bp16329CwWNpPWBdnrYL9AoHAJK4JwJ3BwwYFAVetYtwNvUCtJCoMYGCLRpk8928GorE8+JHT+jOx7e5Si/3p2cDxy39q/ihA3G9WvNuzW9SUw14EjLY+XhNH6+dIQ3a5eyrAA2HIBFQ/yopVe4gja6utOTETN70lCBWEXrqXyBOIHThZDlo2nALhqgY6wveRWdOFtUClXboXAK+eVDSPw9QmCQz3nKsg9TeLklJY29sQOWclhweB9ff3OB0LQZXDqTeisY06B/PEbS1bO4rhffof+e/+qn1OsQxHen8hj/+iRCvcERJDTUZzHwGU+8LyzCZ+0GQuuu50L6fsrKapFhPf3A9Va/USs++mwYRcoRdmw/SNahVewuhy1T4cDpRqzecYlfpwnKDOjYQJtTxthrst3jOD1pxEnO4E9fzFwgi9oEkUg3QrlAPY5xmMGk8yvhBFONSCCTrvhQzumVK6jrDf2GQVmgDmdHhflLXCQhRDz8+S1iOk6ewnVqKW6RrXjx6Y8wJH/HhnIrRpMJecSb53+xcJx3yB/ah45DNW2x80nYF2Zj1vwVTN0Vja2FD5bcUOpaxxBjCsbz8FH0u4sYmPgTLT78P7Sdd3RV1fa2n31KekJ6SAgltAChhA7SRJEmCiiCCqKCFSxgLyCCvYFXEctFRWwoIqAiRaRLJ/TQIZCQkJCQXk7b7/fHDoIKqNzfN8dY45xd1tqrzVXmnGu+iUS3GWO5fnGfwJ2ejl/0GZoPb0XpymUM/TAXmwMGDL6GmtcMpzA+krDyKl596S3iYyP4osFVpNYP5KaktthdPgaum8vCHDHluus46HDwyTffMGfOHCIjIy/RCufIhiXprgA2RkJSC2jggW7BcMgFBwsgeUxtQjdXwODrIa42vLEGBlbCcmBQG17teoSt49wkfBrMwVlVJF/kW/+ne85atWrRrl07MjIyLvg8rmgbbW4eTou+/ak7+CZ61olC4QU4ck4y96SXAi88eM9YajVJxW4Pw41BDSDPZyEatDMsPVEdwN+AruHWXvE3oL2/kz49WpLQvisHvvmZM8e+JzDKIHTPVqqqLBeMjtCaeBVADOXUDgzhUEQoJeHBbN+1gRkPP8TxZR9x6mQR7vN8vOxP34Mv2h9KXJZUpYrfmTTveAXkLuXw8bosPxbDzY0d3NenJy0ffgPXmRw+fHkFNw5uwpJv0qgX0p7syr3/pjqpEwW33jiA2IiZnHAXgqMF7qRDzP7Rw+SW4Db3MuoTUXoS/MbBtEbwyC7o17gJBZwhhkDiyaeYKjzkEcNo8jlCIIHkk0YiAZwmChcNaIRJOrGcpgE12ETR7v0U74TaTkiKDMRbYbJ2kY+2LfsxZMgQIiIiAHCvWkPADeMxAkOY+/QtLHNV8UiDLvifWAtJq9kzv5yrRjXj8dn3gAm+rSZHfs2mXexqBtz3FO59Yfy82I23xEN5UD6R9eNoWLqHeJzsythLxkkvCVd0JLxRAlQV4RcTx+HQRNJOlGLbno4ZEcLwYdfQf/J0klN6kL5vFxPunURxgxTGjepM03HT8duwjgmPPkZQUADJR35gQRb0BXaYJvMWLqR+Yjw/LFpMUFAQAwcOJD09/aJt4sBawrtjISIB2naC07Ug/E4IioGhXZJI7VSJU2dYvm0xGdu+I75zAI7tVZbu5YPP2H7VbNqM7IJRqxMPT9vBjf8L7PxfIvk5SW7XlL3r/zgT1KhRg/r165OdnU18fDyrVq36w/PPd4D/rB9oEbmYfv1SKXJtpmlrJ1vKnWTuqKQ+kNj5UTzOKlzwu+YwuQxO1rBgC85SARZ6tQMLc8SLpbvsmZBI4Gvv8tOs5yk4lM7hYBcOfxu2uMYUuUIpPZPD9vUrqTxTRB3fUK4c3Ivok/MJKTv8l3LWbRVBVnoxvoxqmXswlsXE+c57ckTRV6NoEj2Gb/0b42s2iBlfbOP+tgc4ffo9nn8hhfCkaLYe+vZf1/PtV0OL+HnUCS0irqwp9YbFs3JfGFs2fsSAiZXc/BCc3gz0hpR+FsR9QlkQDq0gMTOGkDr7OAPUJoMjODnOjxiEUQM7woOXeE4AzTjJRkqJoSNiGzupIiW1FkvmZrFtN/Sv64djiYl/podn7ryP+rHnNPuBNw/9/X9fYBnw7n2PEx63h8R8eCwSjJnNwazCt7aIOS/M5Zd1h5n14A6C4sPp1aEV76w+zc0316Qgexd7Fx7Cr2YY/eJqs3YvrFm+nPiYKOq+8jLE9YHDhzB9+Si+A6UtDjOuZ3Nq9LmTUiOaz6cvZdmKT7hi6Gi6jRnDTc0DcdrhcP++vDLlRb6d+yXB1Y6JPzmbaZeLcQ89CEBYsJOUlBS+++67i7aJB2vP2bEr+LthS1o9arQop9RxmiYGNE2MxD/QwNMmh6kvwzW1Yuk4GAsEZ2pHCOhCTrKNVjNex3AGEzR51kW/dVnMGRoSyiMPPMro9bf/4f6xA/s5ffQQtZu1IDIykgZx0fg7HaRnWZJIN/DTrGV8KUjfvYiTuyAwEH7Oto4ldWoBfk4II4ljWIKaQiC/cAPl2RH8UhxMUucE9mLnGizVh7P6HbAYNNUf4rvVI7H126SvWsS2FStISWzEztNhzPv2e2xlu8k+BbiyKXCVUjMjjZs62Rk9+i7y3/mOUydO0LGlBfqTF+Lk5Pk2VBlYzmL/cg5JhOS/R/LHTrYkjsX+3xcoKosEAoiO6cXt90Xw+qPP4OCci86zVDPGcnZ18jxhbceG0LYbjLitG407XQuBpbw2/UMCd+Uz6v5nSJxiZ+YcWL7O0tbwCtxrwMxj4IxxEF4GNSpPk1AE7nBrPx2NBxubCcAfUZcqKihkH1U42YGTaCJxk44fwo/GOCIySa2Txa5f4OjhIvZvgawcMMo8lnu5s3Q8C2rFg8NOg4cewnjtNSa69sAJ+OCB/lC3GazfA7ajeH5I4/FfH6LSz05BVju2TprEnk0TePrpejx6qzg4pYAXjU3kBnrJa16XjgHdqdi2hlWrV9Fm3hySR98DKY1ocfg0LWy14Ia7oHVjOBPN6g1HOJC7mscfGUOznr1x+Puz/Z13WOlysf2D2Xx1dI8lQ7+AbrPMay1XA00fJ0+evFTX/51C8yHKA+0aBOFI9nB4E3QcBFHeJOSrh0KvZOADcFOPUwSHfQ+DBH7hwJe0ifZhlKwC+w66BV78G5fFnB6XmyMb9zOkby/yNi5nTbWqyDDAZhikpaWRlpZGckIsDvsfLQRby4Id+HiZtakOjgG3D5KDoGbCObi9DtXvm0BgsBujxIvL7cOLqFIWRbsSCWxlKX4rgM5Y1jQ7sSS/NYPDie57I7269yHnwGnyv/iYFgF5pFdvvbMzzpCdsYATKxewp197mjfvit1uxwD8HBDgB0fX5eGtdg775JNPMnfrZjpccZBvXjyJsAaPLCxejQKa5Ht4ynibqpYOstJSSKSKqqr1FB20Zpr69cJo07kmK346SIcGkFMGvjJw2iz9GMD1neDB0dB54BUExwzmky1u+ib3p/XAQp7o9hmZuS/TsC9MmGaBGfM4TGgJNQ1YkgfXxJWw/Ci0jYGMTKgyobQCfIkQ64PyQheB0YcJwuQMFZTRgErKCaESk0KctCDIZ2d1eQbtG8HBXRAUB9fcAqVfNsLePgl8ftZI6MByIXfiINRtRL8XX2RiQACe7csgriv3PNCAouDuhO/JYG/mduZu/i/NUlNZvyOcj+asYmNwLPeMjeHaEVG4Jk7i2H8XkYONWrnH8Pl1IHF4d/yLT7DycAaxs7/g1qYpNO03EEJTAQeKqAshYBRBsL+XJx4fRljNJhxJ82fusjdYO2UiS1wuzN9708VJgDOgBk899RSzZ84kDsts76I8cBqOXQUnfel0PgrFYVDig4ZNg4AHAT/uvW4b8CHgg7qPgm0DHJqI2ac18DQoDv9rL47qdlnMadgMAqICcHs8eM8bRCu8JhXec2qHA9l/VRdkYVlQVGBZr6SftnRuPicUOZqi6ixtwTKFCgM8YT1oHFOFYVjOq5tg41S1L9ojWG44TSxF8VmFcTMDcASQll/CV4uWUnVkJaWlWZSV8gcqdMFPC7bw04It3N0Hiq9IJMjpZukPBbQ0fGT0cDCq1zM89Xgc3w/YwPMTWtAmL5snPhSJDsiq1gdVAe+UwI1REOSGiX7QbWQMC/f/xpcfQmsbeE3RyOVjh6CeFzJ9kHXKGrVTgN4D4c6HoUV7IKQlh3ZtwVv4M7lazJW161DexoYzDF5fB5URwIMwcDw0c8ObuQ7OGF5K9oKfCceLwBsHoWcMcgLiOZmdzYA4yKw+DuEAcnATSz4V2CilkmBiySSOcnZRVV5Ktj+E1YEuyVBaBKbZBbZHQ1J1wwCl9esSnHUEW74BMTBhwgRI7wHhrdDRLzHCbHBlL2zHt3Hi2/p4irbixss3OMlRJV3cK2mT25fX/juDk0DjRo0YfuVIAjfNJ7dOOF2vbMCmjAx+3rmPxKmzSIyqT2hUC0sqc7b3eqFnn+Tf90FzXt3KSz+8xEA/F4bLeuHsQHoxCgoO5sFnniEPq37+Do3C44NaV8FeryXzuauztULJ8c4m1ubFnu+EiP3g7AMYULcJ0Bvsu0h4NBVsfYHeDJt88SX0ZTGnz+fjTGEhLTt348VfV/+jOH5YBd523r0dwE2hFhJ1YD07kQ2bYqs2Pj97JsUA9sx9n5ojRjFtyVra9e2OqEm3ht8RxhBOYzF3IJZaJAJYCtirwH5wH7u2/MDSLDt+249wJLuYS1FeEZThZsRDrWlduZ7mnUo506EL17W/mW3pA8lcd5h6uoPHJ0CQC1783IonYHX1nzeOQsBRL6cCdhPUM4q+JgzsYtmt7ooo5cAXpQQB8/ec6yz9+sED/aFjd4hqWRPLLGIAAUHfcZMBHlazmWDaPN6aJq23UHC9i4h7oMlYSLXDS17YO0d06mvZEJdWQJYNmkdBZTYkNHBj5sDOYxDaEE5hUgjUxEUUeQQRCDjJIokijtHcfoKOyR35ZdkR9h/Mp7kHfjkIu3NspP0E8WGQ0B+csWC3AYkNrL3FWYVAs8bg8Qe64jsVixFv0LRRW56a9BQp3ZpwJbAbJ7UqDH6eN50BHTrwWeBj1K+1gFfffJMGtcI5sH8TWSuOcPWANnS+IoWVa/Yye8Vy6s3tSJ+ba0NQOMZZSNQA/nCEY8GGV3B5yvG312bqW+Ox+Tl56eEdlpPc3+lR4K3fr4KCgrn11lt5ZPJknnj2WV566aVL9pUTDcC1A7on9CH/eA6F/rtQG/AZYBhfWcu44H7gzAPPdeAoBaMu1PdhLTvuAlpC0O6LfuOypLV2n4cWvlM8PW0a5ScXsmXPuU7ftm1brr32WtLS0v4Q5+w27c9avjA75HjB5mfwyIguuFv2IcLhT1x1HDtQUVLEocJdhITUw7lyA1HNGvH5x1/RMbU7mV9/R1rL5jTjnCTNBEIFFBeSuW8V+7avZv/2gxct51k6cBJig8tpZsDAoX1pfmMDUgwfjvBVlN23hdYPm6S2HYBt+1o2LoDvjl04HS+wzSvSDleQnw8VfrC7ErxeiCqA0ppw/zUGA6+yMfBeMXw41OoIXywCj9vB4qz6OGzXkVyvIz/v+4W6CblM2eShVWIAX7xcSEasSZOx0CgSVm6G9BehYzfR/BSklFmrieha7ZAnD6PW3XQKbUZT6tLBYSP29GmaV0GuCUFOsJf5CMXF0fJYDgYEEs4ODDxsKKuH6TeU3m1HcE1oLm3an6Rbg44s2VlJ8ZHaBEUHExUCgaFg2NIgMPqc03B8sHUlo9/4mSMS3XO3YSS3IDwhnPj4eFYsWkQmJn7YKHJXUlZewZiHetOzdSUNtx6gdPcKftpylK0nThPRJIpmLSMp3JXFqvIKbDkFtGyVSnhKPWv/bwN2Ye0rqpXW26e+yM7SXI55h/FQt+dYtm8Wg1qPYdn2H+nj158jvjgsyZ6FRRrk78f7T99OQpP2PPvo09xzz8vMmfNXgK7zyREChelQ41Aw3ZMrSK5XTO0IEeHXErvREsM+BgKOQuF8qPDC9AMQ8gt8tRDiV8AZFzi3QVEpBD9wQWntZatSTK+HjMJSbhs6lEVf/MRZy1C73U5VVRVZWX9cRJhYjBlRfX3WOijSCyntoHakuOPBlwmOaUywYScfa5ViAHF1G+D1eejQKIVIj5da8XG4zZo0SIzF9Hlxxsaz/jikRFgzaDhWP4kOCaWwopyyVbPYkXEx/+h/JIcdTuwuZE2WjfKD+fgOHif26HFizpST+nQCK0dlMeHrU3y1wTLjuhT5sJauOwpgRy7sPwFFkWCvCwGnDHJcFqhv+THIz4HayVA7sYotB47yjX8xTWN6sii8Dhk1NnNMJSQGFfDDXpOKu8BbADUyYdPjULs3xDsgrAiK4lsS3CaJuDotcUfEMaxWIzoGRtIoaC/ta75GXb+uJAeGEeWLY/vBo/gZ4CqF/YL80GLiyKMDUMPXkjP1RnFd5/70aHqSxMb5BBw5xazf9vFb5tU0qxNDk47gVwMwfEAY2VvTKAuKI8Q/EMPnodIvlJROjakXHgax8dhsNpo3b8G2Q7kYe9PIwEsTr4dfThUTHNUTIyKBWW9MYVv6AT4/VUaQy8vA1h1p2C0J247t7Ms2OFGUS3JgOElxzXHEhFkM6q3uWBWAE5pkNOSzXQsp9JWxb89agn/7khRnAj+e3IIDB/kqxNo49QcOERwSzCefzGZHVjTtGn5h9cAAACAASURBVEWw7j//YXP2X6X351PlKWh4NZSaubQLLWbbThP/ciiYbyfoyyoCI8shZx0cKIeQE+A8DDEHYf8pS7K27hhUZPLs5CKuvvW5/zvmNAFvcAQP3DuO3F3FNGtaxvItxwEoKSmhRlAobZq34sjxv04tY7AkllnnpVUmGNa0Nh1veoaI4PDfl7PnH80qC6tJmGGwPD6WRoZBVmIs9Ww2whLiicESqkQHnPuODQiy2ynzhLP9QCWFmdsorvj7U7fFpWCvhC37c+hSlYvPVUlkho/Q2n7cPMPN199lsvzk3zPmhahKcMoLhSWQ7Q+OZrB1k7WcjnRCZB0IagJxsS7O2I7w/cl0VsZl4hdkkH7iNGmnveRWglkOFXuh6E2o6AEta0CjHAgLhYqeNakZ0oj64Q3pEtSNzqyhhnEfoc5UbLZehIbUwb9yG+FL1lMruIiqI3D0OBRVuDlQXkFKXARXE0ao/5UUBVxPthFAnZC6RAXFsu/oJjL2J9Mjrh8RMTVY74SmiVDgH8Z9S20cqGHQIy6UAIeBER5L8xaNqRcTBbHx59rFbqNRwwZ8+9H7v6vCIl0udueepnm9MHJP+rH01FFOAJ1aBHPb9REYtQyOZxSxbvcZyvCRnnOCBk06Ua9VQ2u2jATffDBqgRECkc0a0LI4lfl7PiCjdAc+xNqTURRwhHxNoynXk1h3KKeKvwYKCQgM5P7xT/HAIw9z1ZiRfPXUQzyCpRa6FJmmxaRJCaJdT4j2QmTtUiJSCnAsOwBtXFA/EjLLocEU+HADxHmh+3Owai10eAFH8XLq9fo/1HP6Ac1LSvh+4fe8+MwkjmfHwIxzsMrZuTkUlVx4f9fKCUeq156dgehoCDgNve68isCwc3LlIKxjOE2xGO3sjNsSi2EbnV8IGySH/7FQoVgRm9erSfuerfhpuddSUP0DOmVaA8jW/fBlhpdAvAQGOlhxwmupLv4H8laBpwp8XkjfA+E1Ia82pIdCahaU1YM+iTDQHcm0it+ID7ARjUHdYDe//gCeWIhKhzNfQEFH6FwJTQ6CPQZC+rQhrfgIz9S5jxAiCKMEJ89iYbo0r85BGLaQuwlolkToroeJzLdsnrP3mYR2NmnbwoOPrpyy9SOVUxx0r+KMLZVGgTdSu/4CivQbUbVPsGhDPBGGg29awulQqJUC7qB4DprW2VEDkNZz182LOHFmMw6Hg8WLF2Oz2WjSIpmXv/mOgcMeJoOThFJF1ektrFpip1F4OXlAF+C+Fo2wRdeAxZBZ0AqTo9QHMvOz+eC9J4iLDqdJ204QBEYrLMV3hBX6PduPn275idMfehk+L4coszX393uUxrWuJLWFkxf+6wFuwA4MAOxOJzXq1WPC7beTWAeufBLrvNclKD8dHhoLfSLANQvKO0FAjLXnd9QAxy9Aw3I4GsCpFxYQ++Dd2Ha+D6t/tHRg8+bT6RK7rcuaOQUUeb1kFZzm6muuoHWHq0lISGDxYgvFuspVRemfxaLVdNM1sE+wv9BahYxuDVFu6P5YN0Jir+actav176xa0a/6t0b1b+jFy/QH8nfaqGHWJHO32H1o/T+Kc9ZDQ6YLjpfDiXI4WmxehlXshckHlLrg9GlLbVOWA7tDYb8TEt2QfRwW5bvZGllBeFAlO6eWceRNUdYZ9DH41oAvBJ4cAKGHIawENsfAqWtNpvovICxoJfGMxkES/MU4zI7L5U92UQl+wU1ZvXQlB7IhcBs0tkNd04MRMYCVRht2Z7xNfzOPjiFJlO5aSljlSdr3TuHnRfNYsvMAd9/Uml+3rKeqfQKh0fso9EbTItBGbRsYRgHvdb+BactXcvBwOk1japK/ZQkdB9yE3W4nqX4dUiNyWbhsI42BTJ+XU2fyyHF7UWgyZ8pPciSvgl/X51Du8FC/ZQmt2pTjczjIPemhIj+P6MCaJHVtQUBCMJUnwFEL1h2EuJrgcEKSfxKNrmlA75uSue3OBAYMaUCHXnaWPWvy1cEeuDyZOJwBDHv2Fzp1jSXt2Dx+/Gg+EW649jh8dKmDQk7ADkVBsGkvpKZAx17gKYewNuB/JRiNn4b6e6BZPRwnduOoKYy6WRQH5+A/cDxGwXyM+mDrfOGZ87LclJhYpxt8hYUUffkVYWFhtGjR4h/F/XILjBzXl86da5MCzN4FLQdDaMRQLGG0tRvdzjmJLVgS2LMCpW1/TfaSlJQcy+3jb6Bjrx7/Kl4x/8ydxDkygLr4BUDfIdad4DC4otcf3/JiGRl5PXD8AJywQdUuyD0MJSWwoQbsb1xBYg0vtTb7yP8c8jqAbyY4/MGdA6/cC9d5oMutMGAI1DkNR349TWpwF6IZj2UvVeuCuXQGBGEE1ufntaWE+Kfitx3CDDg2Bw7NS2DrhjMEHZxDHXsQwZX1OT1vKvbSDwhpHUKr2K2cqFxHQ88HvP3OEJy1Qlm7vpTNVfWo57Kxao+Xnw6VM7M8mBd/20elpxCbzcZ/Zn1CXPurWLXWaj2/gCD6jhzPq5NerhbLmOArxf9MNhGF+ykAluaWkL4/j8rcPBI69SU5ug+HDldy3Gcde/vgp484/PMaKKrCvzGUlUFGLuSmg7kJiAW/L6BLfAD13QYr3hF3DtrGy1vvobjCGqidTjt33NeJqspAfl36OMtXLaD9KJh1CeOA3xuxNkS1hxv6Q1A3OJoFm/fBpm+hQgbbpnxN5cRiCDtMQCMfb0/ahruzSXBr4NB3MEz0fe/in/iffAjlV1Xx3h4LXbVdu3bMmHFpCRdA/hkoXbuBGVMG8fmuBkz9ALr0Ar+AWCz3SHb2spaGeDHwUZm3DhXl0VHi7Aqgyb/MpzPAoG7jcG4fdj0Dul/zL2P/A4oaj+H046r5W3l87pXcsWwVR3ZGsPjbd2lyVQuKCiN57O2+F4zqcYN7O5aB8BewIh32nLR0pScegKW3QNE+6xk7wLcDpo2A28qBBlA7HMo6gTsCOs4zWcR7BJCEdYT8wmS3OwgKb0hZ0HWc8tTFFtqUFbvAdxxCf8pDM+fBTws5udjgP1+tYX9cFrYaTdj88ka2vrebUzlu6vUvJuPMWhwBnxKVtYvognISCk5QVFnKpsQArgvwZ/kuy7zTNE2uu2EwT7zwKvffW21VZtgIikrk2hsG0DjE4gQ3kGV6yHaXUAtL97sLOOEMI9HrorgklxC3Sd/a0KMJ5HpPk358C5UqxQ4Ex0PnBNi18lc89d2k/QY3BUOLa1+hyx1P8/isZ1m07S1y9bVVD9h40OhNeAT8p6yI/SuHM/b+HXzzHXx2cQ2HRQKSYddemPYbjNkEr30OSV3g8DY4tVFM3ZRBwWAPLCmH68V7eR5euRLcU4HSTKZcA6su4aj9ksw5DOgD3A1MB4ZXX4+ufu4V7N63m1kP3URISAh169b9mxJZFjyP/VjMd6O/4LfFTZn+bhRn9vTE8IZQDZtLA9oQghcDG/6RrSH0v9TIhHqy5qaL21RcnJLiG+BzOSkNqUn7q266jBQuQSVfYJ84gdHXtOTTg734bswcsm++i+emvsOddzfk0D4Xu7bEMeezWURdKH451hq/KZT9Aq5TsO9JyP4Cio6DzwN1W4DTH15NgZEJ4A2ABongbAFFcfDeg58TEAPJXEcOi4C2l8xybLQf113XFFvdq3G5ndR0Q6wffJDjZsmSYuxLjpKyeza9bDtJ+7Ul78zO4GBuNvG3JTB9TQzpJXbGDvDx65QvSN/9CT+vTWPigVwio002LlrDSQNSUlJ49YA1eJfs3cvx48c5sD+ddu3aAWDYbNRrmsxr31qKeGEZprix1lAHsOb/nzcc4qO0AlL7taFvj5ocLYa5RyGzAg5kLWT9gv2Ueb3YgyDBBleO7EjXm5dy/Z0tOLGygr22uzAykwgoO4mbBUAFBtDbbhD0bCpmlY/c/5zE672KfX5FFOaC3985pogHvNbZ1JJOkHcIrr0D/vMlvH8KpqXDPd/CrLdg7g74+Bd4+y24dwYEPH0zn8wzaPQpzHvzEt+4lN/ad5PRpEZR6p1k6MColpo9qLZqgBKwUJio9r8ZHuin2rVrKzr60shL54fnO6FO9QI1pIdNmXvXSL6zbqR/lqo+kcxR0oqlks8nqVDynEMiuzhVqCrzB2VOHC5tuEtaPPwPT0tKTmv6+9/rugFvqlnjq/5xXi8dDGE/IRYVKvrZ18SCEnHNMvn/eEBDfo3W6ry71fqxODVoGqoPl9yiBz755OJp+Vf7lr26+v95zxyBqEczdGIaMu9Dnlw0fyd6yFdPH+p+rdU1yi+aq8Hbn5ZHB/+uoiRJefml+uizFRp190tq17qPAqqdM9tBIU5UIxhF1rBr7G299PwHbbQzfa687l819Z1kRceigXeg4FAUOzZAw775Volz1+vmPWm6fuECPb/VAogqM00dP35cWRnfa/bcWaoLiogIk9z7fs9Hbl6ennzwoQt6uQ/HwiZ9oNfVyn9noipuT9WtUdazhx1obx+7jjx7h44vOyl3uWS6pNN7pRMZZfpp3gmFhjUSztpy8pkcBP8h7Ub+LVVUWqySSlNdJ2QLasrhN0S1+Ade4u3VbeSPbDWQEYAGXoOe/BotWICyslCP29F1d6HNGSj5VVRzICo7hGQG6+FBaGVmpN7ofplOpcsX3KBfett0anwrta4RqO9nPKPRtz2mabcmK/hPmT3rvv+fdOheoGQnGv3iRB2Y9oG8ubmSvpe+GqvuDWLVMTZE42L9NTm1hmbGxco3IFW/TBonc8G1F+hi5VLFU8qeOlo9EmP0ef8a2vWQn+5s5a9dL/lp4+e3n/fufn3202165Om+mjeli6anog9AHf9nBo0TUTeKCaVir6mgQ269WlWsfPdkLd33gOq3aaWnZq5Sv+uGqKTwR3300RxB/IXTCuScU+TzwjRQ9gfINRyZS5E86FW3nwrM3SrXM3JpgkzzY+W7P5XO85d/KfL5TGUezdJbL89Sv05DlFr9rYTqAKjn1eiGm5xadH0rzXmzsdoNuUkvTbpSH08I1K2TUWA4sgWibq9OlvPdNfI/UqXpx49q8oYVOmRmar1p6t4fCxQbG6HwiHDZsYCLUlKSf89Hmc+nzzesUXL4X8ttVIdJt3XVnFu6aNWDzTXqypqa+dFHKj11St5d32rx0s90Or9ApimlfSZVFkrLvpYqyqTPv8/VgRWb5J/4huJ5RvC1DCNZy6Zm6/SpfElScalPjfrsq/6m/98zZlPEvYj27QRNf78feRsKb4MiI9D27ej9N9CLn6Mnv0NNn0Lfn0QrNqLvn0JF+cjlNVSaP+XymNP86BO5i2fL+4y/vrr7P4pPvV9nPp+uqk3HtWPhjr9k+p9iUjiwXNUnBQbqydatNKN/nL5sGKwGwX6yge4FNQDdakNXgtraDYX4+ykh2K4mEREaFx6uxyLC9XbLcD3cKlyTa/rr7Wh//ToqQvvujNekpGDlPNZEu65Fz6Q6Nfv5u6q7gVdV7u2aNe9ufTV/rO6/vac+fw3d2A9dBdrYB7WPuRzmtAnjVdFB4nkp2CdNkakbjp1SSNwU2drcqR492+qnnyZp2LBkuVwf6d133/tX39g+HG1/EFVlItONvjZRiTJlaqikg5IqZKpKpqpk4bl8YZXY59Wu0zslr0fKP3YBBvVpZ1qabh1+vyIT2vyBIaAaPdqJnnwkUh3b+2vRkntVUTFZrsqF+vaNREWFWe8NejhAjmf2qOdvBzVou1ePHXZr0NZ8uU1TxZWe38vhH+iv2cu+UGFh4e95qJS0+kS2ht18z0XLH+Dn0FuvjtLcR/ppzQ2Rcv1wnab0b6Z6YSH68bWZchWWSZI8VRbwm7tKmvGbNGeRFB35vrAFyyBAEKKl7xVpz7q98q7ZKkk6U1gpm2Oi4B9Cj7RGXIGw2zWis13dGiNCEbcgxqLui1CdDigoEO3dh+o3Rgc2onljUcVWFBmKbpyGfD7kmhd4ecwpt1syPXKVFKh5SLhKlxXIrHJLR0yVlfj09tvbLnu2OdsBnIYhPxvyr74fDGoLeglUBwvhuV71s/41rpUBak+knKBQA71mWMAzY0G1HSg2wF/Dkppq3ri75D06U1Wb3lX5rm9UsXzm2e6o97/7Vlfc9qi+mdhR7m/R5OvR6sko7Q6UUuNyZ08/4YgVV3jkL+n6k5K9tqmY2Rn6qPxmlZffrQKPSzsrcrT7+CZ9u26v3nzzzX+c/qTuaOtNaPNJ9MYxVOJdKVMzJJXoHJa4qn/fkMwqucq+1ROvjNDcrV/oh48nSatmSJnvS2X7/8ig3gr9tGKrGnS848Lfb4iccWj6c2jZ2w61auSn9m8F6KXXe6nDc4FyhCB7JEr+YIHqzvlWE9w+PbL2oN444NNi08KRKSop0dSSEpWWlsrj9cjjdetQ1k4dqM6x1+fTnq1b1S+11QXzEAX6+IX+WjSqozraUesAu2Jtht6f/pa2LV2q8l27pKoqSdIHS/bqxUcm6eXrX1JocITVNiDorYFNb1OCf4iCAkPUOXGWPF7p2x8KBSGCPn/bDjFd0dAH0YP3o6YTUNxdV6l5coquvRfV6oaojexjEC+gXr+i1NfR2GPotd9QylXoxwz0wAxUWnlYd4y1acfsy8bnlHxejz5pFKbKPRWS15RcPmlNnkzTJ48nT8c3vqb7LpNBwUIPjjnvug/oHYd1z8Da/7QgQPVA3bEJDDXgIfU5O7JX/56FHg8ENTMMOe12dfB3al5MrBZ3b6XMMd2k336wRlevV1Uut7zuKo2+Y7gcNuTnQH72czNGWhpKSvqXs6f/LeILUzEvSJleqVWBNMhryiOXthw4qFqDn9GQcbPl82XqSPpx/bBgmUaPu+8fpe/ogQ5+iKaeRIXekTLNfFn43+dvxE1Jn0nmMXn23K/HHh+gjkNtGtHcKe+7YdLWJ6SVC6uxRM+PZiqreKc+/uAVXV1v4F+/b6DWfVB8klVPBqjFWPTLTJv6fYWc1cvRqz69T37vVmhIzvd6aPcejd5tqsPExzTt1enySppUPYykVxRr1JQr1e2K5nrrvx9o24+bJEn7Dh7VNdcOu2gdOB02vT/9Li1/uZvebY1SgpHT6dA7U8bryNb92rd2q+644kHdN+puRdVtotox9WVgaPz0Qi35pkIVFS65qlyqrKhQRUWFqio9Mr3S4ZVnrPYj5pJt0G4QevxT1DoVJTyCYrci53KbPj5u6OZb0Kzv0JAVyH8tohjZZqDJuSh6M/q8En1ahVKOoDELkNfnrzfHIvfuy2ZOC0DW53afg4UvM+V92ZSKMqUZnWXu/kZ50wdrUvVMNxH+MbOmYs16Z68fAYViLY//jOh8LzXUk4b6jisURoLuskzbLxpCQc2qmTbSQFfZDN1it+sJh0PvNgzWyKRgXe1wKMEwNNqBDi+cop49UwVo8+bNatGiyWUMNoaIjJYzS2r/sfSSS3Ju8skxfoOCo2PU88mntdy7XdKHVr36fHr99df/WdpPoLsWo4JKZJovSTqh8+EILRojmdPke9+hH2439NhgQw8FoJNPIA3xk94ZUS1g+yuZpqnfMrN1w/0P/2GwPJ9BAbXvidL2oYI9E7RudKxKT6GaLyMCkFHHpg/LyvW96VPSOpcilpr6yOvRmK9flMPhkM3plMPhkMPhkGEzZBioVoM6Wnx8tTbs3Kr7vvhMvZ54SnePv/Wi9dDGZujrkberf+s2WjB/rvZ+PFPF+9LUrnUrOex2GYZNNiNYYOj6a8dr+syNKj7lk68a51impDWmVFIp+aTSjZJjxJm/r/8UZAxGNjuq9wiqX4lwIcpRaxeq5UHhPuRXhWK8yLkWvVyE4rcg0tDTbhS8B+30okd9KOZZ5HajFz67bOa89QKN6JJZsVo6namsG5LU32boRgPNx0JiHoMFoQ7o9sSWWpjUUVf+qaA1sQRIf66ARqDxWKhTYMHQGVj7wbY0FUyuntmay85mDaDwL2n4gZqDOlVfR1anCxZS1lXVaXbDggfvG2QJp2yGoSZYaFCXh7JsE7aBoscYGZOlxoelhaUSH3nEHfm6YptXPp9P5u/oZBb5fD5NmjTp79M3EAPQ8fzeWq5H5dYnkr6TJfz5TNJTktle5luG1o5BYXb0xh3It8EuczrSG7UuypgW7ZFpLtGmQ0fUe/gIC3nsQnCBA5GtJrLFGhp2F3r/I5T0FjKCrOeGzaaXXWVq8v0J7fSZGvGfQ5p+1KelXq9+LK8Ujf86M1qMaojfw6Xr4uzqxjAM2QxDNtvF2stKt73NJrvNJpttkGy25rIZ1vUIe6BaN6gQ9PjH7Xz7GLTThz4z0SATJZsPKdzsK4RiheqZ6F4TjTVRn6/Qg4WomdlTjrl+YhW6Ix3d4kMDfWjMV+j5hZfNnBfQXZimVHpG+RMH69HG6LNwZA4L1MquddUC9ABoRNtr5BkyXtNBd4Dew8IsfNCO7jTQHbGoSyAa1xJNDLXwFP/MrHXPa4SRoLrUkM9nymZ8Ktc3UwU3y4mpe8n/PY4/FsTgpSq3KRb2JqAeoOTznjWEv0ih/11wCG5UcGysJpeYun6WNMtlqm+OqROmVGXm6Fj5Ck34+gdNnTL+D7PW448//vfp949VTFu78vIf0GzXVLlNl/LM0TI1WzINmfPRsfvQlQaadD36aTAWsK+5qXra+GM7mqYp08yWzN8k09QXvl813vuaHpl9twUV+Df5iRqF7GEouAcipPq+E33mqtIg09TQo9LrpqVSMSV5TVMLPD4NWlktGQ0KFP16/55evUZ1dPuDN4uagaJN1P/QDpcO2z54Tj6fT263qXseK/1Hcdr0Qr8eDVOuGatME20Xel1ogInCvYiDqOYZFDgbTTqOFguVmLtkmqZez66t+79HE3LQU2vQg8vQbevQkCL0asb/sOe8GHnyTyjn2XiZa5A5H63oZxWiX80Oyh95v8zX79Hym6ZqwZARWj9khL4OrqVxAVGa1LyuRsXWUK/ajdU5KEStu1ypgNAw3Yg1a/25Ut5v8ZSewZD7ydtkbi/WiEFZqmv46cP6pkDV4bSCqa/B/LMZL4k/qn1S4cJLucsJznAxqFAhtcbrRVPaakrD86TYeaZ6/bJd+PVRytBJWpjn+kN9njZNjRj7wN+nf29/9Rrqr+KS6Wr5TKAq3R0sxvwBreltSbofd6LrbWhWD4c0c7L+PMiapikz262K139U7js1ZOY1krlvhHwytSL7Vz1+fKG6PfP0JfNx9SgUEomOHkW+Q6jufEQgin0BXXnPfbrlhE+jV0tPmNI1ptTf69Mz76zXpDdf0e2jJ+qFn8r0xFvvatz89fpkX6HWmKbe2LRT8R16q1v/1v/fGBPOrezsdj+NeC7t7+PURHREGMhxo6HuR5P0qzlaS80rdJUXBRQjBqOI+5HfdWhNGjJNQxbOuk+mmag929FznnvU8hY/vTwTzS9G4w6h1t84/++Z02rlfJnHntf+AYPUI3GAWsQ+oaVTfpF5eJN+vKOnrrPZNOeqLtKCt7X6+Ve1e8xwLUtN0GfdDb1zX2tNGxGlYUPuVEjYuY34+WL8cVh7xtcDrtYToc/JPOGVTMn7jfTmSMlmk+yBkv1WyTBMGY694h8y6P/XEBgrxziPmk0zdcMP0npJz20oUlzXXzT4l4/06o6Pz1Zg9exlXa1ck66OnXv/ffojG4lEuwqLCuVbHSDfu2j9GDSsuu5aY6E/D+zoJ9/qb87NmqYp0+dT0ZFjmjN4gCb2R/+9G30yK0qf+Yapr97X45qjm/Sw7szqp8RbG15yidl4JHKGot53I2c9q/MaNkOdb3lIr3h9etyUFvpMjVlgymuaKjSlKlN6S9I3puSrDuWS1laHoyeP6aVp4zTohlYyGsaLoP8/bWQzDPUK8Nd/v1wqUkf+7fvhNyVoqPdtrTC9eufnNzToOUMf7EC9xiIeQnQ7927ywyj91CbJHCMpSPIhbUQLN6TI410nKVCHTfTqanRt2g2Xy5x/Y5JTKrl+zNGuzz/W92tN6dBBaf7XSv/8PX17zTAdfW+Gyj+7ReaeB7RqcjvtmDtDS58ZrlcemKr0yVPkW35An7/8s2pGJ/5esAeCDI3EWqK2A43EoVQSlDZihDyz9sjncsv0SD6P9Nv7UvaPpgoLfBpyd4EeeWKaaDP6D4x+qQpPxRJigSWE+qd62ksHhwjsIx6IVdJza3XCK90raaikBabk9llqgyq3Ry5PgTKy83TsPGT7+5+bKkf4RQwUzg+DasoWaWjcE+j5DpbUOgLUGWtmOLvvfqF+kNxHf5XP45avuFDFs97WmyNSVDMcjb4aPTgATX0RXf9VgEapmx7VVxqnxeqsp5Va0FqRw7kkgzrsyHkegvSz30yQ3d+hrTluPbzRVJ2Vh7TAY2rYb7u1qcqj+flVOlJVpT2VLn1Y5NMPFT7lVZfdZ5r67Wi22r38rVrf+ZgaN/GTw+lUYpxNibGGDJtNtrP7UxA2m+wOm+wOpxwOm+xOh+x2219kBn/tB4bGPv+6KiufktNhlyWpvURd10NGf9R9NBpR1lPjS9dr4vcTxeOIkYiG/MWia8tnyCy5SvIGS5ORSpyS2koqlMfM09IiP4WNRB7fx5fLnJ6/nTx/p6yD0o8zJK9XrowqLR73gb68J07l65qo8qsW8i7qq29va6IZD32kzVMPquxIieST5t3zhhKCrf1FAuiXvldrTFiYnrIjf5tTj8TPVm27v04NnakHArpqX8dRKpzgkVnuktI8Ms9UqPS+1ZrRJ+b3hgioTuvK8xjPXh0aYAmIGoFuwNqD+oGGg0aBov9PGDRI+L8qBrvV7H0p0y09KSklV7p2jfTJuo1y3vmYOj71s55fnadNf6rKESNvl81m/9vv3NgPFY5HjvNg4xtVl9cB6gfqDRrh76ctt9+o+c9coyVd0U3VzBsVjgb2QVffiAa+FqRF3ghtM6/T+3pC7dVb6Gaxt5HodXEG/eUlQZ1s8QAAIABJREFUtGE+CqvWDw9/8Do1eOUKPXZgjbJNU32OmvL7NE/2PovkCLpPhn+QbP5BComM070zf9Zbn2xXlscrt8/UrlM+TVjp0RFZsujVPlPrMg/o9klPKmVwN/V44BaNHNJGqX1S5V+3rgLufUhvz7lXL/28WzMXP6Cp6xfp1ZfGqWXHFvL3d+jsKqr9BfJ9m8OuitJV2rxyiqg96NKzrB11vhXdtR6FPodiv0WRe5DjA0QzLFO+P8X5th2qHI58nyJzkl0qPSXpfkn+erHqHT2y4Abd8xZ69mTXizLnJbFSqj/072j7CnYv+ZjM7gOIXPMbJzdvoHuHdmytiqRG/T60D++Es22A5VcyG75/biiPzfmBE+UuxgBXPNKRDg8tYf5zLViVdQ9JG9/CHPoc5UVLGfHsj/S0e2Hxz3gXH8LZuAalJVt567tPWQak26GxDz4DFmI5olgBtDEgUdZRt3CsM6HrgAbAM1jo169jeTdwYmEmmljnOv/iovafUo0Q/J98irYZzzKiM3QdAR8LQvbC25+mcVu/vUzuexuxnPP0dvYUwtZcePiOoWxYOg/p7/zA/ZGcWAeVg4F9TgfZHi+9/MEmJ63bN6Xyt138l3P+uMIioHMPGNwewlOhql08frGBzKUeiwjCq/34vsiBl8stS/SLVcYVwCbYkpVD39feo6BgHwc+m8smGfhMWLERYjvDj8shxc9L1K/byQ5YSpP6idQOq403pRsVbj+ebAQHfLDeCZ4MH3tX7CGxvovGEWEUHtjNDwedqGdrJnSIJdDr4/CKNF78ejYZwXmwJIValbMY//h4jhz4lGmzDdye/RfMdGhYGF0dLpadceGz2cG8iJcMAzpdazDlTRvR+T7qd4HFW+G9LbAlHVwLuKhbv/X3RBC9tYR68wfgrPk+OGeCsYkZ8xYTYzd5cRYkPdGABVcc/vdARpdoir+lokW/UbptO4FtanC6soKC6GtwFdSnWQuIbwjYwVvsYXy/G7FvXMJ6w4NTMH1mS1p2noM9OZnZH6/gpKMB4xIKmDTiWa57bDjxu7bgTLqRqGH+uCc+yvdbDfLz1zMyGCKawbF1sAqYiuX4YGAkTAuDdzOsQ1RPYDFBBnAlkOAHzgDwtwMu+ETwhgkd3PCjLI8MOfy9q8S/UhgEvULcHfcxfrILZQVyVZbIagrzcgw+6Qo2H1S6vBz3uTFMUdvuR3CAE4cD5szbybPP3MPRg1v+VTMMBNwh/pw2nYy69gp+mL+K5V437bCOXyUCfz587wyDPu3glVshd0gw7wdfjcPRjjIWsU2byAe8X2BBMx8DvOAwLADiC1G5y0VYmyimry/A63OyarfJ1S3LSPIPpW35GaoCw3jXK5qE+NPQNKnvcnPAsM4IH8y2sfuQH+P7W3XfGOsk00GswcQGtD60io1HfuGdtXtxNbiet+M30bX1fVQ6DXzmCl4e8THvr9iP6yIZNAyDI+WnqOX7lMH13+Ln8NpwKO3C78ZDl97wUTI0uRu8YeCtsrPgU4PJn3g5kI11uPQCFAhsmAwp0XdgD8/EGFIf/OpA/mReuM1L0lg7sddOpLcx6cIQr5de1v6P5JVyt0i5aVJhllSWf/4zU7t/2qHvX1mgpklNNaSRTXcn+GnGvR2Un71aplltvJ2xWwuWbJJpmvrlxdf19qihKpw2VE9GBOquuKt1T02b3GOR+TbKux29CRoASrUZWh3tlKe5ofRa6HXQN1ji3V2gfSDTHz3lQIvDDekGh/JvMVR+Lzo1EN0WH6i2TkPRxjkpst+/Xd6G1BE371PLkZ+rqFLadsCjO74s0wM+6Qe3tDRdGvDGboXc+5YihryoIU+lKe3wuSoads9kOYP+uUohEJQQ9/+Ye+84Kaql///dk3Z3NuccWDawLLDknDOCSDDgRUXEawQxC+o13iteRbyKiGIWxEwOEiTnzBKWTWzOOU7u+v7Rq6AChuc+z+9Xr9e8dname87p012nqj51Tn2Cxb7oFnnnsXfluohIGdJrlBgMOjFx5QX+erSdH13DkKemI0//p7P8/cRi2ei4XSoF2WxH+jgR81lE/zDajhlvpGs04n6FBfqArC9rEN3s14Rbd8hXVlV4MFO8b5gm0QsuCEZ3Yc5KcXvyI7n3eKnsTc8T77vfk+HzlknSs5/Iwyt2ycVGkRwRWSMi60Rku2igWpGIHBaRh3LXyd6a8yJOq1hbqqWivFT2PDJYYnx+PxQALfRpfMFdSkqOS3Z29jWP9U5F5u5BXIKIeMjZHf7y0b0GWfWUItOHIPprxOP3gNwIsm+GXhoK0kR1vSsir4p87S7bbzfJxqKBoqq1V3Vr/3eVs1pEKq7yXZkq0uqSj5Zny39e+kDemRolix+YLNUnt8uyZ18Wm8V6hZNUcbmaZdHc4VLz+Sip/WGBqBvCRP3aTVpnK7LWhLwC0sFkkCU94sQ2o6+cjPWUZXrkc5C9IFaQVSAbDYh1HCKpiPzHW6r+aZRx4chKH6PMivCWjBemy2vXd5BVabHydrs4CdMrcoPuyumea77Ck8T/wzq5e5XIe+dEfmhUZXujU9Ycs8vw5SJ+/9kikS+tk2WnRb5qewgvl+vG3Sh6vekPtfWwj7dc3L9VLsa3l08O2aSmuEWGhgZK59SA3z13cBqycg6y5Y3RcvTYLMm5ECjV5Xp59aib3F1okL83IZEfIJ7dEIN723k6xM2M6H0CJMLbLJ5m7TPGfy/eX6vif/ty6b2lRbyf/lYez6wWQ1C46EJitHMVneAZJ5h7i2H8DIl6dJ7c/GWG2EXkjIh8LSKZIlJvs8t2q1X2/2pcapsbJP/UV7Ly1YESF+72p+6JG8hbsUhsbKyYuLZC69yRkdOQ3ApE5FZpsH0sO88ny6QZHpLsj0T9ATR59sgYef8GvTQXDxNVDRCRUSJym4jsFos0ifx/opy/Jw6LFLlcsm7DOfn3k3Pkx12HZNfKNyR37xKx1TaL+uvEeZs4nQ5Z9NBgOfn+RHG+ahDHk35SfLOHTPX2krE+AbJj4kBx7HxR0ocNlBWRwdISipShWcuDIF+AZHVBnPFINUgxyKMeyH+C3aX62TSRfTNk2713SXN5lvy0fvXTYT3l697JMiNQEQ+T/neR4J9fem8h4Unp9orIwSqRNwpUeXplrWxeUyifHXfJg0e0h1FEpF5EcitaJCO7SZqqHCIOVbZsFEnsPFKU3wGIwv08pGnW3yQpooOIKuJqENn2L7ss/uQNudnX/Q/1dVgcMrsb8swMJH8d8vB0D5n1Rm9ZtjVSxn2MmN9GJq5A4vohOgOCL9JjBBJ25zxZd+touW6Sp+j8ECYeklk5qjy7ShXf53bI1Ke+kcidDRK9cL34LjkuuPkJbv7ChPWii0yTnv9cJ5lWEYsqss8lskBEttiscqayWl4+mi7/OndeTouITUSsYpfC0iK5d/HT4t0u5M9NlG2vFANyPksvxWdOSw/jtfcgB/ZF+n2CTJmpk4yqaPnHvm6in+Yr4SlIcNSVzzHxW4T41fsMcvYfSGvVLFFVe9sdPyXHZKPI/xkg9BfkQp6LuEgda75ZydD+fVE9I9EfryVkTBiK/srFGkRc1Bd9gWHPW6gtOrKzrWyr78rE4K50nJlG3YpV5OyrJTopidK1S0iobuKc04ETcPcE00SIKIA1ZyDHCDO7Qsr1/SEqhKYDmdTd+DahEb6YotJQDCYASqpL+HhBLzZvt1JVUofVCsXXZizXJKoDPLiOwV6JfHAn5FdBYKuNfKeL1DQzHYBSK3xaKnz22VFaDln44IbOjLnFH12gwmOfbOaD+ffQVHFl5CEMeO3mngTsqmboOxfxHKZADjh7wIalzTj3D2bWNye5AofPL0QBbo2CDm6wxw86jE/j/P5GojzyCEqE71ZDYf41fqBPd8hxwM3302/qbXif9yL8JpXd8/fjcdJOdu07OG0lkDQJcr/FO9Cf5FtfY+rtvUh1gF8sbHTCLa5WrEeP8vn649R07s28GQPxAJrsUFV6nJfnPMrhDVcvw/JHpGskjHfBhnItpr3qmJggYqCeyGlGjlTaMNQIfi5wnYe63YAT9KLFlzY0EDEBqEeLoS+Pet8aByOnKsRMOINnSAKK8lPZOv5vAaE/J638VFP/wCfvc1I/mr/fGovJePUqKi6nk90fLGH4pHg4exxL9HCO5BQyuNcg5MAX6PQTsJ/+GlvNGcTsTc57O8hrLCfaD3qnQYsK6ScgYgjEhgFmP6xxHSip9CMvpweHTDXcGdNMxLy30fn4owJvrXqLs0dchLu+Y5CHYKkq4/b3CmgX5MaZatu1LzG0Pz0e2s+Ku8DggqxKGNxNK2JWXA/zcmH/cgd9R+oYN0FPWjWYFRV9SzWRoX5MvH4CO3buxOl0/vyTChrAcysa8ZNhyDYmvuxFZXZfQiZBcZnKxfdPs3j1jZQXX2T/H7wbMzRKGrJc0CsOttbBhZpfHWREK3LlhkYUgxf4dkSZ+AmGQBVHXQXjb+mNV4aBiXd40NEAD++FimywqeAWCD27wh1RcKGhDSQERtsdrD14jPeW/EBs59GMf2QA3bzA0GxlRU4Ny195mvw1X2hkJX9AegHH0Eiz0oE+faI4fLgYBXiiP7x2jYKMOhOY08Aw0of61iAIy8ejTiU6D9xLoLwc9DUQqQYTZbVQ4Ggmo204uqIBkpeDif2BZx+G6IQhpN73NIq+P1pdSdNfUc4jol1eOVrRlP+fibigKQfq2oHuJIT1hPK2kpx7TuAo3kKVeHFy7wmqzu9mjH8D4R2gtUTl0BFwmKHXDRDgCU3DelO/0cqXfr0Y1jeMtLEPYfIO+bkpO78scl2dK5wt+Sdv3LuYh1M9GPV9IUkxfuRUu3C1XqEsqHcq9F/BkCldWT4T9EYtdZMMfHoUPrXC3B4wuY2MZ3dNK5+mu3B+9zEP3dGb9FNnmffMfKprLmmJEZiBNks/bYaE2zaiqhPYPcyFV95u9h7wQd80l6JSlWW5f6ws6B8WfyP4xkNQCx62CMz0wN5rME2UEeg9jJqKWght4qYe/fB3htA+Dnr2BW8PKFHBWQdNblBbCKEdtdqxJgesyazg5Z3HGRnfgQfGx2MHfJ1O8rPK2HRqDzm5B6k7nUfp8QwKiouxOR0EA25u0KCApxEqm8FDtLTZWh08pcJtwGchsKN8IcOGfcbu3WeI8Yeyut/SMgIobmBOBe+O0OzUYXTq0SU46FIOyaXgWQNKcDjtDR7Eq+PIKy7Bveo8P9QUs8Peih2titMFNCX1bLtPAvwwO5XhL3pg8H8aRWkPdPkLyikdBdtCcNcB0Wj10P5vpBXNVbgyxtwmqh0Kl0Lc3EufWR2QXQl6K7U1R9i5LB3sTqZ2PQyWU1Tsc3Bhp5XcEOg+HLq2A5sxlgJHPOF/uxHvlGmg/30K8lUifDjlLWbObsG1+hhf5Nm5a0gXntlVQWFGMS11WdBQ8MuTonoS8MBK7pqcyPwOWvGqX8vZOijKyOelfSc5muPkZjWfQFMJqaldef6l+VRW/raY6jPAvdFQVgQqKShzXuOlrybTM7A7EbYjrMnTSJX/W2KM6UtCQjuiJt+Jy1VAVPfxBLqHUexUWL/qIK6KYJy+CejS38engwcREYPoOiyeMQkwMQA83TVrthetsHgS4GOHHzOsvLkvk7TIOu6eNJQwtBrRltYWsgEvsyfxTU2czsjg47ff5at1a6hsamAgEBQMNb5mEvUWKt0CiPauJQ0h4wiMccA8YMEQSFvwPOF9rkOv7wNoZGm/dvd1QEAEBI0HpVqH+TovElNN+JyppnMxpBjAEOxPdNh44r27Q144KL6QodC8aw1L8g5ztOECear1Z/5Yr7a/DUAw8OkC6D55IMaQMSj+z/4F5bwYKVjLwfU1dK4BBrcNZQkaB/uRtuGtbhvGmram7VyiFfJu+/8ngoU/JuXwM5nRnxaXCuUXsRzfRovOSZBhKxwspnptHgdPN2ALhQGTNFfKpYuiceTjmDtOx80Q+HOLNWiOtpnf9qEGrRr9oMu+c6mw/ahKfl0eJ4rC+eTrNwk5+y62inqqaW07ygfiZ9Jh7r94+QYPpsbqfvHb2bUwfwfsXLWJQNdx4qkldVhnvnx9M0/MHsVrrz1PeflvlXMkMLntfTwz2Gb8jOGpJlaesuMDvPdXxvAqMnjwYBonvM/Ts5KZEKBgQ1u04QFkNcDn56D0ABQ4wctdqD65ml6Beiqvu4Fnu2r50S6B2tOzEWgr70tOBTz2TS3+cXk8en0PulyhbceFdE5t38ETyz5m95nf1q6cEhWGT3kVM2ekktDxPGGDnZxYDHf9AP0rNabM2R3g5aXf4j/s6hUYPTxgUA83BvQMo+vTzRSW+RKQW0qCyYq3A1K8wqHdGPAPAuM48B6unfgDWtnAPftZtGExFVVn2CTZ6HBQBExEq7ncFY2ga/5USLxxCLppu674mF+z4rt98eMv6AsEseyk2X8Sxsocyi644+1XCm4BwNdo7u730OgPed+CfyI4c0Hvh+a4eaIpp/BnlPPygtKgWVIDf1BZXS6wuzC2i8Cc6AbZFVR+nsO+08X4RcDoYeDdC5QucTjH3YtH3HSMuko0/1+roVrS1t7l1jsdbeopBbpd9rkAFQocjlK4O96fyAgblUoQ/TyCUJuKKaj7CRpwgsFCs4Tjck+iU5qe4Mu6fbQMmoug37BEJk8ZwmO3j+XNlzZw/sSXbPnhW5qbr1yv8SLaRLIOaOQ0N7rDsiIX36BZqP+G+ALDeg5g4l1PURrdlbhGIw49uHsplOi074PdoX+0Vku3swlGJCh07p+CuaUD5kCIVcAYd2nq7t/22/WtsOY86II9eGJ0xBXrEp8/dYrNL81nwZJ3yFeFMH+FMM8ILHYndpfmmIY1NqOowsWTFVi3qniFQerN4B2RxG5/L/p3v57WmnSGeO/j0x3NWqj8azGArj20H+7P/U8NJLqonDCLkRhTJe2i9UR16QgRc8BvGtjHgUenS6QmCWiaFx2D4tWXTkTT6LKQ3WwhRJoRBAuwre3QmgsQXVeA/x1Xrvh+TeU8/OSLLziPw8VOfpxf/S17dyYSbC8iOC4Omg5C7QBw/Qjrvwf3jlBSpemqNIDRD83G+HGJaTOLS9b06lLJb13aU0AEV1NO4dItRyON9PQA9wbI20bj4oNk7D8KHSB1IJj7A4nR6Drdjz5oDDqcaGvTyoEsLlBJDEH4Yvy5vUw0ar1EtFn/p2V9BQLV5yArBEYBRoGLDVYmdA8m/8BxDjRmUlNcj2aDLdBag7O6luaOqcT2jaCb/tI1uXvAkFS4Lh7S/KGgECp0Q8g8uRVrUyHXwucy0NDBU4CbQxu/K695+WvSKciHB0Y9yuaCEGrCwzA2ulHToGBEwd0KVi+wKhpGZHVBp25wXQwMioDRvSEiHry8YLRJu4/5aI9KvR0+uwDWRnhqOIRcoe2TJ0/y0rPP8ubazeQ5YXB0OIO7xTLp+pkkdEkjxVOoraiiwOFEj+ZxtQBFh6FrHXQcmkr/+4zcHj2JKYMj8YysIntHFaeuNNcZtR8ILjVwc6qJ6n1lWMJDiR0aiiF4Km7us8B9JlhDocUMha1QrIKHQbNFOiAGoob5ENkpFHdTXzobTeQX28lTy4hDELSnoRUozINhL/wFIqNXjmgX6vFAKR4KFHdbyIDAIeR9sQtf824ClOHg0wxnPcBrOxT4QfE7MDwS2KiVM/cfrBGIeojGI2AYDm5d0axUCBrc90u5fEY7BaRd9r9wNXjq1+hdC9RmwJYj2M/uIjwV4oeh8fn0jYD4O7HZRqBvzsKgngSPm8FYC+RQTwhRuLCzDyM92YY7bsB4NHfkctkHdKzj5/jIpbrwyD7G2oN7WbPlZbKyvdFA9jakBz1UZWDfvpyjPdvTqaMH/aM0fpgWFXQKHDsPJ0ob2bb6OBGjOzPzvjv57K3z1NRci7zjknzwh476c+KI6s/hLDeCenYjKsmPEXbwN0NkK2zVwchCOOEDldVQkwNF46BbE+i9QFGgjwIZbdXADWis5RYnbC8Dmx6eHHn1tgszz1F8/szPY5+dkUu7hDSi+/Vmar9eeGad4JM1P/D++kPEO2qpzDiD0enAZYOdZ0A9tod2syBv/XG2TluE1yfLuL0bfFp2hcZsoMuFltEWtu+o4f6pY6BHD7Q73AfNdHwGXn6Qb4PcdlDiDRUeEBMG5otoGLo39AxlmE8o9DMjuhDW7y/niCWfYIStaG7utdi2r2k5p7/44gsn0WbDYh2EhgvnvsvjyJ4cThc76Xw+m5WHaujeIZCWkl2UvbwNv/oCiM2A746BzQqSDoe/hswf4VwxNHhC4UFwFYFXDQ69DgUfFJrRpi0dvmhWwANthg1AI2qAS8XRfX/R0yvEsw358MNr8N0BzNKKfyrQzx+GR0H0RLB2wWkvRJFq9C4VikootZgwmifioAl/pQWUCjao8ZRhZIxyiUwJQBDWI0Qp0CtWocDlonDT92zdt5slS77ky9W7KSiJbrsCta3naKOpuGFp8iXfZCSiTwoD/TULHWQEswF2F8OpylaCHTl4hUUw59b+lF2s5EJmOk6n/Rq3839HOraPIMm9MxZ7BGdrjnL2hJ709VDaYqakQIdVB/v2Q50F0nMhxB9i/LWKrjp3TTkV+IULbxfY7YTTFng68WotaxIR6EdyTDQGi4PSigrcvBWMJsELhaTUTngmd6Lb0OH4BXYgOCqImlIXMY0FtDOoHKyAknqo2QkpZbC/eAvGzhCkwkF/qL2Cdqhu0JqiEpZgYPzUNEAHtY2Q8S1UrqExbyWnfzyANdOGq6EVV/E+3FznoHsLBGUAMWhQExqpr28AXTu7kXrRn7KC3eSICwXNyAwGRvwVy/mTFAPVKliPa9CPywnWM5oCHaOZxtyDxLWDMy1wdxGc/0Ql8oQQb7Dh7hBId2omv6YMQjeAoQ78Q7Ak+aAMmkp+7D3EGPRtNrSNAbUtwuyHtpB9CHAeDVnrgxZYd2u7wIhfd7ilGnZ+A9/uB3s1xAEDQ6BvFIRGopnPdNzdG8DkpY1grQ9YjoOrBHQRgDe71bFY+YYpTMWMx8+KeRxt5gfoC2j2vAmwojcaGTTxBlIn+7LouBld6yHU9afAuu4XXXTVlmE5uIW84ykUBnUnts3TP1UJ1S7oHenP6BHXYyyBExfhznseYsu2bygu/j2egP+2RAM+JJbvZkdVHRnOI1jYQTYh7N8bgpFhhKW6MbhzB6rqQ7HE6mjvrlE36n01xfy1qGhx+0UDjI/6/R74hMcw8o5ZtE/tTt/9+/C22zGYnURGxuHlaf75uLFje1C100nqmCIuupXSmHEWMyo6NG+sEo1n5wJQVXeNBlvBdh4uDm/gRHoG3cI6IWc3ovMDauuQ837IzmJOqfmE+afTWS2AYZ7gXwFM5demgzAgrCtJ86OZNRKc/3ieIqeVHGA9cDWC+z+knD/N+RY0hbyz7bNatNzNkSZoTgfFH4x6JxlrnRx1g8c2laMGKBBjpLpJMBmd+AXmaXenoB5dmZmWMgMN/RycS0rAL3QiMXo9BhQCKUbDAfsRgI6tQDyXYlHNEbRj4VPgnst6a4GKH+GrpeCo1gg9U4Gh3hDXk6p8lfKilYQn+BIU3g2woO75ASV8MBGRw8FYjOWcna0Jgbi765mk+OCu6IBXgUeBnbgzCvieidzIT9Fnb70RJtxMP9xQgTInRBeDzjqS6oHn+OZwJJkrl2pdlCrQQ+sFHZs3HqBfn+7M9NYeoH1FYGqFeD/YrwOlHLwCoGu3KIYl9OCbsjJsrv+G9VTQgpZotM11VxMH3cNSGZakI8WUwPJ1Cq1l+wA7JzEDu+hQ8jTlrizONgfT6qPjlhBI9bu6YpYBlQqM0GvY/x+Vdj260a5HN40x3tT2uky8vPR4dRbabTvJ902tWCzaoVlou3WeUaHwLMhZ2Ho3tPsQrshf7QJbLpzcrWNtVwu6ixfpEh4IkVVwRsXHX6V3qoJ9z04848B7RCj0TADPoWjLQbyu2H/TiEAGj3iS/B+/Z2tmJtlFDVyLL+kPKedPiYBsNOVwQwNIfNAg/EQFQoxQ44BTNhgXDQWA0yxU6xXyd6m0+kCHaOAsuEeYOFbiJDnZiIfJDbejH9OsDuR40UnCu43HYBrQ1lI2YKALxRQxhWYU9MBmtAiuIzrCif4ZDnIDqCvD/sXrFB8oo2mgmbRevtDBCSFeUHYSU1083v6hGLPKoHobJAZCQDSYi/kx+zu6xD+It7eTEL2Zrrq1uOMOfIXmquiAt0hlJL+Men9Jr6QDIg3wcByAkfqENLy6zeYfJ7KwXzgGBKIPVtD5Gyg+sIX8Pb1hem90wKBICPOECO+2ZWWpkOQE+wV4+PEn2XJ2L5XVf5AF+IriBYxDA+oE2H3No29Lieb5SSNJiOoKHcNIHFnJjqPnydqxmgnV3rxd1EqV4ztOV87HFaWjVyyMj7+yYoIWIq0CbkabGv7yJfxGquHsPjI+/Zyt60+wtqCOgaKFRD/lFgV4ap43oe0W0r6XyosRC9j2UuGV22iB+u0O1kVk4zkwjy76cNQDpeh8BSXaAih0CQd9e1D6dAefB9CcVJ/f7f64l0eT+eh5bEVXBsB+kmvGnOEBCS+MGDeZGE8L1owcIgOh1KJt6TsLFKE9licVsHnBuCBoKoAWBWwhEBqokF2g4rS6aD9AT5C7giFtJIYqcEX74d8+DC/vbpSVVGBrzkdJnUzZ/vcIb29Cb0hDIQjNGXmXUKrR0wcfFIxoeO9xdKS0cVwLoLeUw4/307pmN/vNcCHUQK/ubhBqB49WMATjrobhF3QBd99GOJND5oV86NADzwg37K6O1FSaiYs+Rzv3s2jVNxLBfgbq48DjACj90ZyjWC5FoCoaQN7+iuNo0inE+3vRPS2N60YPYdCUSfgFmzl3YDdSpVBr60N0+3j9AjQnAAAgAElEQVRSInWcPwy5efD58gNs/iidA1t+wFUeSFyyL/F9onnn3cU0Nv7eKtlriYI2J9cTpNNzh1t/+judHKbkN0f2D+3IUym96JrcDiWtB9REEO0XQXjnNNIVhbiGBraXeJFrPYMo9+N1hwfPTIbBXhqwdbmoaKmez9FQ7V9T+v6P5MRW2LeNxW9+RFlVFZlnipk2Ug/5Ku4qDOgCnhUw/W4jE7vF4nncgZeznH/s9uF09tWppV0tKjUFNuoiHPiYmohVHbjFoKGCHcE9NR5T/B3gPQst3//7igngGbWL6iwr+w4U0gjM/ysx52n381xcnUFtcT7XP76SFe/dTp+uPTh46gigWdQfAQTOtkKWAnoXmOrA3wmBFU7iEz2xxLjh3ZKCZ3gSG8+WkRTiR+KMLtStPszuY9toP+s5ZP/T2A59Q0zy9bw883Wuu/sCfYc8gF4fDRkDcK94DZ8hTlDuoRxvcrhEpK4ARmsD7FxIw6aNfH0CclJg1mgrjkoHTj83PHyAhiLwqgBTMAR5QlAegdzNhYsVqIZoOkSGUOORidFwBi12yIf07yG5FjwmoAUPXQAdn/Ayd/IsCgvRMnZXVkzQLGmEjwfTRvbESU92Hc1mxfvf4KquB4OVi/UXyW/RnuZDQbDuIOgSorm5azCxBJEYHYBPgoLOCO/f8xy3LniEhta/GnvaiPM/wRt9oemHVE44e3PocsWMTAajG7FqCxMjwglqOM3RC3ZsUQl0SvDDK6Oa0uxSErJMfJzTSr2zEbgB0kxMnwrXB4OuCA2caEsGCxpWkIxm9Hr/xZ7/Rs6tYU96LfVZRWTsWkVYQhL6Yye4e05Xvt+STn1ad7qkhmHZ9gND727H0RP5LD1YRmvOFywYZOCL7eEko3mBVxNHJZz6zMk7fZy4JiQwzNadiLhy8K0FbgLuRvMBfo3jX0uctFBEPRpScTW5pnIuf3UpzXn1KIpCk/5jSltUnMX5vzlOB1Q7YEM99DTAdCMcbIKvmmG2zob/2M54hpkg/widDO74ToyB06cxD7iXxBvOE6R8hd9NL3HoUA17dxxm7N+ep+nEHO57YxdLH/bG0GMBzXsyqTywkA5PuxHJbI6huUh1gD92aN1F3fef8NYGyPaAeTdCcpWgejlRqgUqHBCZAnGzwO0ccAbSxhF0MZdk9zF4eqnAGQID7IAvFO2A4s0QtwCM4eCWBPwH6MQ6HqYvRW1X3wzSDrK2QPK+ts9mXHPAE2OD6d0vgdP7FHC2Yss6j72gFgiiuAT8fOC+EdGMDP1tRnhccDBuur/IeWwGBmvI5QfnIMovn4i49zh2sk05/dpBcH96B9QyJ8zGUKMH2fmFtIa08s1XC+lU1UxDvR/EDmNXTgwnK5JxqnWQPIWJ/3BjlB18T0JVIARHX8oFN6NxvW7hzxMfX1PC00gwWal3XiCi11O0P7MB+/ibObf1OGNeWomxthlH0TEuNLzM2wdex5hzCwX2lXRIXkTFiSfYsGEJ7ssmM2zdNRbRO8CeB8er4ZOySpxDSxncO5p2aVMg8iauAEf+Sk6jXfWllOGO/RtodS+h4XfOvKZb+8zD818AMBgMLFv+Lr4JQ4jxKeGBmX8jIrkH/bv2I9UllFW40YwGf1kELqpgEw2xczarHK+woKsuJzKyAb/r+uHusEKZjvzSDBwRNvSu6zh55AIpI6OIqtuKw+cI69ZnMP2hl1jx8NuYG4/g3akn/rpYnnr8I6bcUUQUsQQQjBnQ2+qp3XALc98sYZ8LZk2E5CqgAdz7dUIXPwpsJzlRbCGnNJbY5MlAMrgFg9kLz8BGjB7FONdtB0c+iv+dcGAzJDwK4WNAvxYtUprCp9sWMqDdWeKV10FuwvrWfpwFVRhzW6H7JDR31/+ag97s6c6BomKOrtsEWFBbwR6bSkKPeIaFwdgE6BkAObmw/N1TvLLgG7LL4umY7Yl5kD/Hj50lszgX9U/WF8INokfCt69AQDK8uc5Bbks9tVaAAOgwhV7DRjI/WRgfH05QSCd8Y+JZfegMebv2sy8zk9jkFM7klHKwMBqbTQeRXbjtH50Zk2pAd0ShUwI0uoNPGCgWwACzD8Kc6EvpsP+aePjjHRiMf3R7IlN64aF3UOOaStjgISSHGTmRLZx4bxtLCw4y/WIB7fQNhLkaaAmE6JQcDu0u4sNzhRRdy3y1idMOFWU2qnVWEgKjSPLrr032V8jTX5JcwEkFD7CJ9jxCFh+SxQjzMp573Ea1CTDDC4//D1IpLpfw0Vv7WLTkQa7v/wyx3v24/747eWnOXBYvf5e5ufvJy6zg5IVqzMp55n28FzMa1moAZpY10FINB9t3xHCsEN/g/riMNgIHj+b09nV4TblA5wl/wy8iDv3kAXy0toVZN7/OB68torzORvudh1l6pojJKTcz0buOvKc+5eKozowc2QpSga0xj83fZ7OxGQb1gC4uCNR7Utk3jO925xM+IJ5x/b4mwVKNq2k9NMaBT3fABj4BUG/hkx8+ZmBsMgmxXWHDW9BlEERWgH4ZWuLEh6Ov3cuIGUFEKqB8NxPZcBSL2634GlaBSYe6dzoX3vw7sctv48P3c5n76GtXHM9g4LHrx2B+/H4WLnwV1HTCdacJ0g9l55mLfJuRT/OOYzRlZmLpNptX595Azw6++JmA0FB8ii8Q4nJRxp/c0+cDVTPgiRJoTtbR7FBprte+0gUOROcYS3e9ndH3PYCnToEyEwFuLmZ6JtMtpojjlXa2pKuYUkaiq7GBtYoR49Lo62HCu16h71hYuRNGTNV+U9yg7+PwybPQ8c/080+KISBee9P9BkJaPXHzi0X35CLe+/5Dbiws5nppohnIdBRSC3xZsJNNNYKrZh9LAzS29j8yjq12OHiohq/0P2LWOenoE0VYh77XOMMOJY/i17AbY1IG5YYuhHMzs990kNlXNJzxGvPrNS3niy+++IJOp2Pn8RO8shlGT+5Bu7JUPty+mGH3zGLhK09zxnqQT5b9yOGMi3gnehEzLpUbRoymgz2XqtxGzqHlJw+pkFPURJxZwT+4OwEpowgM9Sa051h8YobgGZCETu8L51aS3HMchXvnk34qk3/MnsjZYC8W78zCbM+iVzcdL39YTx+Ok2vPwD/uTtbPu53HV7WguMH9Q0GfD63NLnKtMQydM4dgby+cOcfwM5nxiJsHRgONOi9ctGDkLHveXUtsQCPtu+Vh9IqBsGQIvR0MlUA9fPFv+t/1A/dPMhBWcRrlRCFyLB+bGTyeCKd85zl87v4RIlbh1ecJ3EN6ENeuO97eflccVwPg7+lBVrOJfRdNeDgMXMxLonNyT46crWD1u19R4h2NdeYY3prRiUndQwkN1KP3AUUHUaOCqbDnci69AvXPGE8rOHdC6Sqo3ihaHqxNRO1FSOQcpkyJZVBSMOi8IcIMZ8vwS4qjtWkQ+Y298eregwt5UVQWmFFdrTwytz12hwl7e3j1NXhkJpzIgw+3wROPQOgCeOR/fbfht0AIGOswqlspfPgeMldvxL+4gMnJNgpr4HW0tIkPcMjlos4CHwFPOsChath7GFet1fWzOO1CXqkVtxYrAY4KVmYXIfmVxPleBG9vfgklzwT3HRh+cBBVV8OrpfkUXNhHkbMOVqMl6V3wwlUAoWvuSjmWmSk+ikJ0fCKBrzZR9pQ3p8ocTHuziJ3PxzD+84tsn6KQnmFn+VYLj90SxKrlZ3DLzyJpSBpRjQdZs/ojtqcXMh4Y4g/HDAbsMT70SBvH8Ltn4t+jH5guJZJprQKPQDbtySU1TuW6IQOobm3lRm8LB8uhyazjtZtU1m7Wce+rw7CFdeH+8W9SYoBb7jJw8Ssnd6RCS3wYsfF9MAeV4u+bSqekRAyeboBA+ym42IVyfhXzFxyj1+haJk5ehsmjGlZdgKGPwLnHoCIdspzsWlZN6No0krOz0BW3aqnBalBvuYAS4IGjyoopJBFt5961wPFfSl2zldcWvcVr/3qJuQ8/j4/relqS3Nlxzp0T7c18eouZm4MNePwK+nQ2WvhPl3Y8U1DBf2e9UBcw/5uhQ8fy6kTo0wcNbTMAzTaat+hptBrYZYXXl8O5Y1/haFHxHD2SpHFBjO2qI7wZRneCxCZojocOM8HRFU7Ph4hr7FZwos0RQX+p37vQ4rl0wJ8trzzKgOpImsvW0bjGQtg0OLcZwhzgmAC7P9f2jTag+UIhaCk/X5OBbbOGsOdYNo8fvZRaCfH3YdzooRSJBzs2fa1lyyq073zc9PT0dGNatyQSp4STEh5JaJ8eEDEJTc2B0s5QcRYiAQ94NhcObIHdx0Fd3XbxgIj8+S1jMamZ4vdpMkqZYPCCx4YobMiFjiHaYK5fDrffDIP0ws7TKrcM1lHbYMXutFPwo4tzK8vo0Q1aT/3AF1v+g49aTLc40A8aT2KHJFL+dh8e0YlXTIpZbLBjy5d07HyBD96dRPSx7szdpa29uMEXvmmFZ6Z7sv0w7MhoQXQQFgGjhhgZ6x9EarAJ07i/caYwiIljbsfNUAX8CLpQMLrTsPt11iw4SegNnvTyC8O3KQB7iQW3jhNprt+OZ/MB1m61se8YPL0jjiBdOcrnVg1yTAuClCPgFfervqtoS9D1WJwR7K34hNGRc39zbZfLnqwGFq2tY3yaPzf18EDcdMx79R3ihw3gb116Ee4LbVVSKAbOf1HMQKWUnTvu58bPTmJ1/k+LVbQDngPlVmIi3Rg+Bm6dCQMia1izK5N2ke70bZ/E+RwvNv0Ii7+E4uK1IF0w3RJDuyg9nfrAI0HQ1wzFPrD3cxg0F3SeEOV19ZynDW2BQEf+HNapVSVOBM7A8TyoOAGZx2iJKMLtmBHlgBWZJujfBuuNYOoCuj2w9D3tue2AhiC8CJjdTGR89iZeq1Zw49qj7LT9VGkiHL1uIu399nH/hPm49a1nzpzZuC7DjoyAj8mAwUvP0ieHYTbEssH8EIbJVh4L/RdRrgZwHoAzFhouwosW+DAdmpZxaWUPf1E5FX20vLD6Y158+xvcz2/l9hWLWDFtLgMSUnj05RE8/uAXfPLYLUx4dgk9e/fn8Ve/56sDsPTv4LSoOFpV3Nx04LDSvLWc06++gVq8mgxXC0F/G8SosED8Zz4HkVdOQ1gsrRQcEBZ++BDfrfqYBruGDJvQVtMEesITA+DZndB/IIyJgwMXIa0mnC53DsRkyGfs9bdQ89lWqsWDri8+CUp30j96jbPvvIwtxsmAQB2JseGQ3B9pqUKpzMaqr8QNB9YssLuDt5se3SMuFAcQOoolxvYMNLxLF0XhONDz0jDz03QoosemtuCuv/YOHLsLXl7wBotL3Vk0/0HOLHqOr/ckIrdMpVs/Mx3LQd3wGZvObKa20kW316fx1XVj+HD+yzz7wZvYnVfax/9HpT3ayqeBgBWdLo5eY2B42hlcp/dTHADp2RtIzj9GhdMdq/1BslrjaFSztTsw8SH0NVnMmtWDB9q7UdQCo4aD0wpmn7Ys8GE0JOhXrq0TLU8exZ/ZSJgFNECNHSqOQqQLPLJBrQaLO6zdgAR0gp4+KP52aPSCgxcgPYubXpvE1pbV9AcmAdPR7O7twJMhfjzWo4VN5xy8VAgnAUgEZRGJXZq566ZJBNQKSt+jPPXKQuoy1mszy2Xi52Xi7h7ehI3oRlNUB/4+0UJk4D4gF0eGE10UXD8aLEbYs59fhCN/TTkVRcxe3rRabeC04+btia2pBYNOj4enkZYWG97ubjS0WjEbDAR6+hAVCoPbg73DDKbPXMTpPTCwFyR1FZyVFuTBf+AyOcn2CCRmZAi+budh9BPgH33FPjzTCE8pTTjsdoKCfuv8mI3Q6oCwYBP/uDeJN5ad5Ym/hRE+8AH6dI2jOq+RlH4dEHphqN+H5di/OLfxJJnHLCR0hM7RXpjVePCugLoaqipduJsETxV0CUDjSOT9PWydYWfE86EY/J/lUyUAT26lhG95kJvaNpY5gEeAd646nleTFdvKcOoUpg0NY8GSfBa/8Rh1gTdgSLwJ/aEbISaIGWMe58nbogkK90BOmzAlW0iJDKGw5fcrjJm8YdQbsPHyVY6EoO2LSAEeQlOlAvTGczzZIZYn4+vY07qPOg8b1jNrUfLTWSoenGIimtUaCOGDIdFA19EGhpcqPL8ACo5D6hDQ6cD+JZSEQbshXCpn3ybNwMdtLf++HECLK3sByaDWgloOn76t7bFLbIB96bCpEHxh+2aF4hx4xqIw2+GiwuFiqdWEHTtGtLjSeyLY+sG8+fAJcJcZ5vdw56n9RqK8kvhn40lgGDr9Uvr3Ps+LC24gvr+LH1fk8cz8BVRUfPybXrobQGfU89XCTsQOTiQxMQwPtxXkbK4n6wTsz4f/rIDWX20kvZpy/i4g5LDbQdVW0YfbHYw1QrKncKrJiQgkdRAOrvQi9Rsrc6dYuHOOhYT9Fnq1HsdQ28KwuSMJdIHOrqDzM6IfPQSDI44gpYq1a99C8RiAf8Z59B06gIf5N30YYIL3vq/hh/QfGZUwiN2Htvzie4cKwcGe7No1m1vuWEdKcCTXTbuH5557nySMmL1SiOw2AZ3JA7b9wL6nPmTTLgfGVuhkhNCADij11VBVjtWoUp8JeU3wox3in96A2wQXyvWBvL3VhSlhOJsNLczwmsxOZSv3MxUTOjQnKRUYDhi1Th0rhILbIOIM6K6xHwpIifVi29EDlFbVoODGkX35NGUsQW09hevm+exYMIO7x0QSHOiOu8GAW6hC4bGTHP3uLHmWwmsijV7ecKTQwLHA3oQ/5k9u7ljISkMjoWhB2winLaxISvHl0RvbM8h4AU/zRRL8VAoOfc3ZwmxqRTiJnXqKgYeBduCdA9mnqNzdjOOOUJ5domPvYcgRuGkgPP0x+MWBcpnP6kRbfuneNlq/ny44CVjgzB2wrAhkHrTbDtUHoHMgnD4Ed5+Eye1gyg/QcQMxLbUYx6h06ezCUCL8qwxsbVsKRwN3zQcpgY8+hcMuLRDxdYCt1smsIcLxzEDuMt+E4hhLNxmKW1MCfqV6dJ46Jt7oR0pwVzKP11Pe9Mu6fU4VHE4hUFdFj6BM9hdNJzoqhLDkniy9/TwdQ52sPwfJqoZOhKNNUlcDhK6pnO2+fPGFFS/Hcr2+iUXvTSDJVsS9G17moxV72H8kldJPKzHphd7Bdp7cCv19wDcMCvdC7FiV3FDB5WxPSOc4DcQyAV4GqN+ObmRX4js+jV/+e7zVkkTj8neJHjIYg+cvF04aFOiV4klQ1458+UUJrQ16GhvO/vy9zs1I0E0jWDT7C1wGlbgRnnTvnMKrb6wgMsEXao7hb6uFYAuFW5Zy8nAu1b4QHQCO9iEY7bVgqkIRKN4Iugy4kA/66aPYnfcuNcUXiItKpdONKaS0f4hU71QaMdKqrKUj41AIBzUK9tog4kWwj4YXe0DJRzBtN+iH//LpvNJN0Cn0SWmHoV0E5o4BnA8cSn6tnomzprPq3q5UW0yE+ejwMCgsKoJCO1w4ZWHFhsO02DL4dSJgMBrQAaAaTOQPn83G4NH4xzyLZ9x71Hy8BS0+9kcjpQCwExvqza39Chg50xPfkeGY48JIuW4CcdPuo85/AIfzzlLXWgq+D4FzOQS1h/pChnZVcT9egdISzbl+Ojb9HZ58VKO5UHQQ/CjcNVbbieLrgFNrYGDHP+rOhgK1EPw5DKiFNwvg1UNQWA75eeDZCNdFwIEC8F4G0bvR9Ysi+P0DjFzqZHWZlnMfi4bW3t0Tlq+Cz3PggEshNXUQvasKyUErvdlcoPK6y0qzxBCmFtLAWloiPOk/JBQPXR0GT28Mib4cbjaTm3sBWkt/0+PjOYJjgwppLWz68TSnv9nN5Nts3L4EwizainHhUth5NeW8ZlFpPYhRjxgUxGhQxKBDAv0M8s0/g+XtqYlSfvB9eambTl4cj9wAckMS8tqtyKgI5N3OyPtzpki9Lfu3VaFdTpHDu0VNT5dNvYfLew89K2tvGiq5D4bKiwvLpaX1CqeoIg+sd0r4bX0Ej0vFev39vaWoZN3P/yentpdtu7+RR6c8KaraKKqrRMTllPSPPpRpekX6gdwK8sXAWGm9PlSO9EU+CEJG6JDb0Fi2M+9PlJNTPWTZm77S2LhCVPVuUdWHJUv9TNbJHHHJWHGpdlHPzBJZYxUp+1bE9bVIS73IwDgRh03EeRk5bmOZWPe+IZW5W69VYltUEXGJyF3fiRhnnRDd6FtkyJwvJPD2ZjEGPiKR938ipvhBsuSF+2XJ2z/K9AcXik5v+E1RY+Wy9zofs3R0fi+m5j0yKC9PgsIVuW8OotHe9RBYKvCm0F6VGf9SpXnHBZGLpzVOT5dL9m/Pk1t63Sj+OnfpzzgJ5B2BLwT+LbBM4E0ZoHwuJsVP5j3aIA+tFsndKqKe0H5iVHcRm0O7NlVEXC5Vsi42XnMcLsluEVkpIjUiUiWS+S+RvOki9jQRByJvIM1rguSlCSb54Dpk6f1IeKBRSm7Si7zUQe4bqJOHempcpQrIP9HoE/Qgn+v1Yt+6VRx2uzgamsT+3BvSMANZBBIO0gWd3IeHLBt6q5w4WCEvDtsln0VmyTdT7VJ1RuS4wyXjHnv8qsWouyQjkzwVGZOIzJ+B3OGlFZvuCRKFxqGa1nbs1fTvmsp5tYZ/ulidTvkF2S0gqRE+smrhPNmyZ59MHjxUPhw/QqwntomoLb8c97wskc3/ltaqPPlwWhfZPwq53wNZ/tAb8u9xoWL9tPEXDISqiHzlUuWexfZf9sfDV3TPHxJAfMIi5ZkfDkt1RZ58/9Hf5djuf4mIKge+XSmDzYq4ofGFbJ0SKK5FwfJFD73cDDIbZGN35NkAJHOuuyzt4S5HnxgreXuny6aX0qTmy8fk9KG7xOm8X1R5QFR5VGTTOyLLx4uoi0XUdSLymIhqE3G+LSLntf8r5or1rgjJ+WCqqKrrqhXsfy0uVeT6xyuFgQflprtWyvg382Tu+rfEP7KTrD1aJOvmzZJ5rx6Ulxa+JQbDb5Vz0uWVyM06YX07MV7QyYhdOnl+LqIoCHRoU7AuQsBXEjZ0iyx8+Htx7j0t0qzK8+UiplUiuv4bRWGS3DVnuyye75SECJfAGDGyRjqzS0y8JreEfSpP3dIigaaZooyyimGeiF5/WF54VRWn89J1Oe0O+f7JZX9gHI6IyGLRWFIWishWEflIRH1bRP2nyH+6igxEZHeMqNlx4trgI9/fqZMljyC1m5CoIE0Jf/1s/vTeA+RdvU5sZ1e0PVyqSGOtWB4eJJ+BGNBJKiGyMHmkpD/3tNyvGyh3c7d0ZbK87V0iZ+8QUc+KPPFethB5w1UV9KfXZEVrE5B+3r/lgf2vKidu/sLwJQJIQHKavJLjEqfLJRfzS2TFM/+WhX1HyK1T58k3u4tErdgvq/4+XLa9+WYbi3O9iGoVte6grH52gLz97gbJXbZcHg8NkVunzpbnPbzk9W7IXZO95IlhjeKwa8zPqipyIldkoUuVLnd+qvXDYBBunigY3cVr7CyZvmKNhLVLlk8O5UtNQ7Mcy8iXzatXi//lD2475PUE5DGQB+D/sXbe4VFVWxv/namZTHrvFUJooYfewYJIEwFRFFRUFNtV7HrRK4rl2rEroggioPQuvbdQA6QT0nudTKac9f1xKBaK+N33efaTzJkzM+fss9cua6/1vvJyB2TVeOTVKORAf2RbG2Tr7bFS9sYwKXp7mDiPPS9qwdOiup8UVZ0qov4m8t0vIvO+EFEPad2GqorWk8wRkToRuVGk+GeRwQnXZZQXRhcRkWeWqOJ71xbh7u/kjX9NkBGv7Jf8coc0OVRJd6viVFV594PNYjB4XrFRxILorUi3ZVdS+7YKDBTMz4lnh5kyYcYyObqnRE6dU+W2bBEWiPBvVcbvVGVLoyoNTlXufFkVj4AzAmtkBO/I4+wQK6sEHpTPl9tkzAuqdHlO5KTrkmK3qCIup1PeHTHq2nWhqiJZJ0UWjhc5lyyiPiiiviuibhNVzRZ16/Ointogqvq8qMv9RD38mKibH5WqlZ/KK9ER8kNbxP8KAkt/nl10NJtl98l8UR12qf/+XXny/HtRIN+APAYyFeRZkKHW22VbjCpqb1XW9lkir/T6SI5sqZKHH37kqr9zE4gnmj5L6mDEoke+6qd1Hs7pVzfOq3prB66vE6+YQlZ9/Su896J20Aj08YAtdvCxQr8ucIEaPyoSj/adSTx5ENzFnDEmgdnMHd0SmDnzNb576xNSBwzglgET2PHaVFo/+CDsKiDj9GM8edjIiH53kT3nQxY21HNzoJ6WvdtR1RjIna9sYEBfbd123xaodjtYdsPvYhpNXnjf/hrjJxnZ+OZJ5m/5lBalNn76bClr5z3LtrMltETbSytA80v2UaBjAqh14CiHu1YMo3ptBmbzQBJK9uPXfzSZ5gzcLhetevlhSB4IxZUwawfclAAj7gclXnsEvAnKC+efhwOYpz0O7r64yXehnhW44saf/fw1GgEReOgLIe3AApyN/vz8dj/2R1sZgYIXsCIXsj8Snv3EE5f7kvtPAfKHQfSaKz7W36EFMBj4AkK74jd4CvHxFlr16khe647sLQKiYX64wtLxwq+/HubmX+IJOejPlk/PUlCzh4k+rfil3oBNdpMYMoXh00z0f0mhSg/3Xrjf10B9GQ4sE7qPuQZ/Yu16KLgJctvC0hiIWou000O3Vti3eHD2lA+FRTWYdR7EDwpm2+o9JEboKbRV4TfKyaSHoOivy8CLmAw0KAq+Tw9G57GahN0DmXDLAe54ehAH1PV0NMPoZHj7qBbW1+7887AmBXPHq08RlPQM776yh9wgB/bmNeSrMZTmH+bE3rlX/E1LCwjI0xLwhwBKINzbGop3wWMPgvLZ5b21f2Pk1HpdRRf/x17BgBB75R7Dy4r4+/3uXD3yyGPj5fSieXJLl1RZuXqmuCzMKoAAACAASURBVN3l8uNd3STCgpw6cEqejo6VMAV5tx1yj+68EnX/cFHunyPbnC5RVRGXW+S1PW7R/WezQHttmu0XJJELD4tHdJLcdcAtqiqyZevWy15XPEgCyA2hSDd/pIeCPKAo8rSC7Lq1gxxf+ao0rpgom98YKg1H/iuqY7mox98SObhY5OePRZauEHG7f9fT/+7/K4wEquqW4oJTsuq/Y0UWP/e3RlERkZUi0u1ZkYRxT8qI1iOlZ9dCue01tzwwX5Uh76ry7MImMRgvI1J0FVm6SyVYYNj5//0F822C1yjxGnO3RG/MEp8v0oWPN8iwzGxp+7Jb8B8lYJbhHbfJzBkuSQkdKQaGC7wvcFTuDz0rRmWeTO7lEJ8HVEl6UOTHb0X+5qThEqq2iHpykKjqdpFFv4pMnir7Hx8nM4YgUwchwzsg00Ygn9yMpAQiwzohKb5/X57xo/tG/2H0bqyvlzhMAhO0mSDaMufC+Ukgy2/qIWrdXnEs/0ZWxgXL4z7TZIH/HpmoPCu3PLVSOt0y5Yq/94w38mA35NA0pHYkUvpfJG1CB3G+31HUVYjrh1iRfzStNbQVDJ+LzsMqT9Q0it5kEV38jaLodILBKPh6y+8N+FrFE8T4u9ezZkyQlnFhsjkVeXnsk9LBN0iKvx8tkd6XJO9eBXm/i2aoq5wueW+5yIzNIoE/2oWOnbXzPKzCA28K0z+SFhNekTU1IiPe2yZ6/V+Vufp7IIMs2sO8R1Fkx8MTJHPxw5Lz9M3ySUSgHB7WVs48MU7sxWtEDj4jNT+9Km7bTyIfPyqy7jvNmSUi4nKJ2+kQWXfPH431z7DlSuP2/pL56y2iifxdH/bvFWl1l1Paj35HNn+6SKZMe0emTFsv09eeEqN1v8Bf5QFvnKbJzv95bXPtkiAwUmC66EZvkDFHa2TKUlXCUyaJok8W8BeF3tIZP7GiE0UZIH15Q0z4CbwhOmYJPCdgk9R7XfLdLlXcB6/7lsWWuUoqV/UT1fWMyJH2UvF2vOTO7i17/xMj/33cJCmtddKtg7dMf7i/DLspWHx9FAkKRgyGa99jc3OzqG5tGeZ2u6Sutl56dL1RAPHxtMqTE+4QQPSKIvEgvwzsI67N38vpeM1oZ3dLkcb7v5WG1IOyIOBXSeK4wL1/2wYAeTRV89t8OQqJu8q09qrGGVMpklIhwvMiphRVljS55c1TjTJ++oeS9OJCweghelOoKKZbxWCOFr3JQ3Rmsyh6k6D8PSHTC8VqQs7m5cr4yDDxvEzP/2YMEjf8JfnaZpOjm0UmfOwSxi7SKsXqL8rLv4nXA5+L390vynSHW06JyLp160XzSl76Ht35ijcajXLbbeOke/ee8v2widK045S49y+WI5+9IXUfzBd16SJRd88UsWWKfLdQpPm897XJLmK3i/ux92XlhC6iNpeIbPtGxOmSSyvG/y0+2yUSPz1N9P6J0q3/PTL4kTIxWO8XZi0XDH81znEg+SAfXbdxXigpwqC7hd5z5K0viuWYTWTkPBFzi7lyOzHSB7148rEMGF0vPoGrxaD/SAx4yyt0FCOK9kx074v1XlV+3v7P7rl+/0op/3y0SOV7IpWPiOTcLbJhipx67R45Mu9BWf16P5maEiLj+sTIy4+Ok+iwwGvKMl7orBrXLpavV26XTVsfll7BPS++H+HjIaefHiJJgSHyVf/hYgFJRRPBvQ3NUfR4194iU8eJPPeeyIj18pouVXz5QuB2AcN1GemFIv9kzRlyxCbltSYoMKA3q7h/zIb4FkAtutJviR/8LwbFQrYHDIyG8hJI962gbm46x3etxnn4E9zNzYj78smsOi5lzAz0NvDNqqP0vG0Qr8SU8tQRsP8l4yIGo7GUYU127nTBnc834ny/O3hkwh0j8QyaRkpEEJXVzbz5clfUbVlMHP4SLvuii9+QgELXdon0f/w12vuEktAiiCO5BipOnGBI3z6It5WARBONm/fiH5aKobIaDOHQt1lT4Ym7DdpWsX/bbrq9dA9KoTd0ygeP+2BcZzBejRlHRePX1Z3/a7rsGRcouH+P7p+A3QWtDi9n9YoHsE38GL6+B5yX5S2nFRq/0+yrXM3VEQuT7sXcehL3FMRw4816vj8JGz+Ziq0gkp4B03llXxBqmHD4wXW8sXgBza6ViNgxGhIJH3WMQS/o+bAjeF9jmXl5ZIGcBAwgAjmnwXQK7O05fbicXGmiuaGJmlN2Nu3eRri7gU0VjZwuasLuEAxG+HNk4wg0qhRFUaisrCQhIOD3iTmYTBZGjJnCM/+aTGrqJb6GJGC0UU9YYiDj77qZsC7DIT8UxZ7EqRU/89SW91in5uPr/w7O5hW4m3bSLApyIbL9GpB/Fr43QOj5OD6T+9N2VAB7vhSIdaHsU2n5nJn/RmkJGga0OMXuaKFR3dFEalYdP86OWbMoWLsKe1MTLucfra2z9giuqRv5e9yZOpG973xDSoQHSUEO3gn/L6rrdXTtWhP88FJimrLpfnNvKvLN3DsYvlm2nEWjx6A1ez/AgMU3DqtqpW2MENZURpvUXoyZOpp8tQ8dwrzIrqslTMkg0pKEIdELkxGUO+6Cb+eBnDeGjBkwYD7c/hyceBu2rYFVW2Hi5feTNWSjhaIloWVSTP3j224oUsCs0670z6ELnWZBvmEJUX42Ts6y4z73GH8J8jyPZDSWu2tl218dYTB0KB1ums744I7YfY0sW6NQ9KvKhIEKw19r5p7B1ZQWdADK6RxxDF3zYcaNuwtzOz1T7gG9XuuGnE4tWulC4IF6mfv7C+yZuO2lSMUO9AYFJe4xtPjaYNwSTnnpeg7qUsg4sY1sS1cci39Enz6XlWn1jBjrYvFCoa7ehvNvJgcoioKPjw+1tbXouURTnmhReOnOGxj/9oe4SuupWrgaU14WIW1t6GUK85d7MOvAS5xxlfPg0Hfpm/s97xT4c5ZtiKuCJlcTTgRwYQSaMZ//do0rQsT5DxxCxgt7aEYhqFKYaxNDj/2SsF3kN9FU5f8jIu+cn4qUisgB0aTTHxORL86/XntmpQyf3EesgT6iM17fdPevRZHUsR/I5HqRRw+6pcMLJwWfVoJvlBgf+Uai55aK32cLZNR8p6yxiyxds1fMPl0vfV5vFg+LjwT6eUv7m8bK25+ulqzMYjmWZZPSCpesTzslVSs3iD2jXn588mX59tWFUvLux9KYXybq+8UiARYRb5PIB0+JbfxwaeyJyMdDRR6KElVVxdFQ/s/mcS4RyRepKBJZ4RTJdv3VmbJZRPrOqBFDl1cE/eWl1i1WzQ8QqY07/8+6RqCjBNx6qyTfuURmbquUmVtcMnJ2vfS72S4Wy5sCPgKIv4evvDLgWSnIL5CSkhK5Y7IqN08TeeptVUb91yGGYc2yXERUVZWyqmrJ/pvVkrvrS0lb9x+xSba4mtPF7bSJW0TOqeVSq9r+spD4ctE8qWs4K1s+Wi4rvvpChvcKOL+ve+0SFhYm+/btEwtI+/PHTCAplgCZFtxanvcyyS0BFvEEmQKS09sssnmWyK6D8p+er0gQt4s3g2XP5qMibx8W97O1ktXrmNxrvF/aMk7iiZB78BE9/xIYLDBWYIDIP3IIdU/WLlynCOOHir7fHrlJtC32y+Hc+QZ0AXnillPiFpuIFInIB/sXS9LonqLzswi6a1eWT2jYZY2THsvF+rEqo9a65clNdeIXNEbo9qIYxj0h1rFHpGt6owR9nCUPrtDiSyYtWiZ6c4BW2QkjZOJ9H8vun9+RjT/vlm9mLZdpTzwjY+/7Wt59K0dyTjulvlhk/QsiDfki859aL1MjbpVXlVFSe7pQ1B+7iHwwUFzP/yofgHwb4i3yvL+obw4RZ3GunJzTV0St/2OE0DXgtIk4M0Waz4kcWi7yZprIirMiJQ0izj+1vtvWiRh9R55f3/y1zu55/hPRg+SA3P4/MU4E2svQx96SrpM/lpd+OCvfbUuXkcNOi8WsefAjgiNk7/QVYjVZfveZXKFNlUQ9rsrDLxyTDs/tENXplIyMTLlz3AOiishlAsFERER1OUR1/C5oRXWIszFPcrfOkOL0RVIp2m5yuYhUi9av1Z3/KyJSWlAg/3rrbQnx8754PSEB/v+TumgF8oxBJz/6eEj2h3dq1tBYJRum3isDvaMlUBkiy149IBXpdslIypZ7aZZ+iPTAKXpUga8EZgkMFHhC4G6R/18QgkEM7VZJp2xtqz3jCpXa3Nwg5UVnpPzcGamvzBVHfZ6Uukplo4isE5EsEfm0skLazX5YDK0j5dLIfLkSIK+n50h0yJ8NVCc8lC0+21XRPVknffbZ5aXZ+8QY1l5avnVcTEkDJXFto4T9INLhE5G19SI/HBXpcNsiMXgGCyDe0e3FGt5BIF4gScanDpGVr34k++avlzd+qpG3NosUNIo0LBdxV2gX36ndGJlvekhqJrwu6r0pkvFmd7nJiji3vCjqgnekNH2zVD00TBwVReJonCuSv/98k7kyXA6Rphq3ZP3qlszVIru3iexbIHJkocina0RmnRPJa/jjbs3MzSK+rT4RFIt4na8Tb//gi/UTOHaWBPgGX6Ve/3lJGDhC7pi9S1btKZXivHJp076bKIpOdn63U86cOCNWq/UP55vDnpCnt6vy8htZUl+VJ8e2bJKQkAjJysoSm6rKr42Nl6+XykxpPLlUbLaa8w0rQ4o3PC27Vjwnh6qzJFNEjonIIRFZJCK5bpG3XSLHmkTqqkvknl495bHxI+W1YSli1GsOmh/fev2aDqPLFYvFIpERERedSVaQx1r4SsmLo0V2LpPmzDPi/GSKyIbFYp/plpUJIi30X8pIDstYHGJFszIoE8gQeFzgA4FJAqcFOl7ROK+ZMgaghHWmV/EhdqBF0f85Q9GpQkV9Axk7vmfxp49AJQwa3ZXU1AlEde0HPt3IRJOjS0Gjw39/83Jy/juHyvR0HIUll2TEQ8KgvBTCP2Z+1oPUPTGDR7768OImPkokoXMKqHEIzSdtEJ2JvnQnyolSYkd2oXSjL4aEJto8M4wju2GsJzx7AxzIgS/e+pFjS5+msbEEbd1nR0vfLgOm4BtnJmDKPcR2jmVkhJPY3Ub6RejwjgZ9NHw6JYukkm9p26KOJSg0K98xedxHOHdu5tuVNu56ujfmuiZ0twwj3JALyZ5ouRd/cvw4wdEMVeVQsMuGp0s4q7NyogiaKqCiVKsja0eY1hp69gAvfy124bvfYE55E4fvj2CUrYZlPhbunf4JX79xv9YGgAfHPsMXSy7PX3Q5+PhAbBg0lUJp7VXoGj2CSRzfmmfvnIUlN4ftZ2HBJ0/RWPdncg8rye3iSWn3JL0WTEG3tZagtGe5a8Y3jB54B9mFR9i6cy2/HM3irkEDqOQid8BFFOTto7zsBJ1S70Q9z++vAxpsNhRxYvHwRNUbyQOOF5Uzt6CRmrwGRqa9Sv+RjzHi5hFU1NSQ1LYNOp22uj1+GU3PayE1NZX7J01ixqOPXly/hwLPPfQQY0x2ShcvINrTl7DZL8GgUTBP4dZ39vNbcX/0BGGmDk8KMPnPptn1E6rrJsqaKgmmiWLSgPaIHPtn+Zz4dMby/CE2PafxjR7k9/ogTsBEmQN+2LCVrZMHklkJBn94+ckHGP/yf9CShCKooQYFIyVuHcGKgUydkTyqWbx7I+fenENlaQl5R3Nw3z0N5n8Fj6+h00grR/r1RlznvV5hbekU+wLTV07k5S0qResPYj63G8/wg1SXZODd8wEGthrOhk+XEDn9bmw+Pnh7Q7wJXuoK1hPw6iuzWb78hfN3aEFzaZWRmHALA959htTYMFq7KnnpXwZ6PxpLRJ2RaB209oYW0aArdjP77Vfp3ncQfr6f49M0gE8XzKXzw6NxV/gyOM5A5Gh/CBwN2MFYz1+aXgWU5EGZCh7FUJIFu7NgbwUYmiH/DDi9wNIWWnaFCV2hfycwuCCtAJ7eXMGhmf1oaT+H8sgYRvqO5ZvvX6fw9H4SLQaym/6elxAATxg2Cj4cBfu+gi82as68K8EQPoJO3ZKZ/8okWnZIZtSQPqzdeQCnW3P2RYV2ISy6G2v2zqG5XGFTfTaBJ7JZvGw3xzd9xu1RHnQY/Q5+3pvJ8u7PwLsn8hPwzPmW4uC8HlvZWSjfhyMyEru5PSaLD6hO0k6ewmAvoU2rDjh8QikBDqxYwDdz9rB3+3wcds3/moxGf7Jo6294WLRMpx49enC19v53oEltaU7PME89yQNiuH/03UTHhJF9JBv38XSOnJjN6ob21JRk0yNwFR2Nr+LTtZojxWCvgLV2uM8cyAdWE+JS2H+48LLGefV0usAo6L2OoQ9rfNZOLhgmaP62eiCQEBPck+KL8Z5+uHdUEG7OwifRCoSAsxYoxFi5jaJqyKuDZoMvYV7eBDTvpJXaFsfT97KWEhY9PZszcz9GdQNvDSLtLe2XvKxmkrp0xz5sFpse6g11tewpzWZ1wVZMpRsJOLmJ6iIDhuyfCV5zK4EdbqXl8Rx0/TuQXw8ZdQq/tYYx4Q5CY5vPV7Gg0WKfwTewNfdO6UvZmh28sCQPp1vl5ZdmsPuMkS89oKpQZUqKwpMxCm32OXhu96vMneaiQK1HFuWjn/oAL33xC3OevJvKwmbCd7dE179R44YM+POYAARBmC+EZQPpYCyCNhUVnD5qYGN2M/6KB82qD23DFByH4Dc7xIZDYDV0TYA+Xkbsgx6lOvdXZg+5m7cfnsLg57ey/oXbuduSy1u51RclNK6JKDglMHWc5nG/+OiNmj/R7BdAWJOdsw02agBX8Qr8AgeTu34HMSF+LJ/9FG1veYhTVVUIcHPfN7jjYTPpO3cwdwl4HXsNm/MhCqr/w7Kpt7MnzMHxdRkc2z2XkEHFdB7RjYF+Gmv/BbGhBICQWMBJyf5lNIeeI6pdX4odTlomB6DawxGTDya0ec/4ERPpfUNfXphawdGDB8nKzOX0+e27/gMG06dPH3bu3Mn/Ar5o86DtQL9IC6YmL45IFAGxrXjh7XnYftvLe58+z7igw7z/49sM7rcCn2aVLT/CUQd0Dovm+xdjCI/ryh1JldBwZbWYq+ZzfphhnOmMHciOW8BD4LgNwk3gcLlJP1tFqP8lZgJP33C63ziFO2/pQI/oBqzxtxDo6wcVh6jJ38y5VdvY9d0iTiyZR2P+Drb89g1njlawZ9FiduxII2PtFu4eHYJe9SS2RSSJ0UKkxU10gDc9WlmY9sJ7dKrdiG+GyqZl6/jukzfoHVaO0/Ibs9sJi0+qtPCvpiben+DxNyN5YTicEOSE+jIwWqEwo479O7Ix2tOprq68eO2tOjzAxk1L2bL9K1yWOgaO/Q9dh8XReZiCuxGs+92sOVjIaR9v4kab8BWFbbtsDLurHXuU1lQcPEtQJ1++X5tL/ynj8Wyy42UrwxXlj15nhPJiMPtoawI9Wp9Wd/7/ZtAHQnl9Gt5H8qh3nKDMWUNbnNRlWhiQaiIxERot0CISPOzgPJNFaYAvLXX7eW/Gy9hNeg41+zJ8yJN8tPJDwrmOLZRKqDmhCRVeQJA39AqG1i1b0bp7KkPrajlXWcsFddCcgmZKguLoEQIBSak40vayPfcsLlU4nD6fefO+47vvvuPo/u84cDYXH/1inhsJxYXVTHjjAP4ZWzjkY6V1s5t+IZkkth+NA40/6w+Mv1YfqhwV1BXsxWnLQ1ddiYdShbePHzpTMCU4CMCGJ3p0xS5at26NS2fj5KGj2J2XZg9z5sxh0aJF/+9RE7Tu/MK0/2yVgyHDxtK/rhQ1t4osMRMVHESvqSPx5iucNbnsTCvk52/s7LFDr+kDefCzCfi1uh8lyA0nZ9Ncm4AhZMT1J1svyE6eGRXrwYQA8PSGHZXQyuTgt5W/sfjUOVICLHj7/UnuzDsGr9ZjCYxMhpIjqBXlHNx4jrrc9RzLKsbsFcTYGXdTfdrJrVPfYlR/b8Y8NpW7bgqma8S9TLijG5MeHsek0RGMaB3LbYMH0DPWk32LDuJdV0Fu/X7yiw7T7uZETDnbSB2TgvdxyBE/XmhXzYHDbpI7d2NGryDWZCiExCicTG/kXH41Ia38mDCxJzT7kLb9MBd2WEsLdmBr0FjPO9/1KeNe70n/dkZO5IKpGe6+WUfxjl1s/sib9fp8EoKCGXm7mW8/UvC7y0TRySB+WbcLawcXOnMQuf7h9Exspqq5DLXZE/OxoxAWCmfdUJILZ6pA7OAygIeR7EqQohgapARnhTf1zrNUqxnEGeNw5/gQlghh7SC4FswtQFFCWLfhJD9//wZdPJ3c2KUlxTp/rGG1ZGzf8P/c24TWERAVBO36jeR4TjmfHzh80TABsOVRk98ZMZ6gR4AHA7tF8PXOM9TU/lFXzwC0DYZ7O8Md82DR8QYGt4/DmRTFDd0TGNxtJHW52bijQtGFxOOB1n8pXNgD1eEfnIyx0hf3rmzUgmwqCcdtjcFhdpC9fweFhzZy8nQ+p9es5P3v5/PTol8xNNn/sPu7cOHC/4lhXg4lhw7QO8hFt4ceYsjU6QycNAnvkBDK60J44d9fsXdPBRtdMOYhC0+9uBezx3Zc+Z+h+DSj/JzOmqUHaTXqHzAhfJmmmzn+Jj0h+RAeC26Li21rt/Dq1EcZ/uA47Cf20aJD5yt+Ht8YVIcntW43teYmnG6VQdMnkZQ8jI4J/vgntsUgkSj+XSCkBUR0Ar8uoEsES388k0bglTyYwG4T6DlhAikjx9PlhpEM7NSbQaMH0C3UwuB+t6IrcxA55AZ6RNpIbdsLe1EmPknRRLf1p+QsSFAVJXtPcLzMRXn7AALdiTQez6Wi4o/C7JGtBvH0q/cyICyU9K0wbymkOzQT7jmwJWnZeVRtP0lVoIGSkED6dVfYuELBq6uVE9v01Kdvpf3YgaRX+NEjyZ9GvY2qM/kEJHWjtmY/xqJymn5agClnBVRngajQZMdQDyExXkTZo/DwiqXcp4GqmnZ4GppIDbdQazZTpwevZAgKgpw8cO25B3+lmBd8/Nh+LI/Txw/QPXcDByyR0Pg3KMyvguIaaOUNmSfS2HA457LnREcHsfFEGfffpuJXptAQmcKuPTtx/y4azAwMioc3doGHZzy39m7Nh/ffQmL3FBoazORlFVBhcKEUpdEyKQWHVxANgIEmzDSg+QTAMyoKNc6Cq31nAuMGUVOaiVJ5iCXfLuOz177is3k/Qu0Oanwj6dSxKyXZOfjGBlJfa9NWL/8A/v7+9O3bl5ycy9//BUTpIXDACMo8/PH398fbRxMzylv3CwvWbuRQo412MfDF1wPxCegJyn3MfymPyuBzxI8K5a1zQYzq/uj1G+dpRT/z5Gl4fCjklap8vOMk7z77L0orzuJrTMZlS6PToBGXCUK7BJ2fP2Gt4onzTqRrj75EtOsPJl8IjwPPKAhMAKMZTaztKjEjTXatS3VUQmgkinIYT7+hUGPBaWoi9dYWVBZbCFHdBASaKaurZ1TnFEyeUJDpRalNqNh8Gq8zp0ltrxLU0o8Su5mG6jporgUimf7C5yS07ciyX6qY+ZWRU5U67M4F7Fy0j1NN7TAFR2CPbMfpH37jhMFEfXgAZxwKdeegIigQ+7EdFBLITTd2JPtgJQGWEspy09FZmlF3H8C49xhl+zbif/Q32JMOlRlQUYvFMwKPRD3eZ2tIitbROawliijsLU2nlz6YpkoroclQEQiJkRCfAAVbjzEh7jibCm/km6Yiho6/k6fi0phXkYCzsvSqDervIL0Ssmqu/H4nsx1H25ewFq3H5C5iZPtUPli2Bofr0nTSBRwr19xhXTrdxLhxHWio82Hh1h2cranizI611IofSWGxVJ/bQ1T37gRhxYwNjXFZxwUDtXhF0GQNo8mk4OG2466oJbVDXxoCQzh6Kp267EZyy+sZe/vtdImPY8jE4Wxetx2X6zqcY79DSEgIN9xwA7t27brqeaoK2w8e4sD+A7T0byYuqRVGiw8hHVNZs/QHsorKeHw49B7zAEaPSg6lrWbUNDd7MpuYNqkNYT2eJpqU6zfOlVnMbBcKwQ2wq9TBu48/RfXJ9biczZxK34Uxri/BxkZatryWPI0RXVAEuuAEMPqBwQd0/lwPKSL2ZtCrUH4QXC5oVKHgCIrlLJ5RjRRvW0vB8QxKC+uJDhA6BXngdIXRKd6feCukFZnJFSdlm+ex/UQlas+H0QXfQJPZitSmE9BpAl0GDGNhrotlb3yJLSEBcpfS9NujULiE2vph2IMicUUquLO8aFq2nJMZcVTe5427UsE3wkDNGSFoTDjdA8L4bbON0H7hrF23gaDcI6QWl1N+dCcHMo/iaAKfiiZM2WfBFA7hoZBeD7FW8LJgbvQgPNKTGEtLbAYrFk8H4S4FvxAFezIEGCE07mb062az238M/cb1ZkRMFHv2raODoZTtl5FS/z28gjzoc0cKnsYwyh0l/H3v0SUMCetChcvBmQ1W9JuWcuxsNhvOFeG+zPQxFAgLV1l+Ko0zh8s5emAzVflneXBEMh2HD0HNPsbxjHJMplpiklugCVYYaajIo7LSjt7XHyMaDZUv4OMVgH9kK3wjY0gdMACzwYCHRwgns06xeu1q+tx6K2Y82bRp0z82ztra2isaZufOnYmJiaGwsBAbmoc5JDKa7i19SEpJxeyt+WKaslez+0ge/Qf50WVgVwobnCxdt4W9pW6KjsMrz0CMriPQ4/qN80wdMzvqQXW4mbvwR9KWXRLI9vCw0rfnECJNdmr1XkSHB/+jSvjbMBtBpyAOFVvuXmqrc/Ao3cLOtIP8vHQpmWlHqco8S0hiCdawGLytvjTbA/GMCCAi2Ex8iJ3cak9KzjlwFRyhtMyLKmMMxqiO+Hsb8br1Vnblt0AKjtBg2YLLZYajM7SRGhg+biL+A2IpbdThCqnD2JiNeng1arEXdT1jCKxWqLL50lRRQIfb4yndV8bxgjJywRwoawAAIABJREFUivbj3L+LiKIsSg4Ws7nWTmETBPlDWEIgBMdqc9X2HUBvgHI9hmAv/KwKcYFwphhcNU48WujxyVEoHQCxnuAbDD6HMnH4N+Fl8uPjF59hTibMbA3zrjIT01sgfIiJrhNbc+vQAXj7hZJ1Oh130/U9jiNVTZSUbCHRbaOSUjwLi9grwuVSHKqBzKJyKgtqyK/I54Z+rRiRGsvQifeiNFSx4lwVWel15B/aQWSiB6GxvQEPmmrdlOUep6D0FG69nkr8aHJDkVGLx9u9ZAlKZTaVtQ1UVjk5fvoY9uYmtm3dyrp16/6xYV4LLVq0wNPT8+KUt0dUGH1792LEA88RldD64nnWKD9+XryREdM60bbVbbz05nxq1RxumuBF9+QgYhsLOVa4jvi4y685r6olV1l4CqdbqDRVk5l2affLbPGi+02T2TT/fbIbLLjVq0io/a/QBFQeB/EDVyFSUoJ6rpTTv2Vw6pRCRg0M6QodxYmpqYwSMRLkkwMVhwDolujDrGGBDO3YF+pdqDveQjKO4yq3ora8h+LGZHz1NXQJ98La90loOAkujR/t2WefZdqbvQg36WleuwXsm7WIbj6HFZ/C/gyyghQIDsGZ78EmMTBwaDQ7vzxJo8vNj8eOMqeqkFqnJvyrAGUmNFXt+HBw1MCpTbB4LpRngCgo/hr36009oVOYB6eLdLgUkB+5NNKNfokD6Tv48IXnOWnXRqxXNv616jx+/8IC9mQhq7GGwO5n6DwijM63dyAumb+r/QqAmxKM+gji72igy+SxTDCZrjkP0utg8s2hPHiDmc5DbuLbtaf54OuNbNuxiZL8NHZmlDHnv/MpPKG1Nd/wKGISktBVlnBg5Xp+mT+fs2czyAKOlkF2nZPPF3zNC6+/zyfffURNXdXlf1i5HnH7S4iOjmby5Ml/Ob5jxw42bdp08fVtY0bz5ptv0KbNH+WaWibfQp9u3nTsMp4CQxgLFu3n5BqVZwfD7Bk6yIBtV9lUvurIufTrT2Z2Hd+HmdPnEHZzGzLWLAe9Hq+kDvhZ/SkuzmTsbeMYemM/SrmuZ3tVFBRk4OXlh6L8ru9wA64qlDwjpvrdWK2NUNyEciCPm/r5ExNkoIPFjbO5Ba42fVEio/ENMILTG1zxGIwQHaojsWUgNfowzmXtofn4dnQ+STSGJuIoNdBKcWA0+1NnDqOrfx1lukievW84Lz43g/nrLBTpIfODH5DyzagZQWicqrmaStPIoYRbhPrSchpCIumVBHsO1VP26/c4lCIKRMBmI1qgIxAZ7EmIrwl7Tgn5u3eTtzIDY3MNZQ2FqGSiVx2o+iA8G00o4RChg7xaiHJAmAl0saBG+zPv8y/pnF/KofP1b0GjoFQUGNIaciq4mGFh8Tdz46t9aJPcDb+DuWw9eAwlycnYfk9AZCE1gYXUmOGi9OhVcF/n7twxOplHnrmPEUMn42quZU7aCZxXUVZSFEgI9yAt/RzbMuD7+Ysx1JURUCuUGYQTpS7KSxsIwEVMjwGIhwfe3oEEBsej2nSUnS0i78gpSvccpP5MDqeLclm0chUlJfUazfyfJLvMvr0wuDxxi5s+zz9D/s7N19MM8fLyIjQ0lPT09Kuep/MLpFPPXoRfnD1eiikobNxJ747TcHno+PSDr/Bq10zvKgehnesICgUlsjVxEY9c/7R2/Z5dM5f8pLKtsBnnmV+oyXGBUgN6PfV5R/ngo3e5YVRPGirB7OWB9bpu/fL45adviIyJx9s7AOU8105WBviHgLKrFFr4I8e2c9odRrBXOd6JbQmzKsSGmVHCRmLucTs+UQn4Vqo025powBMPqxvECWZvIgOhXXI03pYoCrNWUZ5zACmNhNBQ7GVWajxA8dXRzS+CiaN6MP2OQWRbTCwohzM/QeWRH6FmLVr8SQlQCZIP5yZimuRNU3k4ysYCrFP8yTpjwLX7K1ArsdmEJoFJCsT7GKjw8sAnvxF9kRW7LgE6t8JkrENVwvBUnZgCojGa6zF4e+MI9CDUC23f1h98vUHXGtBDUEgs6qKfyBOhVDtEFTC+MxTWQnHt+WACbyO3vT6Il6b/mwHBIfge/oo1a+w0NhiI6eNHQOd2hFrCOVh7AqkCqi//fACsCTB5zK1MuTmZkPaTUQIj8G3fhtmff43DeWV5CBE4k99EsK8fW/dmMDExisbmOnJqoNwFESYobnBSdq6MMG9v2nTvjhEweHgSlhBLZFwiBp2JCA8DLeMD8bTosetTOZdZSLOtmAtpgeG9B9Fn0nTatLqLrLTDuBQT4ckdKTy0/orXdjnU19df0zABsrOzyc7OZs+ePSQmtiA4+NISz+yzn7CgQQToHSzd8QVR3ZpJKoayTCiqgsBuAwi2jLt+45z2rxdnnvFJxJmxkpr9qwAjSCPu+lqsvqH0GfsaP86ZjY8ulcyaQ1it8ezIhVZ/X2jrDyj9bi5n6xU69e6D/t250COFtHkfsGrjF/QeMgolrxzCnVCbRVNgMAtO+9Cnfyqc1UOH26BtDFS44dApaEynobmGkoDOBIU0gT4UMIBeT7APtG0RRWhUG7JPrKf8xBpoqKfJkogt243tnBHF0xOz20JzlUJtBhgHwEE71C5fC+ouNPXRC4nO9VCWR3DvcRijhcY1Ko1mC1HJDkp/PgpoMZ0RwCgFjAZwB4YQ0boDHim98EnsRKBTj4c5HJ+IMCyGAHSGWhSfUIiPwG00YrRASCXofcBDB+luCIqAuFYt+Xbl65wrUskEKoFHgJNGjXQewKiDW1P8eeWDD2mvpOGZt5AiZwFNQxPJr4xn98FVOBKD8DJGcqpsNw4bWqLtFaAzgCW8ngDDOaLa7MKgrIDyXbz5ZRoO55VHTtDGFA+jjop6B2a9nkqzD698NIdRI0dw44D+BHhbiUpJITkqnPqKYqJbXHI2evtYiE+KIb59a8IT4mmXkkL7lG5075KMqeUAarP0pDTaiTRHUOYuZ+CNY9Hf2oLsVaspO7oHt/sK094roEWLFkydOvWaHluAnJwcevfuw+DBg/H2vhR9rvP1w0tfg07xJ8NVQPPuk2ytF24cBIEBUN7sSUzoA9dvnE8+dN9MdCWoJ387f+SSW8/hcHDs6ElOHi0gPHU8HkoWXiHBVOZn0zZeYwPILYHSagjyvcyXn0dDBug9YfniRURFR2HbspnYwQPR63UQF8nzd0ygTXQPOg0binI6DSKCUSIi8Tq9gupiP1oMuRWaztCkr2XH3r14HMvEWFZAqZKBb1gHPLzrqakopcBmJCjIG3Sa5IPVS0diYjSdO7XmdOZZCo6thboc1GgfXCf2U1uWRaBTIcLkx8oQHft+haJsaFajoeBL/ryBphiyCXnlJaqWKDi6WnDsgug+Ngrmb0BLrNYTZQhgQnAwgRHxeIZ1RO/2Y9/ZKo6UnMCzSkdQrTc6fyu0jIe4eCgOhtqTmEMCMBzOxKCqWPSeKLV1qE4TXh0UFD0EtW1Nl52rWVipjVoGIKBWCzOrUqB3nJUXPn2ZLi3PIfUfUL7sOHN3wu7yMAw9UlHzj3GiLAfv0BIe6OrAt87OicNo82QtO/gPcNugtKiSgycLaL/3BOuWHsVvyVE+y3HjvMa+ogDldU6MZg/6TJzEU0/N4Pbbx9K+Qwdatu1Ix06diUhKpMpZT3RkLCERl9fQuYAgX2jbOoZTISlE9GlHQodeHN/zA8csIyg7MIfy4niqTv6A21XFVZVqLwNFUUhKSmLQoEHXNNDHHnuMZ555hsjIyD/ery6SYmUn3nREQj7ky7cKSOwh9B2isDEKVpx0Mybp6X+mbO08uu+yx10OG2ePr8E7PJE92Ys5sL6QymoPAvWa5tbaTPi1GO7spAUhXwmmYFCM0L5zR356/XVG3jkBvdmMMqA7GdNmMziomJunPwHzq2BgW/ALgpxwdLvy6GoygWcomJMxxsXSorQr3j5nMLSz4dsUhbkyHnvjVmp00YTEJUCjgLsG/DVRWx8v6N8vlU8+CuHL779nyYIfqTq1DwLHU5+xn8OlMZw9mE9m3FwaWvtqu+oDUjSZkT81Qp0CA5Pgh4Mw63vh3/OFynw9GqcBgEqj2kiROPDS29mfG0y5ywu94mZIZGsCnOUQ7oZWcVDbCVqGQzsn2D3g5Gnt9akz4DShhGUTVtUZVuwC316kDhrLiIo7L17LHiAOLczMw2Li/e8eo2XnUfw2qy/vby8mTGDM814c2eDPsVmrMHor1LSCvQVnqLPrKK0F/W0mOCjEmZ00hSdSUlGPerwc6rUbLy/TyqEz8KUKPyAX5xF/B+J00rx3FyfcpWTkHsFfPPFRzNRZ9GxZvZw2Ab7sbz5I6z4neOCBB675fWPjYa3SmpU7mshoqMCd8ysnrA/Bnte0aKzrNEyAyspKfvrpJxISEq557o4dO8jOzmba0w8wqPcQLEZtEPACVLqjYxc9Q5+nrPB2Ym6ys92/P+/cvpXa6CpNruYy+Fuy81eGYKutpWR3PpNiI3DaOhIwMpjFJ+Dl9Q56dVNJ8fa44qebd4KxrTZNOvXmIvqOGYazuAJxq7AbwmIVRvd8Ci9TAEovIDIAUJAQJyw/ge/qj7Xth8QeGFatISayCpqWQd7NeLk6g20RFt8QopWbsJbUgLscWv41oqlL5zheCnuIgPAefPXBo1SeXQ6NBvLrvcgvOApnxkN6MpjOgasGhv8KK0dyyUIVYBAmHTiSYMlx0IUqWI860JQxtLrKU/V86opnmMOLrHOR9DF50sVYBrZ0Gp0n8e18p8bz3E2g0ATNRyH9YzCncG7bHirap+JdWcSZ3REMfVTYvi+JgY/q0CvwxOK1PP71XQxZWAxosbIG4OkAA536daW6YiEfLy9m9QFomQR36pvoakvnaHUtsUM96JDVRPEGJ1nxEDKsA4PCdRSXHcXDDQM7xpCebSbNsZem9Jo/7It+omq6LKevs+U43W42ph0lregcoy0RVJTs5ZgtnJqyIsK9rXyxbQ+VjS7u8b8U4lJbUIzB5cQaHgLmP7arVlbI8wRX71g8TF+z8b17cNbNATnNPzFMgLZt2zJ58mRmzJhx8djIkSMJDQ3lyy+//MO5aWlpBPm2Yu/O3aQktSc6Iv7iez7EAGb28gFup5uureGFJaeouB9Gt7jyTsf/0zjB3VRNzuEFrHV3J6nn/Sz4FGwWcEYYaO8WPEo0n6aHAVr/ScFvpyd01EMg0G3EeA7t30z83YP5beFKOt0wkgrfySQ3H0BpNEJ7HSgKoqoceesrOv6wDENcMs6fVIwpFVCyBDqPhtT3cdQGU3dawbtPO2xqb/xFB/VOiEgG9a/xTNXZ9QQHevHE/QPoN3QxD0+YSF5dPhpfzRBwLoOcdLQc0N5QPwuSZ8Dpk8BqQIe+1as8qMIXRRAeoXA0HvJjmtDuPgQow4Idj7o8LE16prlycbgV8pvshImNiEfuBXFAhQ1+2QQ1yyA/B87lcsy8mciuPcg642KAbgFdA99l4evjGfrEjwyeOJAX3H4M3fkL7PuGnY/40KdPH+3ZAKvrhbu2VHHvMx/hLlb4coYnj37UyMMPOPGy1nLfXSZsDU38skklLBRGjB9HSI9pmE58gf2WIxRXeNI+qIhBQyZxIqeYua/VUPy7fdSrB7ddGYLmUmuoqGPhz0sxi4MAfyNSfZytDk/Kqv7qkTpXARt/3sD2g5vwDvHHM7otoX2GkNBYSQ8vG9169mSbOZDja87ganZA09WS366N/Px85s6d+4dj+/btw2w2X/b8tOPbmfrIewT/JRNJB4RzADduhKNZkPdZKTE74CHz1Mt9lYa/x4RwjeLTXrzuOCPJn7vE59+Zont6vbSYKzL7gEhus0h9s0iDQ0tq37BRJPs8gcxHny6VvLMlIiKy5fGvZe+Hx2Xune9J0ZfLpPnzedKQ6xT3f74RtcF9XqtAFfW3NKnPLhQREdWtivucW2wLz8jix++V6tIqWbBaxF1XIjX7PpazJ9aI43ipSPFekaZqTSXIJSJ2EWm+JH/gsDll+y6XrPvmS1m8KU92Hzolw984LKaAOwQiBfwFXheYep49IV7wjBbQqE8UvUHGH3dIp5sqpPcXIgHTRHR3iPh/XiowSgLxl9toLz1B/kuwHKKDLAO5B2RXNGIf2ELsPXqLo8VtsjjmRjlijRDxNIhYEImPlHqP7lLo30l6eEZLitVTOga0kYyOu2VOYg85OGOfVB48LurEJSIlzaKqqhw4cODis9HpFGkTFyU9jMgjnZCkqEtUod1bIBuf0MmQIKR1V2TuihZSVPO4lB6bKD++GSBDnm4p7Z6YIG2m9ZX7106SJSU/yz2fDxPviMvzF11f0YuRBNGoS71EUYziaQoSz99xz44aNUrOnTt3kSGhsdEhBXkl8u2zs6VTdCtJCR4jPeL6yuD2r8qoKbPljfdfkfgHKqXPpEwxmv83tCTXU+4cM0ayM67EEyIyPS1JDBZFoj9HWh27RU6oLWS5hF+RCeGqQQjEX/XdS9BbaSzzIevV13CtfZcIfXdiq7SPR5hgRxocPqWdWnRMS+ECCFm1HVN5Ndv3wYm4kSTe1gpbYD4VOdnoA2/AekCPct8o8Dy/b7QXFH0SXgkR4BaUnXZ0Xg7Mb2xn8LOzEIs/DqUGXdMqvHPshCl9MDorQHLBw0frwPRAKZpAIoAKRg8DnTro8W4/nIObtzPj309B6Q5aPjcWw+1fgulh4GsgAKKWQ/8NYHsMLS15PiJ9yFvSxGmnL1V+EKeA6gF1/8fce4dXUa3t//fsmt57QktCCYTeQkekIyK9CgiIAiJWEBs2BAUsYAMEO1hAQLChICqIdJDeWyiBkB5S9t7z+f0xUdFzLMf3fN/391zXujIze2bWzJp1P2Wtlec+eVXSHpWph07osgoVqEKF6kMdVbAMjYmVGvr5y7u9RJ6dufrh5E5tzPxWxRHndczu1YBS6YHLCXrLc0q7cvdr/tUSLS1uqbM5kfrq8Lt653iiPvi4gfrcPERdj+SJvj1kSGrcuLF27bL4mU0THTiVqb1e6f1D0pFMUzUSpDfulPaelm5909SmbCk9tbH6dRqmC18c0GODVuiJdTkqaz1E1YeNUvXG6TppBCraL10zhyxQclzNv9kx/kx88irT+gC6KvDoanmOrv6yqMdfkZGpSkpK+uWKgACnEqvEasD9t2nIzbNUaFzQ7lObtenAXH2x7IBmPfWWIj3btf+b4fKWX5PTceCuv6Rh/DOp0bSdBjww50/PuWPWLD06b542ff651p048S8rIrMl1auRpJb3GDr/pNS81kalGaGa8PGFP77pn1rOwF+1gtPpYM70P0g7b4vEVeMRwvsfwkhfh+MWSO8G739dkffmSR8vvWIlwhl9Kzz3GqxaC81rX0/fNltZuBymvgD3rYH2zUfzVounKL9cyl31z+EptzJcXX4PzC+Bkgo1ZPrg7Eko9sDj2+AAeIvOUvBRa7i3Kjx7O2w4Bh+/DZcqcvkUnCfz4C6+PZLN6WIg+wgUXuD4e99y8K295J4v5fLlfH747gy96zQhODoRBachRWHR5aUjRzIKeACNLaDpVJOAaSVowHnc4Zu5bgo434WoEaD7QO1y8LM/QPuk9vRuMIK2wWkcq96A7yPE5XoGR2JjeMdZm6cVzrtyskB2tlarz/rYBG6ziXeib+Rpd1WGyeAGiY6yU0MBBMqftxXAbKUxwejJV4kzWNp/FT/dd4q7UpZYzWOa7Nu37xcSJ6dEvYrt5HDxfDdru3ayWPZaF7KyVvPle51pGuVHRpqY9/Y9fH51FXvK53Go8FXuWNCK2Qc/4xJe5p99lZia/2meIhtWdvq1FfsOpEZINZHqI3VB+rmtRc+evbh0KfsXq7N7zXmGd3ySlOSGJCf3IjqiMY7fZCAMRLLhFxyLjN8mEp+5rhSb7Z9nfXT5BRAcGfOn54THxJCcnMxnn3zCV5+tJ+dK7m+spgfYwBRuz3Nid4uMn8RC0034x/8w4/u1lfv7+3Pxwhkk4ecQN6ZaKf+jJaSqKPRtbBnHUf0y1CgbR+vTDPwYlp+FG4a/zfPPr2Ij0Hw8THkXbn4RQhPb0rrTFppMgevHwpi7oWeDx+gT3YhHni9i01kPJ5ebmD+AtwjMryr80CXAShPKPHjWmhxYWg7lQOYR6GKH/ulw/EP4dDBcOQleyM78iQMb5vPhul18csiL58BSmD8G9vxAeVEJ5YVl+LwmcByP5ypXLl7kWO9+xLh+7gAupJ8/cAAKSsAVkoARaqJ+JrqjFPfNoOvAaAtaDHKdoFJAFV5vMokukVOYkv4Mz4e7+LRRFV5OG057WzuaysEsGayPj+FEx154UuvxmS2Wna2eoqRND3YFdeV1deURdWWcAvhC9YiQg3DdSZj8eFrzSbP35i7/MbQK7kD2pE0kJVZiz0wwfT4OHzyITaKSWzS2i7h4P0Li6xHisr5r507XUXbhHZbPiSI61IVdots9E1lfsokrp3uT/34IP04MY1gHJwmjoth4bDNXKeZC1gWSk5P/dgc3DAeje5zjlZnldE8/iTQbKQypJ5IT69/5w7GoCcXgwYN/07nLrnq5fDGPefe9SrWQWkg2EtWfAFX5y7rDouL/n7qz15bIyEh6jBjGibNnfvP8K4BC8vmIQMafE+54EdJJ2Fr8F8Bpt4nuLSIJC/bj8Jq7yc/ZyNGdnzEprUIrGsEoph/KAFX3oVpl3DSmnFtvf5dqtV+n/pRS4t8C5wTwfwlSZ0JgUlsczpuxjzyP40Zo1uAIge5KOA07A0fk8/I6uLAFttxei+xXP2TrF6YFzh+x4kbTosT0lALFufDKHdAkDDYMhO+aw7rOYPrI2gcHXvucPR/MYtWaPDYsmsHpB4NgelVO9q1Czlcrr2lGLywdA9NmYJ7KJPvyZS6t2EWcfyBSBv+abj8KueNQh1IUWBlNAPs8UBBIx0iMimPOlIXUvv4dmsaO55Eb7ueV7i9xS9p4HlAal1SPguoRlF93A75hU9l+yyCOT1mOt/PTeEMSKL9zOSU3bKH4uqUUdnmIYwETeF8jGKyhVNd4ghTGfRrCWC3g0fg3eSBgCl/eeZFI/1voFj+PU4t8HD5xktBO/XFIBNlEC7uDFInRqXW4d+KT9K4eTIdg8VmGuLSsPQcKN/Pek4/xVLiTJbXEuXtF/p43eC//Mg26d2XHjh0A1KhR42922reQBhAU9D2PbYOcHJMVe0uwss91RopFGo9CG6L0V0lt0Iol67/5TefmMpADJcUlnDx0hTm3vU+10Pr8nm7j/7qkd7yRH3bv5bOVX5Cbk/fL4++tsJ7FBFFEe569bNAwZzhjc2b+M3AOuvW3FdttFq9hcKCbSiFBzG1UnZKCNez46iv6+4ne1RzExAxDNUGdTBzRL+N0NqFOn1VU7w5qDOoFGgVGytfI6Id0HXI+T2qPz+gSdAed1R6nHDic+eTmQ2T4xwQ67XhLSn/h6sxdBlvnXvPhSoG3s6BBW+hfh7IDm7k8uSd4igA4uHQTr/m1ZOvdkyj/cQ6eOW4OdBBL3AbPO9tx8MOt1n3G98QTG4Lp74Rduy0WWwCPj/y8PPLy1rPnwQM8PPYsc+4cw+mTuWx/YhqVZCBHH+ypT6JqvYmKTWHX/GykPsRGdOGJ+0czdMpDTBw+minTF/LF7fX4rsEI8jOepaRud8xnN8O6Inj0dTxT1vJmi+m85Ejg/Iq5mF/nwzmvNaL2+FP4PviW8ncPUNz7c04EziVUU3CrOUPVEz8jHj/Nppu7M+90ycWlmxjrN5ep0W/y0fiPePC+xdTuPYaYkEgGtOlPJVsk9QMTuDlQDExNYlS3enz01ER8Z2by4XA3dSX6GWL/2wPAd4iDHKJB297Ue/c7nr16HbE1/iy16a/ljvTMCusYQWRcHkXlcNc3sGKvD2kPUjqKv4rjzp0ENexOz6YtKd/yEyWZUHi44hv7gHNAthXRlF0tZ8fCAmbdkkdiVNP/c1D+XGwOB0FBQTz5+FO8uv5L3tr1PEVl+Xj5gQ0sxMM9mLgpRfTMdDLefO2fgdP+F6xNTsMgKsCPXrUTee6lIdw5vBsZIXYeTEqib9tnWPJ8ASO6PIBhd2OPnIfRBdQB1B4UdQOWm2hD1adj+FfGroEktJhPF0cgds3n7f4e7LbHkFqzdtIzmC9U4cyEGfhK4dSYClX0NZbp3L0K3v8AzuylZFoPMp9bCsCPn3zCnS4/Nse0wvvcAigeCPPE8SRxm8QHnSfi3fIsLH8IalRltUT2pk0Wc9iK7bzX9UVKnt4CX+4Bbzm+srWUlfoY0/85JkbG4Csvo7hwL2eXLcFhy2BwcF1q2sWTdcMZ2Gk4T02/yCtjlvDi6K08WekTvkoby8n+vbjY505OjXsZ82oJZPvg3c9g7ovQ+0nKe22m/O1dXHrgIqUTfbAImNMZfjgC33hhjg/yvJiLyil6s4zcDifpo/uoqrO45aa79vBQ6kCGjsolQB0Y77+bQQ2OUN3ppo49Eqk3dpsdP4VQUzXpGhFD5xYjCax+Gw/eNZOyT59iSgMREiSeGSLyZttheQjL3skguXoEhssPZ4Dtb1INitmTTbqrCKmIoCCTK1cgJAZufy0Hi6GrLlWbwH3rDiFbJ3rd2Au8PkwfnNoPbz63kXkLl7L/9AW2fL2C41t3wDbIWghta3XH+P+Z9ZTEoFGv8Phtj/P421+TV1wKeDnG9ooU6xngEZMWCkcH1//ArU356wcxJBKdNrq4bBiy6Ppshh2HozKTBkzmjn4DLCD6T0ZNL6KEfBT4GKoxGfknICMZK6az0feFRfgFBiE5mGJzYZMd6SqP1r6TdLvo53RimlBWBE90BnZB3sWLTKyaDFle8o+cYWXGQ6x/6CqX9pSyos1ivo1N57taN/J+hgPW9oBZN/BBkKgl8VanNzC/WQVd6vCARHuJI2t3ggf2V6/BiLRnyL/gMqu+AAAgAElEQVRczKNJs3ntpt54Vz0Kvh3sLN9B77eOcv+4z3l3wjOYXi9F+cUsHjWXRvYgru+wiPLycjwek7xsL9u/93Hiy3wWupbyQ8sZnNzgwXPSi+cYcBEKNngpXumFYx742gf3+DB3m5gvmpA2F74+A6+blA8Ac0yFUioDSsAsMykv9XB6lUnejBImp39BLb1KQ0cPbq15GZucOB2VaVy1iHcqf1GhFNPw09PEqTF2tSTGaE0v10CmBdTjboed9oa45fEe7Czchun5Cd5uTffU/5xBq01CBp5yeO+pn5MrlxMW8SFPvuHB5tiB9ChhdfbyaBms37CZIEVzZ69evzhFHh/s37qTSd3Gk+CqSv3YPlQNa4bL6cLlcGH8A1av/xULanNgbxzKsCceJyf/QzA3YvINJnWBWyj9wSDXE8GcHf805mx1DQCdouqzfw3Sn7ebSHSTMAyDW9PC6JcchBWv2SvKIKQ2SH7UUAdcuhMpBMPWhfRpx7G5gzAkxkk0U3NsMkiVSLDZAIvtYOUQeLelNTLp9Xjg0nn2jehEbFAlhg1/l9WLDvOMczRvqTaTFcKrQwLg/F0w63buDRKJsnGvkcietjewNDGJhhJpEgd37gQTOiYnc37eCMySQsJCwji7Kh/T66Oz24XP58XjM7Gn5+IpK+PhVsGYponnqofv5m0lLrES3x3Nxm4fTZP06pjHvyXrYCnPTs6mzzIfs87CIwXQcfZlJvbPYtY8WPYxXNoNFGLNx/4EvAF85YPZJtzs5cf7TMrygI+AFyvKEqz42wfmAhNvuY/yd33sGFvGq01W0jv4GKmuS8g+nogaF5k4/gTjh2zEivX6Ig3E0GCqaSQd9Rot1JPBEmMMg4fS7aydHMP8/gGkhP3nndQz/Vvuruygky0RKYhgeZBWY7M9gvQGivqMtMUm67cWE2d7g04ZbfEevcy+TXl8uuAceRch+4zJofxLzHruVdIrpf2fA+8/KYcOr8U0z8LmWChfz3PvJVL0gQ3T2w7TDOJi6fX/EJxVZbkuI3+tzN9fTLxDhEpMChENuv/2YSIDRc2Yf33I9oZFDjM0SaQH/3y8JVI9LIbloF/OrSIDQ6KbAn5Jgz+kgjCnocSnToPDtwcRHBRC6XlY3Q4oL6Hg24+Z17gH7f1Smd8shrNd6/CcIV5v3ZkVox7k1WrCHCV2txPdKrhaWkrUkehe8feFtJ50D4zi+FtDaBIfwvnMs5h9ZhFid1NUWIS5836m2g1Mn4/8Ox/GsNnZbJp8cjqTt58ZaimKQh+77r+MO2UfbVWfyRLu+Fb0n25iHjXZvM+k9wiTBrEbuLl6X1YMHsMLI7cz9Sm4e7XJ9osmZMPiUac5tfMsnCtnd83nuHr4MqZpcmC4ibfXNHihFDMZzHJ+ZWuuWFlhmtYx02fiKTHZ9M5lpLYEGjfSN+o9XhxbyMb1B5g34XMS1Ri7OhGsDAI1lQAtI0BT/63S/U/KrRI+n++XfT8/PwoLTRo3NpGKkf1Dqrc1KTBh/pYLJIUuZsF9J8g9eoGTq3ey8OVFGEYNUsP7MrreaJrFN/7LOo8ePUpCQsL/CvDGdInm9NY5+HzLGTjQerbuoSKuIhycOjqN3E/ioKQRTHNwYWQUvqtpmOZVTDOC4qJWXDX/qeUME9r6xw9nl2gT78/e6WncNvTX4yF+ok6wSJKorlCqK5R6sijf/+29/HsiYxxS8G+O37e1CJvDiSSiZNHFt1VXnpRoJxEUFIRZblL6o4l5/hQ5bYJ56Z7bePPpaUyVmBUo3q8UzsuDb8HcPY4jPcVQWQzb97WqwuePd+DWpglEXVNnC4mjdzVlVWwAD0l8VCueELsV0xQVFWGanXjMLkyflwOyPAOv18ttN47k8ZBATNPkSlYWDSS6JydjmiY7tm+nbuUkDrz3OqvXnKFy9TcZe91YFvmJR+xizqPT+Gi7ycqDsODVL+hfeSmbZ1/k4uz9lJzIx9xt8mXyTAqPXIJ8MEe8yR5nAN5bCzDLANNkle0+zJ8Ztk3zNxRlvwDVNDl48CBO+VEvuAOP9HmO15a8zn3LV9PixsHEGTaq2ew4w6fgDJ+CJFIk0nUngWqG6osNu/tjboqlbtW/7rxOiezHtzCgiucXcJomZGd7kLYg/2NUHw/79hQRqIW0rt+Wkp9yMU2TvVsymTVpNVPueJuaDXogBSD5/2FdQ/tcR0RYMMeOHcM0TRbcl4Gf6/99LBojsWzxIsyildzYLY0FHyymqKwYc21LzNy9mM+PgMF+sEGYO4S5UuBtiXnE4I6ZnejU9R+C0+cdjzPETplZRtXsTtx4cgxGU6tDXvuAhkSH9CB2LU5m8thQHhpamQUza7BiUStmPenmpUeb8ljjurzTuRtda9eht8QMt0GKTcRVfETjsQ9Q5JsYRthvG+CaumpeU19HiQl+Di5+dAcr557hqeuXMSA2jDMf3EnmlqVMN4J5UpW5S+KLwZW5sKYpk2pYc7PpEo1kWfIBFaCvJhF8Tb3JEjdLPCERLnGXRGlBAfe53Dwg4R1foaDsdkxPObsri+F2g4X9WpB14QLVJMYmV8Nb4GPXvFzGtdyEaZqsXr2a/t1vYNkzs4mRaFDtPgbfZTJuF2z1mZg+Hx8NHMjBKSu5u4fJ5nvAewGGp6dzdu4RzCKTEzExPC6D0oJCy0o+/Q2mYVif0zTBa0Kdfb8secR3DRMScLzUpOWyn5CjNtENa3Pr9x/xavmP3HNkBs2W9KbfG63o2DftXwZ8+o1L4o4Uf2L+ZsftomstnZ2AgEmYpkn2ZQ8yzhJW1+Q10yT/eAmLWq/nsWEzf/UAvHBq9Y+MSbsFh0bhUNt/W0dlCf+K7UnTxhIeFfa3nu1/WqZNm8bkyZMJknj39UWsHDiQtIq++f33o8CcBDMiMF+ui7mtDUx2wTBBP+FbKw6+KvZ9IM5n/kNwMkeYXgOPZwwbyq/g8WRTYgazKO81Gk70wz6kskXlZxMyRFxVMf6ZaG55oDaJdoMGDoO+jcOYNziMj5+uxocL6nNsXzM2T4xix7K3eHhCBpEh1svuP7Cfm76ZwEtXFhMY/nN8Kjp8WEwvm52Bv2mcUBrIYnxa7xTvdhWVY2Ixt/yIeeZzvM+048AX7zHIdhPV1JJ0iY/9xHNBFeA2hN2wGjKtQvtJFk17Xf1KT35tWS3xioRTD1LrmkEI0zTxlVylJEV0MITtmg4dF2Dw2nWBSNVo2fIbfAUmq+aupn/rRnxw183Ul1h47318tBpWfgHvj/+CR9SIRyX2Ll/J++/C3DFwaI+HG9JeY9uoK5RPf5nOQUGsve4A3qs+zC3lrLE7MCV8ksUZ6AXqmbDDBxeKIKrfzzYU8LHXV0RE+T5iTGiz9jMqtQ9lyPedGFr+EFPzRvNhdiXeKk9h5MZexLVLRYaBzWZg/5ujs78oOIeDxqqKTTVwOpZjmj5Kcwq5W2Ox+b9DswfBLDIp+iifdRO/5YspK2DX5t/Qqs2duxqHYxAOxz04HK2x2e2/fMP/DRD+XJfDYeBw2HE4bEy+fwD4jnKi7Bz9xg2lp7056bbK2CRe7igKDs7G/CAVs4r4QqL4R4HnZSgPgImiklOsu18cmybMHxz/EJwzhG+xeLu96GoXKUEGe0+ksdAsxec7xeHzbWj2bHUaz6xD2rgYEsLEwMbi1fuTKD3XjrKy68jZ0JgPH0ljXPvqzK5r52BfcUNlCxjfbriTFk0rEysR3rUBrgCXZY1sBm53P35ekdPlmqHyJhXgdEjMkGXdJFElPprib95iX1pDHvEXbRtW4tzrM5kT9yBTJcZWnGe3iXu6JvJ5m1iGSr8sb/sZkO1TxQt+IqFi32H715ir3zXb5aXFfCYx3BBTO4sXb66oRxaBrSRsAXYa9e3Mq7OLqKN36ZvRl223z+cBiaXD72LW7SU8fGsJj/a6nYyKZ6oduJKt62HPpyb3VGnM9MQ1LOpdwuPpSRRUtvPqbTmUFcMOPz9mSHglXpcwK5mYXjBv8eJxv4y58jLeqKgKbOZB6RtglvFDkQ//Q6WknDxG9MQR1GwjRvzQidsPzOGRF29k3JudeCvzXgas6o2GDGX+7Fv5rE0CtRzC6TRwux1/CpAoiatXrlKn9lCc7iRq+IdTnjePzNgUJAeJcYlgmpSez+OnKd9wcLWHA2+chI/ewNz8JT6vF5/vV9f8Z1m5dhONMtrSp0soaakBuNzOf/Hk/lZxCsP1987t3i0IT/kIKkgsMT934FsmykuHUla2ndVb5vLqo31ZlBLLmZni8hOi7E1xKUU0MsTp6cJ8UxAgeMdg5l3CW9QCX0l1TLPkH4JzoKBc8JooflAEB4Sw4KuLlJfH8+WnombNYHbt6oZhEzVqiGGDf32haInrG4m3VsZQWBhPWfFYTM/jrBuTTGOn5VruWvc6dzapQ5AsACyViJB4aHRDSkuW4e9vgTVJ1/9p4wVIdJXoHR/F9BfuxibRuU0iZ1f35l6JZhKtKs6dPDCUwqFh3C4RKcv6SqKTRPy/uffiLqKR/2+tqb/dgSvAgUvingG/Hg8PDOTZgGsn5h3YjCQcdhEuGw0qtHCwzXrPcIk0h4hxigS7NUg1ReJ2iTu1kiOfwtKWV0hSPZqqNfdEP0sNWzjrUp/Gs7AE31uw3OnHAokNsryAooYmnmKTgnZFPG1vTG73rrwRF2VZzRMHMKvZME+1ZPN36zHctYnss5qe377AyGfi6Dc9gfGf9eOhJcOp1SyO518cwMJlvUitE8jrAzLolRKLn8TWLV2BuTSoFfuXg0XfFRay3iyneMV47nYKyU2iYx6rem3GLDhP7qzHWfPAC2zbcpTc40B2JsVrXuGnV95g37pTv4DSW16Gr6gQysvB9FBeUkxpWTknzZ1kdGhMYKDf3wapzV8kfh9I5zOBBAQ6CAh0YnP/8drbSoZ4pV8VvFdfAV8p+evmcORmBxNqiEFNxN71rwFFcKAna5qKNT1F7nxhZouzqWK+RN5EYYYICpsCLgqdYqtdmCXR/xCc4YJ1fphL3JQsFHcH+HFo3bPk5Uxm6E2iZk2xa7dIbeDkme/DqXeXkEMYQcLmJytmqdCu91YXl1fPZsvgPkyWqCLx3SMPMzo5mQCJpsF2HjREUAVgrpzqgb/frxYzINCN4980nEuib8V2qMRQQ7QLc+NtGsSqNtbxehI3VZwzKUrcF/1v7mP8e3dWEntbiohrFmR816cvL+wfwbywX+Mbt9sNlJGTM6XimBN/h2jdQNwxKJT0ipgpKV60z6io0+UiI8SPYU6x/CZ/jnQN5XWXk1skEvQ+H3bJo29scwIkGtgNZvbMICbAzRB9TtbWQn5Ky+chw4qBJ0v4Saztm82yfkWM1lT6SzR1CiZFQfFpfIfrUmAXubXEtlsMakmkdOvGw8DQ998hLcjg9l5Oxs3NoMa0wcz98S4+mtWcF9oHsDDKSSeJgQFOTm5ZD3kv4BsQQd1o15+6u067C0/OUjzlxYwKDcUuUaVKJWtg6EQWr1btwvN9+zJ99iw82eV4117ms2GPcn/F2tqy0hIKcnPZMmcy+ysLc9FcyFnBghvSmThlHoezCivg+znNW6QQFhb4hyB1BFr9s+vacCAHk0tkMY788vup8153QkJCkGGBVxI2uwgIFA1r2Jh/k5MfOgvf7gnADgrOjKTwo2h8bwnPgWR85QlQ0piPb4pgwWCxKlEUPCZONRbdneJlhyh9RXBZUDQaf4eNsABhmv9wEQL5gtxH8JWM46cQcU9l4ftA5JwVvQxRo6bYcVj41xFVuhoM/dYPe39/4r6zkfKMA8ULJQjZrZed94gYcYNwGBagtvdrTIPYEML9xNHtHahSyR/JjzckllQATxL+gS7mLbmNrhF/rRWTY4LZ/tqdbF/7Oe0qpkucsqyrS2JafTuPNPxXLTmmlmhaWTj+YFXUDeGWq/rzfm+JixcvEhYS+gvQsrKyOHLkCJIbt9GP3pXDWT4llhcqlkE6nA6aNQhlWDdrMf2ECRPgxFzWDPPj4zuaknv0HUYOuglDIkVNaa4ohkhcJ/F1owRmJoYyzmVQR9fRTfcSpxSayyCg4pkekBhmF0M0lofUEKfEJD+DSzMSKB4+nCMPbqO7bNyvYG6T6GQTE27qhhWkrmTRa5VJcopKlcT1M1rx7fpmbLzJztNua5qpuuxsXzIM1lWitKo4IFH24y10TIvEXQFQ9+/a7fq0IXxls5GblUVpziW6VqnEkd1fcuHCZZ5/9iwDgsN5rI4/9zevz4YXP2T7ugMMbnIfg/oPwVtUxKoXX+D6kGieTErgXJod39J+sOsm+rcOQXLy9dfryc3JwVPyAiVXnyE7921q1gz/jcJwVyjjNqtFTG83pnkF0xRZWQYmHbmUM5qo6GgOnc8kLs1F+ovCHSJq1BGvv2tjyayamDu6kzdJnHpvFFdyMvn+/YfY+UkCp+YEsbG1OLN8JKWz6rJnvlgwQXw5UlxqLYrHiivVRUEPYU4VhAtudTDQIXxL/KF81D8Dpzla5HcUZ3aKjsGCAuE7Lg6vsbRKeksxf7O1QCGoXxRVGUv8vnFUfi+JjO31CBgoVFOohtU4nWPFjIaiXvhvP+AP/cW5yeNIDAlFGkiwK5qwa+KB2x/ugiT6dXD9JThjJaYlRTHozq7UjBdum2jjFOP8xfUS626swaQ+tTD021hy0YeipCiKVm1cBEZa7/d3XKSPX1r0b48nVA7j3a/eZtr78zFswhUgWnRoxk+n1vDI2B5I4tYRI7h8dgcz7xlMlMTA0CBuD/UjwWYBcpBEhsQoifM3VYOLz3C5ezj9HUO4Q80IVQQJCQmMk0hKjOLxgGAW1XQxStYIZkDFtZESz8t6/2BVJk3Pku50sqFJLObr3fBlb6O4+BlmzOiAyykyOouFS2qyaW4f3q+XzO02K34ebk/j1LfPw8AUPnSLqcHisiHMUyPpWTMauyG62SvatULJdVVnC6RON5mzh1B4/hRRMbGM7BbFmeVneXzkLu5O7sozCSHc1SKatvXq8dz4udyUPpbT055mS785bOjbGd93oyiZlULB209Tlr2X20YPIDGxL99/s5GeGY3Z+94QXpsdQfMe4usvwkgJtebKFSDGlwbiThQBE0ROYWd8DKHAYye+svCaLlZlP4crOppRZHPg5BCq1hf9lljP36FDFWAEpUdjufiKeHKQaNpJfPr93XgKn2LTE9F8OV4sbiNWPyw2LRJbnhKPpohbbeIZiYsdhW+IE69L5EwVV+c1xEwWrBgJX/7D0dpjw8UdEu1jxZftBW+IwsNinF00aCpe+laMe1YEZdioTV3EfLRtNBovuq0Qty4SivrVcv5RGS0rBvt5/6muM5jewo3D9tvz2gzI+FuA8ZeoZYg6IZZCuPY3P7vwt1sxcWpUFJUSg6gSJdZ9Ic6de5suoxsyaqFIaRSAn/9/NtDgNkSAS0TFiu43i9pjRfBQJ3ENE2kySLRoUZv33nuAmBhrQUUDibYV1xoSL78wiZx5/ehVyUVDWXF0mKy51+/vrcWlPRs5cWM8KU7r/H5ycH7/fp5ISabw6Lvc2XcCUiMMWW58qwpgdpH1HWPkpLFSCTfsPNriesrP76XolWGc6eLgjRf9CHGL5k1Fj+sdPNYljRW3pzKymp14WVNN66uK4q/fxNulMwvC/Mh+TOTEi8yFNXnls8nEp9UgvGJu0Vnrd+2TUBe33eDQ/e2ZtuBrnmsUwoR6CaycvpEERy0SHAa3JgTSqnIkSQEupjW7mc0tn+VU8zsp6/ECWVX8WRYtZrvF/lGBcHQhFF3gyretmVpTfP98PZpU92dNF3+OnniK8IhAFCjip4pSzyPcdC6C0TeLSfPFGXMHH5ttWXPGRrYpGh0VAVUiuMM8Slbu96xeFs6UlywF3fGG9uSWH+HMkXuZNCaOuHjx9Fhx6jVx4KVObJjYjCcHi5Uvi1VviK9X+rHxJRuv3CViI6wQ7QU/cXlFGpeq2rkrWKyUyK4sTAmC/iE4q8eI9GTBMsEm4V0nfhwkmtQUuzeLuk3Eoy+LgAGhBDMUg6/Qt6vwnxLAlEwnizcHEzHQjWL0p4ukq+tXFzZMYsGzN+Pndv5HwPh9qRIoJlezLNC1rlarCNE20ur4W1+ZyZm9t3BylosjX4jmza1zUiTuefp6ht1cFT+/vzeRbUjUDRDtatvpP7LimF1Et06m+4aPiE63tHjHLmksXTaWuNjw31wb5+dkzsQ+nHhuEr1qV0OyRqbDZM3phsiypIESI2XF5pLoL/HJprW8fE2c5S9rjXALt5hY8f7DJe6VFZfHuqN5pvm9fPHUTL5+53WeTQrg+fpiSEPRqJp48MZqvNK/Gh/cmkyf9Dj8JAZLfCCxomM7Try2kdxpXSma6SKznWjpjsMmO69m5/Nyv3rERhgk/0k7VXe7+O72QfhJdHEG0C4pmkC3m3pJSUTLmotO9Q9lXFgCi2OHsbnH5xxp24/pSZGs7BtCySc3cnF/Bifntuf2ytGESCRFiOndxFcfdyRyih/yE+ojtpRU4hwHyOZFbn1BvP+BeDrfYBM/8Skt+dxnZ+QJ0f3eYI6Xzmf25kl4eJD9+0XT1mLYjDRmbvqcQk8Bh84uYeOPwfhWipOPi2eedfHqfCePPiNaPSNWHRdlZga5WRG0bS2qp4oeTrGrkVgaLK5ME5v7i6UhYl6w8AUIBv8xOA1AfyRZCwxia0nkSlnHJPtB6aYfpQdGW2kRD4dLW4/ZdHpWQ51xz5azwKXSmHJVZ7qmaa8aGLX16PRz+vjhI39Yx++ll6TPZTE3/Tck2inFuKVDRVaOvGhZf+MkTX6wobqPSdO+J7brjvdPamepR3ZJt0n6QdL0VeM0+4UVOnAmW55ir3KyJHeCVHbuTyp0SvJKRpQUEixF3SwdXyPpglVpQrE06u668s+sqRdeWKbLRVbGzVZ1kpR9tVzGyUu6LItS4c8kTla2lUhZKTAsCZWUr46SGkm6kiIdOi5tkdRaUldJhyV9JSnIbsge7a+m18XpjSFxeufrXRr+Yoka2KUB14cpyyvFk6e0q9KzO6Ryr9TdkOKRnEED1Wl8kg6/u1hzz+fqaLVp8gv9QBu//VJexzYtfvFu3fvQWbnRv6TLdEoaL+nFv3g/hyyW60qSOkS3Vp8OrRXfJEuldS4q9+WdWvRplrbLym4fmiDNu0UygiL0YkSiPp1ySOV5HlUdKW17drFejXpRDYztOkwV5e49r+KTUmgvu5K1Q2m+9so+kKe2Vf20cVtv3fbyav24vJPi9bkunXdqxfxCXSqtptpj71L7Ko0UUrpQuR+/qxUzTK01pDGPSin1pQ92SJ5a0o1VpEMfSEeypc6dpKmPScZOqUuCVDNLuuSV2qRJ6bmSESh5TMm5A+PftcGfJpXOP/v4Ywe/k05lSduWS8GVpZ73SN446Ydt0pznpAuBbhU0TJX3h0J5ly5WRLU8dYsuUQ/DrmRFa9/3x7R5fbEMWarzr+Sw9G+Zqv6JOJ1SRGXJESfZsqyOcUlWPtdakur9eFGun/YqOT1Ae0uTVVhWrISyMl1vWh14/vvb9fHGtkrtkKySklM6vsdU4nApKlcqMSvoOa6VCvQ7YiVbd6mSUzq2WFaauSRJp+wqzPLTd5+cU9HpQ6qXaNPBixYz18nLBcrKK1aWfqU1/zMpqvjbUVaOQEuaSzqtNrISci7LtWhPTFkAbiyrw1eR1DbQrRvaVFPTjmGKdmdp96Ewfb8nR5eQzHBDVwMDVTNIqhfg1U+XpX2l0o9IIyS1Lt+v7dvraGX+If0YUaK5txzTjNl9lH9sl97YsEKN+ozU4e/2K7G4QGd/l5DalKUs/koiZChMNmUK7bx6RkePbNbmr3frxXeO6uOjxdpfcd6Nkp6+XYp1Sy/RViuf2qPSvFJVaxSmVx+2KW/TSSUG2/RhxHUKNZJUFPOTQm0FKo1EX+lLReqiksqljV94NWTwPlVrZtOwnsEKMiIVGFxbjTMuKDUiW7v2/KDDZT7pYFXt3L5XH5y9qi0FUttu0nVtpZRaUvEP0sffSan9AxWWHKK3VpSr/xDksUuluyXzklQpQ8rbJMVclorPSycvSLGP/XuWsT+1nB+lGSzxSVerSovvks67pbPHpb6TJJVK9nApbLB0Zauk7dY1PbtKz78dpbLovqpdHqnp09/Tk0+cFvrvWcO/JQ4pIl6qFyP5TkoXcn7LMBAhaaoshRHbSIrvMEFm1BXlb70k+9qtuquoSJmS3sq8R4MSn1Dteok6vi9fSfHSHVOll96RcrKlqycqblaR6d8Il+IHSueP26TiEOlInpQvK8tzlQDpWKR06m8wBf0XJNGQzl3zeaMlPSTpLlm5zmqFSpNa+SnWEagvvruibR6LsyQq3FCHdnXUzE96ce0R2S+Uq36glB8opeZJ8eXSHkn7A6Q6naUJ/aXz++tq7fL9WucM19Ovf6gWSdv1xNSnNeud/H/07C5JAbLI5cokNQ8PULmJduWXKFVSsqT+kqIk7a0lnTojLb9qNXVSSi09901V3ZQkfTzyKy0zfCp+uLPiU8bJ0FnFe+5UpEvqImmTV3roQ8n+oWTuku4dKt0/PVQyGkoKkOfkJV395LBKXIVat1M6HttMwXFh2rlvraLbSxMHWYnsMuWnNZs9mvupTxOH1tCwml116epSHVxyWedyJe92KetrqcQuJYZJTY9LJQnSOUkjzv0Dy1lbjz/WJF5K6StlLpUOnJNueVSWL1Uk2byS65RUWpE3OdwutbBJzfyuqkpMiS5sK9E3a45p4+HS/5o1/FvikBQjlURI0X5Sl6oh2kG4vCVF8nNZLlqJpExZSfiyLkiRNY+oWbuBCmnSU3O+/V57c3OVWluaPspfIYH99dmxJSopcmt0pyLlIv20VwpoJhXlSYqXAh2Sp0iyN5Rq7ZdKnC6VRNeQ4X9RTn/JrLZBJEAAACAASURBVGqXDJfkyrZ8vX9AWPt3xE+Wm+xzSIPrBWnHxV9VIrIs7qmK7QA/KUlebdxZou/9pf15Ur5PalzPoZsr2VR8wa0jZaXaVlSq6sGSN1XKt0nbiqTzphTawKXAkAAVFHl099tZMhP8NXf2WKVXDdBhf5siK3m1Zs1hi3vlj8SQFCjpd/xHPlnN9HO/OVfq0cUyKzXfHZKqy/IKTkr6Llva7bH0Y1pUDd0zo7sGNTsmt2OoityZ+vzgRWV+eVxK3qSk+Nb6oTBXVfwzdVVSJ5vkqxmq3fJTRFiZpo60KabAX7pUKHlzdLXE0AVHnEIvnFdaoBRWek4nL+Woeu8AtbjRK49pkxtTO4145VbyqTyoXKdCS5QW0lc1/Tyq1fiMlq30audZKdMn1eoitWwitSiUqjaVUmIl96B/bzn/NKn09g3SNznS0iVS1wjp070VP1ysuNgnxeb9SkgV55ZaeKXydVJmUbbWrSvW+p/yZAuSzKJ/U8H/RGyS0U6qjHR6w+9+c0lBIVK0VzpbI1ybgxupQ32nzu7ao/xzF7StIj35QZt0ECsT7eo38jXu88k6nyt5XdIN3aUhEwyFeI9L5zKVdT5DzUedV9ewUnm8hTrQxasvFkmOxlI9r+RMlM4kSJddUlS25Coq17bLR9S0e4jiUpK0dquhgjJ/aed2i9EoW/9VSUiSWgVLRQetNNYlLqm8XZj6psTpwJljOrzNUkjXNlVevrQ63wolnBYVqSJdUqdAtyq762vxicsKiMzT0Jti1TyvSJtOFMs/VDqdJR3ySC38/VW1RROdLNqophllenhEiMwrSXp95bt6PzxHW6f10a13btVzj/5J+ke7FJoUqs71Oqsg77J2/LhB2X/h16+XVFvSl7Kyzd8oK+N8pKRhcQ00tNJ8uS8aUiWHMrrfrcqXR2rdKK8OnM2U67WJ8q87U5/pRw2UlC1DjzhjFNUnUbboDUrHlJbkSsW5IlkKiAlRlcrxyg2QzDwpKVC6dUS0HGnBKlG+Vpulyje8aiqb4uTVhWZSHYXI1Cv6ek93hRr+OnuiVM72ku8zKTJVWm9KaTdIgdukPPcfU2f+qeV87rbHHzsSIIUFSAt/suK1nxs0qE6QBvUYqoCEyjp8+LAkKdeUroRK9WKloswSrbpQqG9LkOGSzOJf7xsoS3P/syT5kgwpbow06GmpT13p83d/97NHCi+SqoVK9tBYxbespxo1Y5VeLUjF544ou0wqLtQvqsmBZW1OFkk+n3Rje+mRKVL9ZJtKzndR1t5CqUEj5QasVvOB7dTQiV55PUvnSyR80oMPSw1KJFt9ybNbKvVKlTOlQMOre2+J0M0962p7qV2n1pRIuQXSmT+myfunctPN0tyE6srOydGqPMnwSs0TSvX4B8+qcuWvtfo9z7+0d5ksz8Ely+J67E41S3SrR/tqOu6L0Iodx5SjAt3/8Eh175mimufPaMeuUhXmS1eQcJVpwohmyi9xKTw2UHu2ntXb077Qgh+Oq2rheY0ae506t43R4hd2qqAi9jQMKSEuRIVF1oHAIGnE6ES98cpcZTTrqIP7Ptfh4wX6MzkjaYcsF1aylEuJpPaSPOxXQ3kUdMgjW2VJYcXyhYXoo3knxBnpyBmpU9M98kReVRXZ1FtD5TB+VAvnMGXEbZA+tirw5kt5e6WiWK+cZrFKwzzaYUpZlSSjboEIKNcppctlcyvc5tBVhcmhPF1VsjroioyNFzRnzhYdPl2qxmnSPbdIPQOlMIdUHColeaXwplJYU0np/4DZ+piftP2AtHz3r8ccLpvaD6qtu5+4W4sXzNHLT7VV3759JVkde1Omdf7B3aaW/uSTJ0vyZv32vp3TpPFNpYQga7+GpOHVb9D4Sq3V0JahdnLoz1IAG0OlbgtsWpDaVl2j/KX0a59PiqokZbmtlM/HfB6Fu4M1pk8rtW2YoVppVZWULAVHyHKlfL8asTOS/BMDFOKy6fgn0umNUTpdnKLchDOq0i5YrTMa6IKtuw5G1FJCbUmZkhEn1Y2vq9um11e7opbqNlw6d0Gqnir1FKr61QW5XvpErV77VkEFByS/f6WD+B9LD6lue0Nrcoboq/adJElh10kRzdChw1eUZLjkleVBhhhSQogUcA1NY6kkr6SGLrvSooJVkBirXa5SZZblac8hKTOrpRwNJqpqSlud8/mr1LTiWXewdGjvPo3qXFcxDXrrvZNVtN5rKMZfeuapxtLeT6WDQXpwQJVfv50MRYT5qV4Daz8iSrp9Ur6kDYpKCFL/MbXUttV/xvSaLkvhZ0oqqSyt2CrlH5T4cJW2vzlXN1Wu9iud7afS1fcuq16eVFk2WePaiZJSLWuRJ3FJ8h2Xrh6Xctf7tH/PVZ25KGXGW+MvXLDJL7dA/jqlQpXqqEp0SOEKUwvdoupKkktXvpbaF0vdU6TR4/wUFzNKsa1TlG8Y2rVL2h0oaVRV7T35x+/1p+DcdVEK+B1KAgP9NWPmOE274Xod3vmSln80Rw1bx//yu7dc2nZF+vIP4oyIFLsGTQjXrF4udQmxOLh6SHo8obHm9XtYd/ln6EbZ/9jfjpVsnaSOsuusbaCO1uop/1bXvJAhufxkWUW7VCvVT0NHepSos2rctIYSGzdRVFSEqv2OWe6irE6a7WfXkXxDR20puuqOVEhYiWJbpCpZOYqtNEE32nJUWJqqhCqSGknpgVK7JiGy2Ubrhs4tFeGXqNRWUnArqWO8FLdeKntJCj8jOQrK5S7OU406UloV/XekqtUmu34wtCftuM4V9JcaSvYa0oH1Hn3/2H2a+3KeVDdQNsNQZJifUmoEqVLN6N/cJlJSVW+p8AToXGmUfsq/rBxPkeqGhCrBz19SNfn1qy5Xkp82STKCJcd5KdtbpkOn9qtxXZvGjR+mbrem6cHJ9dSySYb041Gx/HPd2j5RERX1mKBLBdnq3rGaqlWTkjOk5S+Xa0fmdoUFf6Ab2rrUvfV/RuETLCuR/x5JZ89ZHsHXeZLviHRisfTc7NfUpuavI2PlZVLNrVIf+SQtlHSdpPclV3upvl3ySma+NXhTsFHau0o6fkZy26S6cf5Kjg1UWSHyKz2oHWczNeNKgHYpTIbayCa3JKdaNrepRxepW3XJ32GX1EiqMVafLnUqMVF67SNp9uwAFVRr84fv9aetYJO09xp31O02NHVKNWUkXS9P2U6dOH1Ik2dfUFSll35z3U/FVvm9VHVLg4bUVbM+XeU6sUIjlx5W2XmppiS/ssNS7ER1G1KgVW8vlMrKFCZrVG7ntTcJkILXGKo3vKm2cUFbym9WYOoVldddpwSnFHpJyg2xS/ZAhZUWqGuTXLVXjqQOuuDNVmzLRLW72FAnPetUnC0d/92c5Y7jheoSK3lK6quyFwXXjtUhew01DuusQjm1S6UKqe5UbkxTpXXdpmahknRMhhGg6IwyGfltVbv2p2qUVKDEY1J5tnS6WMoPkvydUmpHqUeklFomrdsn7cyUfvqdZ/EfiV3SYmlpRqquC3tXgcWXpHoSxdKmtdZ87SW3pN42OQNcqhnWWOHVo+W+nCtv2rc6f9Dq3HmSfvBItcqu/n/tnXecFdXZx78zc+/ee/du7wvbOyzL0quwdIJYIqLYSDQmFjS+JrElmkRRE2OPJYotJIpoVFACSFFBadJhYWFZ2MYWtve7t8/z/jGLiLKISN43f/D7fM5n7sycc+acM/c5z5nnec7zYN/nIlAxMTIXrrSrDGpZCo1u6NxLlbcLNxBnh6hIqDyiYB+gc2FMJ7dffiUXTXaT32xFXfcREh6HFB+hbk07E4epfLBDR1UhKx7M5kB+c89Ellau42hZJy+9vJjXrg/F8VoyNR9/Pwnvlq/9Lq+DzmT41AGRh6G5Gz6fDwHpxv3EkUYEyNFhoJKF6DZ8dTWY+9SDEg3hoKSD4gLndjjSBNXdRhzZMaOC8OnhBEUHsaO2i8O7quigEV1tpF4ER1Qzhgw4DAZ8QYqtFPAZxDBoPpgfJniUwv0PQOq1YK84QHbWlF77dVrOWfmNc4vFyr33/gZYiN88naaM6/E4ofYMbAzyrTDCBhcNHEFKfA6MHcuYGRFMCjWiMbc3H0HSOojWi9HEkNGJ0TX6fK2eJCdMD4QFv/PQVLWa7R/txFMZQ+bP+hMabGPez/KZkBPA4IJoJl0IyfEChONvUZBjq8lNrmTm9CHEZwxE/4YAOxJDF/r2ZhCLl5LOYXhlMvHKULbgZALCEUZSRQwdE0eTl2FjlMlslFIOoFnymTg+gSkFF3IsBFwWOKDA1jiojIcLJsaSf9GPuGJ4KpdeHMvVBdDnmwGpvi9Ke44+P+tWQYNzDXwJejU0KtCQCugCXW6UKeOIn5DGNbML6JtlIy4/6atv/3YMw4fypgb8LTVMDYnjlssvZ9iIvsiuN2l68fe8+MdtuLu8jEuAHA0CzZAb78blygTCCMXL4LArUdUIIAalqg7VIRxZ1Uy4z1DliEB7i0LaBRbGzR3PhLS7MdlgRCcU39/OzhcKWVd49sMRBSw+AI0uWLsVnt9j6KTX9ggzrT+C1GjIGqGAPg62FYF/F753umHlZ9CVCyFgDYS+NuOTZ2cnxNfADJswQHOwobSBwup0YoKGckmqhak7YPv7+3mr8VOO4QEyILE/DLAa+qBOqP97A4c+fpnPvvDi16G1HQpyoeGzT3rty/cMAWjGzRwsvEOnGsWHKcOwP3wfjg8egz2nL+nQIWYIdDq30t60i9Co2zAl76HW2kJ7O6iyg5bVT3JsXShveo3PwQnAvgRIqo6glhbiYsHdBYH7hLLCnXg86cQ6ljF3ZH+2t/mZel0Ol+eEkz1wFpvqS7CE2chV/dTUbife3EKsfIJmvgrPgLG0RRdT3nnyv8CLMSFUAMsO7iHn0lvpCogllGhCcFMFxKBhZhDZyVWUpqn4+oZiLKT8aEoWo8Nh8IUDWfnoO9hHabxf4edwPHREaNxycS79x95MtvVD6O4ktWEJ8Qcw1mM/FDsMKq0pATqg5Ygdkh3gU1HH9CMl2UVO7gDi0h1MzBuHQ+/ixSYzmXl1HNrnIRjD+KG8GSpb/Vx4aTgJUQlsOeDis6NlxK48wqfVkJIMIQKBKnjKIcrZRIsvhlKnSpw5BVVJhVQfrFyMmJpYvRYc9RBcD2OAjwTKWhVMBZEU2+PJvTKGaBmMsns3d78HzSrs/wHDUAGM9sOu3cbvQ0Bxj7GIdQTkBcCVMzMxwtomoVuDOLDITW5dMShB4OiGwYACqtkQlmlAeIiKNdEPAVaaVRU17igXJAUQziXEDC6nbO8OFm2D9LEfMTvsVwTTDlF+8HxC+4FuRIclj+5m4zYIuQvce2BYFhw4jSnY6aOMfSOnc4STX627F7gBOzAlPBzfz+YYo96/96IZGIrrfdWwYc1eNr6yg5blO3hrVQfr24wl1f4uOLqsijdaw+lA5eZoY9a6LAsqeswXXC6IDoRjuyHOBEU7gwkKjsPiKuaC+FAuzosgJm0wQ/N1Mgt+gS02lqHhGu2FBygu/hRf7GicDOWLLUXUdnUQnXCy4KEDg1MDhISm4NJb0CSQraj0J5AgFPoSRAdRXKuFk5M7k3VpkcBAjMVhIjCZgIB2Cn50M/UJCgFjDenxlUmBzJySQkFaKqY+V2GKzSM6M5to7eyjX50SxwWd4kNxaiTmTic2ycWVgyYzNNnH3IGp2G0604bnMXt0CP4unTwbZAdCRBiERfWlw21if5kPX2Mzg8aNR5vwG/bnz2TcRbkE6la0OihrBjUaNu/rRuKCWVYaxYd6U8/4NcCQZLathNXlhkXQRgxC0TSYNs5P05pyEplObGgcXRdn8pET9ttgyw9UiLcCh7oNGcI+TrZK8zfDAxmQUtsF/BjR3fjXuLC3tfHJevjyczdUHzEYTRsEug1LslCg1i6QEQSxwXQUdlO0vozajg5UBjBk7N0EFYygYilsLjlIOxUYlin9oSuAPW2waju8td0w1/MchKQYGDZ5KoNm9d6XM+ecAt5KL4vf+Tu3TJzAQGYxFQgJD6RzYj9cHxzstWgbxtLJVAJNTRBcDeWr/kVtfQeJGMrkd+rAHxhFqXMhQwZFcJHJyfgZOXQdtlCYG0dd0Sra2sEWZHA4uypExx2lMSOftiSVX4yIJ8vRADFh6J35BNjN9LGncPjIIVxtbsTk5YMt7eyu3sm29Xsoqa7A6e9dpVF7yE1IezF2uYQ+KLRgLMsCgUBCiKWNjZFBjMfKCXlhPOBHDThC0FCdpkI7+f3a6a/CVbkKMfGBGMZzMXg7CincA5VunchEaD7XRkPiRvppOBqtZMbFE1TTyoxZE+lnDQWCUcUDtnJqM8xkdfroEwo1MZFYM0Po6vBzzO/FFx3P4PEBRHsnU3/hDHyfv0L9zip2+110d4MlCuKz+7O35hOSzZezbu1SgkI+YNqoZB594TAzWg0jgngb9HfCPzC4QU2gSkFGGlU48XKMJL+dzg7oOEcaptJergdngRIKEp2DQj/gEI1NJg5/Cbv2Qq7JS7UHEpqBFtC8xqdODpDRIHBAQ7d5yGtpYcNO2GnrJu+KfUA1rKjDroMlxIvCYSDP6G0A1OyD1VVwWDcmC+dyuGEtKMooBg/tnQTPnHOK0euurd389oYnAYinlUfaVuDdlQ29C51owoiAHAx0t8CGvbBrWyNltW52+wzLjr3Ax91rOTwgHUY54OppXDFjCtNvfoqfxJ8wvDvWBRUCDWWwu60dh81FSGwcGZqD8MQRYBqEPTyBHF8IjrpkvqhuYlsbrF2ns6Gyi7KIAIaPjOS+OR4GJff+bxg+azoeUxi6KDQAtp7rgRj8MYBaLiIGJ4kYYivB0JZagNmYrCXkTpvMyAEwflwQMTMuoJscVuDjefazraaNfxyqpqZL6G4747dw5hCg0k/ngC8YNLmSOHcV+REqxiTyMSbTUWKCgokO9FIXA32jQ7l8ZBQRGR7MIyOIy9AI06vAG0dCwgCGDhlG5KCryZ+TS3W0iX2ANQ1qgkOJMHmp3VxF0ZfL2LxsAb+a8yp6WwdR/eGm+cFcNdzgAiYFlAyIy9d5IqCUgSwnGxOhESkMuySKlu9JnNa5MHXRUPpfE4o56LvzhyRj2Dj3jcWwlerAprh4Z7PB2bf6wHcEg/3WKojLTCPGnoWcbqAlBKUtlqr9sKUGjumh+BkO5TX8ZtBR3vs13JpiIZImoItfUsvzfX1sOgqbDoPva6uC4iJAruHrltHfxJkTJ4AOvhKd3at3Atdix8XVliSeDso3tMLfgSPAGqCiFXa6oasLEv3Gjol2oJtqwpP3o1W2kzj7UpRJQSReHsaYCSNPqscNVDRDP/Hjr9/AXSmdJNi6MXhbJwEMID4gh9jwDux1Lgo3wWa3xvrCY1hKPsMbVkxLpZOwrt7tikvrdCKyZ7DBbOUAsA1jxWiU6AQuIJ3dDCcaQxx/PKCsBuShmZIJ7avickBKXxdobTQQyQrW83pZHbd98hFlvm4i/eA/E0v3XvDPC2F1OJzSOLMSfI2tbNwSQWpBAXtffxuDDxRjpYKoVg3Hfh9ZSRAT6yTO4iIpOoa0AVF0xcbTnB4Dkc2g7AdtPX0GKuyp9HGs009ULlQftXPVxcEM6XM1AQ3JFC46yj/f7OCNJXvpDm4k9nrIjXeReOMqrhsJ1wpII5Q1Cs7CemoRNvIlaU4V+8HvZ0IWdT9E3AM/v2weYR0p+EM4/TowAepDoCsdUGzAEhSuI1B34/NDbE/xOAWItEJIDprDhIkYOoHgVuBoA4q9HO8xuDJhKFnDEjjctQgidzHsApiRC0lWJxpmYCsbqGXfOzrpwdBabwjDjmPJUyCSybRpvfH570ucAE5oavJwxRUbgSDM/hSimv9pGDl+B9oxrIz+jWGIsRZDOvoJhsQWoPlQJbtzdJYffgl/5ECwF/K7bRtOqkcBYmLgYKnGlFFj2L61BEtALsaCZgIQjdkfjqskindXwoeVsPlfOk3H2tjVUUJgWxPpmkZbDmgDOCWuykknqU8qeZqJzRj62FqOE6cNaEUhmhT6IYxi11dfq2C85ixcVhfrJg7h01FWGqMiWckuStlBhWUPlaZD7C4SNh3kpJLfC+/Bc/tAn9rLfQGp0ilureChd5cTMjkTWAwMQFVnoql9aDgKpQehVIsiJHoAU8L7MjE1FfvoULZlejkW6AA+ByoodbzIgX7tOIMCUK1QMCea4QPvp2DwXKLD3mLk1G6ohy4dckd1Yi0HZcYkuHgKvnSouhQKZkFKBGiqjwaOsAsf1cGvctlUF7Nzz7zrHXsMIWOcJZmr5wcSFc5ptzP1KwDnClhhGQusAuaDmoF2hSEymY0h6VUAVA+YWlFTh9KHZIYA1VWwe0sw9M2kLjUGa2gpk5LS6Wt9EILfo2rPZDpqwEosL7GdfezARid17UJmPJi+IVpoqQKWFrB2be9t/p7SWgNeL+zYUQf8BHPYIoZe/QeuKruBdz48OV8QBvV/0xirHmN18WuM5WwXJ0z5nFadcivUDMhG1N2gJLMn4tsfZAEdKlfNm0Drti385KcTKWUn6fwaeBe4E4fZS314G6Ft0FgGhAqmcmj/XPisn5NNbth9GPynmrBzUzji6cTj9xONYau6CmNBmA4U8wF5xKHQgsgeNi76gqLrhhPH19U+FnwmK6WxGqX4qKOay1AJIpQifwMmzU9lNMYH99naHT8EO6rh1nUnCz5MMWPxNWwyTg6Dv9XFnnmD2LBnBRk+HTImonRcjLJbCPNCZjU4+zQRF9JCdsiPWeX10WR34g6J4H0KmUU1fXGSGn8bXe2rcLurqTwAceN+gSlwCHY1iOt+8QB/LbiGTJuLqWNh14sw94tfIM1LqCifT/6DW9g2cTS3rIDVd8CU8W7+tn8lu3Km89n2o9jvhLqKM++6ZSpclAZ91VtZsaIW1zFOuyexcg1cuBpee38/f5odB8otwOf4WuFjDX4zDJy7oT4PkhoDYXIWSvE+kqoVJrugIQkyohspeaiTNFs3WxUvz7y5nvT6g5TYdLq/LKNSwFLQiKfGy5s+EwcbCtE2uvAMAucpZuARv9502j5+f87ZA2ny4Ln/IJr5KGn5C7ntDz/jzoeh8A3Y/vFIFq18mXnzZpPdiyWMBWOZuyMFjlm+NunFQmckeMM+5QNlJ24+oW7jyaOuAD9N0xnUsZtxIy/lzWIHsSQAjwFz8ANtqontrmDWHAYcQCP49oCeBvtNOjs9Ou6gnnvfRNkxbGNHotiNL83+nNhnqgIZ5IMMhpbPgQHkTbuKJQueI+qrCqzAlYQzhLsZzlACCCGTEsLx8BE3xlWTlz3emKWav/X0M8d+QKCi8eTLd+XthVyMqfdXQAYoHhdB5g5ImAYUQFhfGH0RbUChH45Ve+h0+TEP2ost3kmExYzJv4Bq1tNGExU40K1e0kzl2BQnHidkWtZgVlsBITZuBquW7uD1rc/yyKs3cNfS+RD3MKQ9RtzAG3nj37fz+uLxbNkHz7wAKwuFB2zHsF/6AY/bQFfgLy9wxnA8Bck7YWXZYeLnOAj+Dn1x982w+Sfw2aR2/qFMApJA3sbihif+AhW1cN0loKWBf2Y33bsrYfoEAvJtZAyDbBUcrW4Sg9sZa/dykwOyllbzxhM7ePGRnbyxvJVDh+HTZ93Ut+iUHPHgiHTQ0SysPwruU3D1Xd8hBPxenDPQYmHBrfcx99mHqHHARSvaWPPoTszmhYzICyI3/T7CzaCbAjERxrKydkKqNjA2GTZ9cbIZzFHAPh26C8H99Y2em2HKI/D+nlYGDQ1B1XR8lRgsqUcnlKnA54kQWtrFU0m5jImswE4HBhuKR8VJKoe4LqiePYmw4zCGiNcL/j09u7V89G5573RzMCQYl6YRiKHr2osxMb8OjOYj8pQLIcSBUvI0QenQ8qCDgJuPV6ACgZhYTxa1CF0sZT2ziCELF50B6UTHTWZ5xBff2ip1RhgNbOfU6+GZfdjsyIWMtXAQ2AK2fW7unr6KLK8TZB0QB+ZCCA0gGMiPgvg0aKwsRjrGk2O3sGTrM3REqJCRxn2BtfyaySTSSIytngBN6AYsX25BTboMbPcCS+jfP4l3V6/Eabqc9jde5P2d/6TO3w08RlNTGcHhNuq74MZgqG6Hnz6lc6ymnTv3QUMDPPDAmQ+BfhfUD4OVN0LNdmit/o4CC2DRn2DJ36DvJYvZOVCnzP85F4+ZxlO/X8PViok+EQPxLttFS7yZsNFWvMs+ofaQk6NWY/dIwDuQYIOXOqDID51unX3OE/uUjxSBzwc7GsDrw+BA7eDey9m959P5EIKpAojZjBQXIiEhNulsXiwLFz0pgGSnqCLFF8ipcEyq5OnOdZL3x1vlyjGaTOr3bX8yt/8YSTpFRLKLihHTTORO540y4b1JRriHrzkJs2rIlq0m2fl7RHzhImIVkSgRmSsi94pIm4gslbVrbpYA8yl82aQhJJ3eJ9AXRUXiFSOAQbOIPCgiL4tIq3wsLmkx4izqF4i4B4nH85gEWSw9PfeKyM6eNtwvIveKV66VNhkvIpr4JVJa5Ub5897lwiX/c/JzI+YLQVd8t88iC8JIjHH5po8eu1ner60TJiEBNkVeKksUy8yJ8qt7rxSPI1vEnyEiLSLSKuvWLRQVJHcgculcZN7NOeLxTJFD3qHyRlGG3LRclaz9AXKdc578RcZLmYTK229qkpiAXDMfeelu5OfjVclIDpfE8QEybligxCWqEhYVIhOGnOxK9JynSCQwETFZziz/8JnIgmikavsY6XQhLj1HOr1Bov9rkjS8pEjnTQnimhQoTRdniO+OwaLP7iv6LXeL5w9/ku51r4njb29Jd+FqcW97ShorV0jNjg9l09O/lWl5g39wX87KwRcESLqmSV3NUel6FAkJCRHd5ZTKynKDOFVExuefkjj94pO35FPp+8hYmG5crQAACDBJREFUSQlH+s5A6H9yo+77nV1SU7/tQ3bUfESzI/WOF8Qa+e3IUqM1pHsxck+sJiKX9CRNRPqJyJ0iskJEnpPykj5y/exTDIjGd3oE/KSoSDwiMqF5gSz0d0tU2yZ5XN8rn8ld0izTRJcwEQkQEZN4PMFiMmvyytqHRcQpIo+IyJ3Sqk+RN/zhUuLJljtaAnqGNVn88rJ85HFJ6lN/lcEW5J6hyAU5CGPnCdnPCfQ//Qvdt0+IDj31PQV5rC5GMCNaoCYz22aJGhYg+Y9bpVMCRCRbRBaKyHJZt+5BsZiRy+emyvzXJsq8m/qIyHQp3pUnt/81VMa/HC2Jr1ql4FCgbBSzlAuy0Ylk/xyxxSFBgYilZxzDNU7ylmj+jqjo/9fJbDGcokVHmiUmBomJMUmfOEXevNAscSHIBJsqL5qRSRZNpgWa5F6LKlMD7XJdULDMiAyVP4eEybjoCPltVIjMiImQmKhwiQwJEovJ9IPbdlbE2dLcLG0tLSK6Lnp3i7S0tIjoIv5Wp+yZ85pk2xH5ZY6IVH2DNPeKyHL5UvbL5EdmySVjkYkjvk0QViuinmL216zGMSws8JSdKTAhuitBHC3xInK9iMwTkUMicqmIvCpuSZVGuVnWrs0VyxnGwziR0gSssq+oSHQRafc7Zbauy1y/R0brXpklP5e/yduii/rVUPl9qrx7/zPy0d8/7uG13SLSJX69Q5x6i7TrhbLVP0lExokuy8Qvv5RSEbnh+eeNmCoTkSsuQJY9/azMnrtIIPv0bbw1VPizInzVt2MCjwuXFomiXCadvgbpu9QstodapNrTKRGrW6TN2Sy6lIvIwyKyVNqq/ix//71dBl1rk4QkVZ68Y6CsXTBVlvwxT3zea6TL+Zi0uj6SFtc+6fC9LK/K/8hqSZY73kbCnkCIO7lNCsiCTMNzft2o3r3nn8u0eDEybtwPqyOwZxLRMLwWaj3J0nMMwQhlacXo0/Hr57IfvdHfaX0I9RQ+AV3gmBf6mCkvqWRgzghuTlJ58qlbYHYMMBxYBhyAjlaWb3Bw39MamdoWYh2wbLOh0D0T3JcGT5aDTwxvbX/72j0NsAUpXztTMJQybsCE4AE0/D4dl+v7buk2XJEVFd3NnEP3MWJ6ONoBhaEquPMhRXMxHRMBuHq8fRoTnN+7DJQaTOYG4FHgUwwh/b8QLkFnGRpzEIIAH4KVupJFdLe+ycKiW/n04VjSx4azMbOUyrffhJK19CYtKq0sZeiIobTVH7desAM+Q17vy2Peq8N46ZdeRH8bu92CesN9LBzzJVFZWYzPexBQEV3H5/XQLNDkF9SK92lsfJUYcwSFe9YSqsDS7Srvr1fxNPnxoqPgw+cVfMJXhshF6TCpArbNhqFL4W4P/EmF9rPeSX/msFoNzYH/P+wD50yd050tRE7tQ+i0xOkY/2Oxx6yF+1+DPUsgsw2CfLSt+JI/vxHF7UsXENc0CXNKMbz5P3RlxNPS7aNPXikNmocu/2SSBj/Bs2/8gYULH8ekQXUptDf0+kjA8PD2gQLviuEqUzh3HvnOFBaLhkc3oWgKim6IeEQ1jqcWcfs5MRmaseJnNCp78fNjNHxoFEeEseiWkSTc+Efqqw7x1z6X8/YOP3FfatxRoLA3BJ5fIjg/eAqOPo0hzj1F256x4L7f3YsfIgXNpOL3HW8ToJkwqzqKoqCq5pNyf/X2xY+IDwUFXTcoS9fB/x1EZlHALWDRDImkiR+gt/0/wERg3RnkSwiHK4bBM6fRQ54rnBVxBqiqvIBwh6Zxteh4MdGhjMYfWMLb84r5l+djPBU7GK92k/fOc8jxKUYx6lx1eD/3z5/P3o5h6B33GNLDNLhlDOwdJNxuUnhcgfkm8NuBYJgyBGw1TUhyBFrNUfwJyYZvi8IbkbxXsVis5350zgEUDAvGTgx7zGYMTUcihsnCgZ58mqqAqoEIuqKgizFcak9sCF0wqKI3UXLknVQV/Y68iCzawttYXwmT4+ghxvPoDd3d3ZhMpq+4oPhg51QXYzad8OBjxlCbHd8kNHbMaNat/xzZtQI2vMU/Qqdz001fYKgOHv+q3CuvvML111fD0g8pf8/EnLUllLV34eDMmEpvxPkdAqFvx6Y8nlRFFUVRRCFOVH4uqqp+KymqIqRfL6RdL6AK3CNQJYriFRQRRZGvjoryuChKi6iqiKrqPalTVHWNqOoloip/F1U9vff1EE5EE4sHufAUeQZgRB07XT3nIpkxQvJ983oSRsyS4+cmjIjdKT3nw0AST1Pv2FsVaejIkftFFXMQ8vqziMcTKKqKeGuRWbcjOQ8it4z9z/fxdMntRny+/982nPR/VVXx+/3yqqaKrkeJx+MRm8Um7e3tAkh0NFJZ+fUygyWbKlk/5Vb5978VURXkhhtukOeee17g5DAdr7+uyNVXG3lUkM/5rQwhWV4DmQlyG0gLRviNjsWI1Yxs4ARtnaW09ocMSD+BOwUmCYF/FKxNAi+KIXA5Vf5NArcKfFs6e67TQ9MR/QpEX4zohxG9EdF1I7XoiMeBfPo2cvdDAfLTB5BhlyJRwQjp5+b5U0B2hiIrByAbLh8m+kNPi775BdH1+0TXc422bEWm5J+6fPBViHKGKoTz6UTyP2HEj/H/xDjXQG7uuRcdjVRVnX7ynzYcue2yM3vWUyDtD24TvW2B6IXporsV0TunyqYgTXyOA6IfvUh0/0rRdf2sBULncR7n8f+EszbfO4/zOI//LM4T53mcx38pzhPneZzHfynOE+d5nMd/Kc4T53mcx38pzhPneZzHfyn+F3jU2SjeZgqRAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file From 61cb050975688f53f3a9ae50ba0c51ac657a994d Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 17 Dec 2020 12:49:08 -0700 Subject: [PATCH 39/76] Linting --- captum/optim/_utils/circuits.py | 5 +---- tests/optim/utils/test_model_utils.py | 2 +- tests/optim/utils/test_reducer.py | 2 +- 3 files changed, 3 insertions(+), 6 deletions(-) diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index 974d4c07e2..e2126bf262 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -1,10 +1,7 @@ -from typing import List, Union - import torch import torch.nn as nn -from captum.optim._utils.models import ActivationCatcher, collect_activations -from captum.optim._utils.typing import ModuleOutputMapping +from captum.optim._utils.models import collect_activations def get_expanded_weights( diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index 86e1bed3bc..bfc7339dfa 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -324,7 +324,7 @@ def test_collect_activations(self) -> None: ) model = googlenet(pretrained=True) try: - activations = model_utils.collect_activations( + activ_out = model_utils.collect_activations( model, [model.mixed4d], torch.zeros(1, 3, 224, 224) ) self.assertIsInstance(activ_out, dict) diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py index 90d9a49d8c..9d351372d4 100644 --- a/tests/optim/utils/test_reducer.py +++ b/tests/optim/utils/test_reducer.py @@ -66,7 +66,6 @@ def test_channelreducer_pytorch_custom_alg(self) -> None: self.assertEquals(test_output.size(1), 3) def test_channelreducer_pytorch_custom_alg_components(self) -> None: - test_input = torch.randn(1, 32, 224, 224).abs() reduction_alg = TestReductionAlgorithm c_reducer = reducer.ChannelReducer( n_components=3, reduction_alg=reduction_alg, max_iter=100 @@ -89,6 +88,7 @@ def test_channelreducer_pytorch_components(self) -> None: test_output = c_reducer.fit_transform(test_input, reshape=True) components = c_reducer.components self.assertTrue(torch.is_tensor(components)) + self.assertTrue(torch.is_tensor(test_output)) def test_channelreducer_numpy(self) -> None: try: From 58d2c5a2cdd2b749e3879980cb927e42edba6004 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 17 Dec 2020 13:00:55 -0700 Subject: [PATCH 40/76] Update test_reducer.py --- tests/optim/utils/test_reducer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py index 9d351372d4..6a99f01a89 100644 --- a/tests/optim/utils/test_reducer.py +++ b/tests/optim/utils/test_reducer.py @@ -16,7 +16,7 @@ class TestReductionAlgorithm(object): def __init__(self, n_components=3, **kwargs) -> None: self.n_components = n_components - self.components_ = np.ones(2, 64) + self.components_ = np.ones((2, 64)) def fit_transform(self, x: Union[torch.Tensor, np.ndarray]) -> np.ndarray: x = x.numpy() if torch.is_tensor(x) else x From a240d1087780e77c3e3ef339fdc167308d95787f Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 17 Dec 2020 13:55:41 -0700 Subject: [PATCH 41/76] Changes to Custom Modules tutorial based on feedback * Also changed NaturalImage's Parameterization variable to have a lowercase 'p', and fixed n_steps' unit display. --- captum/optim/_core/objectives.py | 2 +- captum/optim/_param/image/images.py | 4 +- tutorials/CustomModules_OptimViz.ipynb | 538 ------ tutorials/Miscellaneous_OptimViz.ipynb | 1589 ----------------- .../optimviz/CustomModules_OptimViz.ipynb | 541 ++++++ .../{ => optimviz}/InceptionV1_OptimViz.ipynb | 0 .../{ => optimviz}/TorchVision_OptimViz.ipynb | 0 .../WeightVisualization_OptimViz.ipynb | 2 +- 8 files changed, 545 insertions(+), 2131 deletions(-) delete mode 100644 tutorials/CustomModules_OptimViz.ipynb delete mode 100644 tutorials/Miscellaneous_OptimViz.ipynb create mode 100644 tutorials/optimviz/CustomModules_OptimViz.ipynb rename tutorials/{ => optimviz}/InceptionV1_OptimViz.ipynb (100%) rename tutorials/{ => optimviz}/TorchVision_OptimViz.ipynb (100%) mode change 100755 => 100644 rename tutorials/{ => optimviz}/WeightVisualization_OptimViz.ipynb (99%) diff --git a/captum/optim/_core/objectives.py b/captum/optim/_core/objectives.py index d899256764..d879f12276 100644 --- a/captum/optim/_core/objectives.py +++ b/captum/optim/_core/objectives.py @@ -161,7 +161,7 @@ def n_steps(n: int, show_progress: bool = True) -> StopCriteria: """ if show_progress: - pbar = tqdm(total=n, unit="step") + pbar = tqdm(total=n, unit=" step") def continue_while(step, obj, history, optim) -> bool: if len(history) > 0: diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 992375d13f..fd8c3e99a2 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -472,7 +472,7 @@ def __init__( size: InitSize = None, channels: int = 3, batch: int = 1, - Parameterization=FFTImage, + parameterization=FFTImage, init: Optional[torch.Tensor] = None, decorrelate_init: bool = True, squash_func: Optional[SquashFunc] = None, @@ -494,7 +494,7 @@ def __init__( if squash_func is None: squash_func: SquashFunc = lambda x: torch.sigmoid(x) self.squash_func = squash_func - self.parameterization = Parameterization( + self.parameterization = parameterization( size=size, channels=channels, batch=batch, init=init ) diff --git a/tutorials/CustomModules_OptimViz.ipynb b/tutorials/CustomModules_OptimViz.ipynb deleted file mode 100644 index 6e70c651dc..0000000000 --- a/tutorials/CustomModules_OptimViz.ipynb +++ /dev/null @@ -1,538 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "CustomClasses_OptimViz1.ipynb", - "provenance": [], - "collapsed_sections": [], - "toc_visible": true - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "0eb9231074ff48e68349a37e319c7869": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "state": { - "_view_name": "HBoxView", - "_dom_classes": [], - "_model_name": "HBoxModel", - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.5.0", - "box_style": "", - "layout": "IPY_MODEL_1555dc9cb70845098fa539cd9db186b4", - "_model_module": "@jupyter-widgets/controls", - "children": [ - "IPY_MODEL_44593fa4471948568c5462b8638d8e52", - "IPY_MODEL_db3b13c3ccd141cbb314ddc605a65f19" - ] - } - }, - "1555dc9cb70845098fa539cd9db186b4": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "44593fa4471948568c5462b8638d8e52": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "state": { - "_view_name": "ProgressView", - "style": "IPY_MODEL_9f6e2db7346541f9b01f82d00e52e18e", - "_dom_classes": [], - "description": "100%", - "_model_name": "FloatProgressModel", - "bar_style": "success", - "max": 128, - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "value": 128, - "_view_count": null, - "_view_module_version": "1.5.0", - "orientation": "horizontal", - "min": 0, - "description_tooltip": null, - "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_84f23ee271e343db9c62ccfa42ec34ed" - } - }, - "db3b13c3ccd141cbb314ddc605a65f19": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "state": { - "_view_name": "HTMLView", - "style": "IPY_MODEL_6812345efe26488f91e8224838908c06", - "_dom_classes": [], - "description": "", - "_model_name": "HTMLModel", - "placeholder": "​", - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "value": " 128/128 [00:43<00:00, 2.97step/s, Objective=322.2]", - "_view_count": null, - "_view_module_version": "1.5.0", - "description_tooltip": null, - "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_21e29391811c46519616619dc4449b31" - } - }, - "9f6e2db7346541f9b01f82d00e52e18e": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "state": { - "_view_name": "StyleView", - "_model_name": "ProgressStyleModel", - "description_width": "initial", - "_view_module": "@jupyter-widgets/base", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.2.0", - "bar_color": null, - "_model_module": "@jupyter-widgets/controls" - } - }, - "84f23ee271e343db9c62ccfa42ec34ed": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "6812345efe26488f91e8224838908c06": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "state": { - "_view_name": "StyleView", - "_model_name": "DescriptionStyleModel", - "description_width": "", - "_view_module": "@jupyter-widgets/base", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.2.0", - "_model_module": "@jupyter-widgets/controls" - } - }, - "21e29391811c46519616619dc4449b31": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - } - } - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "2ylZPub2JTMH" - }, - "source": [ - "# Creating Custom Captum.optim Modules\n", - "Captum's Optim library contains an extensive list of optimization objectives, transforms, and input parameterizations. However, some cases may require adding new features to these areas of Captum's Optim library. Luckily adding them to Captum is easy!" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "GWrStkUVEbOC" - }, - "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "from typing import Dict, List, Optional, Union\n", - "\n", - "import torch\n", - "import torchvision\n", - "from captum.optim._models.inception_v1 import googlenet\n", - "\n", - "import captum.optim as optimviz\n", - "\n", - "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", - "\n", - "model = googlenet(pretrained=True).to(device)" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "DffA7pFSFZY0" - }, - "source": [ - "# Custom Transforms\n", - "\n", - "If both Captum and Torchvision lack the transforms that you require, then you can create your own custom transforms.\n", - "\n", - "Custom transform classes must contain a `forward()` function. The first transform in a list of transforms takes an input tensor with a shape of (B, C, W, H), and the final transform in a list of transforms will need to output a tensor with the same shape of (B, C, W, H). Captum and Torchvision's transforms normally expect and output a shape of (B, C, W, H).\n", - "\n", - "An optional `__init__()` function can be used as well.\n", - "\n", - "\n", - "Note that any custom transforms need sure that your transform is autograd compatible, so that the gradient is not interrupted during the optimization process.\n" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "hoyneR7FFTXK" - }, - "source": [ - "class CustomTransform(torch.nn.Module):\n", - " def __init__(self, val: int = 1) -> None:\n", - " super(CustomTransform, self).__init__()\n", - " self.val = val\n", - "\n", - " def forward(self, input: torch.Tensor) -> torch.Tensor:\n", - " return input * self.val" - ], - "execution_count": 3, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "2kjc9istEzVz" - }, - "source": [ - "# Custom Loss Functions\n", - "Captum's loss functions are composed of classes that the optimization function uses. Custom loss classes should inherit the base the loss class.\n", - "\n", - "Custom loss functions must contain the following two functions:\n", - "\n", - "\n", - "* The `__init__()` function with that must at least contain a target variable. The target variable should be an nn.module or list of nn.modules to collect activations from. Other variables can be added after the target.\n", - "\n", - "* The `__call__()` function which takes activations from the target layer and then returns a loss value." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "LQZECwPoEdET" - }, - "source": [ - "class CustomLoss(optimviz.loss.Loss):\n", - " def __init__(self, target: Union[torch.nn.Module, List[torch.nn.Module]]):\n", - " super(optimviz.loss.Loss, self).__init__()\n", - " self.target = target\n", - "\n", - " def __call__(\n", - " self, target_activations: Dict[torch.nn.Module, Optional[torch.Tensor]]\n", - " ) -> torch.Tensor:\n", - " activations = target_activations[self.target] # Get activations from target\n", - " return activations" - ], - "execution_count": 5, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "K45Xg0HGF3VH" - }, - "source": [ - "# Custom Input Parameterization\n", - "\n", - "\n", - "The tensor parameters that Captum's Optim library optimizes to produce visualizations is stored in a custom parameterization class. \n", - "\n", - "Custom parameterization must contain the following two functions:\n", - "\n", - "An `__init__()` function with 3 input variables:\n", - "\n", - "* size (tuple, int): dimensions in the form height, width. \n", - "\n", - "* channels (int): the number of channels for the output tensor.\n", - "\n", - "* batch (int): the desired batch size to use.\n", - "\n", - "* init (torch.Tensor): An optional input tensor with a shape of: (B, C, W, H).\n", - "\n", - "\n", - "A `forward()` function with zero input varibles that returns an `torch.nn.Parameter` version of the tensor being optimized, with its shape dimensions properly named for Captum. The output tensor for the forward function must already be converted to a `torch.nn.Parameter` tensor before the forward function is run." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Hm2HLX9VFmAT" - }, - "source": [ - "class CustomInput(optimviz.images.ImageParameterization):\n", - " def __init__(\n", - " self, size=None, channels: int = 3, batch: int = 1, init: torch.Tensor = None\n", - " ) -> None:\n", - " super().__init__()\n", - " assert size is not None\n", - " if init is None:\n", - " # Create random input with a shape of: B, C, W, H\n", - " init = torch.randn([batch, channels, size[0], size[1]])\n", - " self.image = torch.nn.Parameter(init) # Convert input to nn.Parameter()\n", - "\n", - " def forward(self) -> torch.Tensor:\n", - " return self.image.refine_names(\"B\", \"C\", \"H\", \"W\") # rename dimensions" - ], - "execution_count": 6, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "x_AK29oiH9Z3" - }, - "source": [ - "# Running Captum with custom modules\n", - "\n", - "Below is a helper function that will let us quickly and easily experiment with our custom modules from above. Random scaling and random spatial jitter transforms are also included in the helper function to improve output quality." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "uQ9sEz8cG2El" - }, - "source": [ - "def visualize(model, target):\r\n", - " # Define our custom input parameterization, then add it to NaturalImage\r\n", - " image_param = CustomInput\r\n", - " image = optimviz.images.NaturalImage(size=(224, 224), Parameterization=image_param)\r\n", - "\r\n", - " transforms = torch.nn.Sequential(\r\n", - " CustomTransform(), # Add our custom transform to the list of transforms\r\n", - "\r\n", - " # Additional transforms to improve output quality\r\n", - " optimviz.transform.RandomSpatialJitter(16),\r\n", - " optimviz.transform.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\r\n", - " )\r\n", - "\r\n", - " # Define our custom loss function as the loss function\r\n", - " loss_fn = CustomLoss(target)\r\n", - "\r\n", - " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", - " history = obj.optimize(optimviz.objectives.n_steps(128))\r\n", - " image().show()" - ], - "execution_count": 7, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 427, - "referenced_widgets": [ - "0eb9231074ff48e68349a37e319c7869", - "1555dc9cb70845098fa539cd9db186b4", - "44593fa4471948568c5462b8638d8e52", - "db3b13c3ccd141cbb314ddc605a65f19", - "9f6e2db7346541f9b01f82d00e52e18e", - "84f23ee271e343db9c62ccfa42ec34ed", - "6812345efe26488f91e8224838908c06", - "21e29391811c46519616619dc4449b31" - ] - }, - "id": "3m5iQ2zfqV5F", - "outputId": "b3df586b-d7f6-48de-b7a5-4eb0c853e4b2" - }, - "source": [ - "visualize(model, model.mixed4a)" - ], - "execution_count": 9, - "outputs": [ - { - "output_type": "display_data", - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0eb9231074ff48e68349a37e319c7869", - "version_minor": 0, - "version_major": 2 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" - ] - }, - "metadata": { - "tags": [] - } - }, - { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/torch/tensor.py:775: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at /pytorch/c10/core/TensorImpl.h:848.)\n", - " return super(Tensor, self).refine_names(names)\n", - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" - ], - "name": "stderr" - }, - { - "output_type": "stream", - "text": [ - "\n" - ], - "name": "stdout" - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - } - ] -} \ No newline at end of file diff --git a/tutorials/Miscellaneous_OptimViz.ipynb b/tutorials/Miscellaneous_OptimViz.ipynb deleted file mode 100644 index 23fedec5ce..0000000000 --- a/tutorials/Miscellaneous_OptimViz.ipynb +++ /dev/null @@ -1,1589 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "name": "Miscellaneous_OptimViz.ipynb", - "provenance": [], - "collapsed_sections": [], - "toc_visible": true - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "widgets": { - "application/vnd.jupyter.widget-state+json": { - "8ac1934dd2a74116aa92e7e0f89b6866": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "state": { - "_view_name": "HBoxView", - "_dom_classes": [], - "_model_name": "HBoxModel", - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.5.0", - "box_style": "", - "layout": "IPY_MODEL_1619e2ecc1194ceaa27b03204ce9e119", - "_model_module": "@jupyter-widgets/controls", - "children": [ - "IPY_MODEL_1b27274c717e44bbb3465f8b180fafbe", - "IPY_MODEL_c7490e5b0751438dac835b01cbe2f52a" - ] - } - }, - "1619e2ecc1194ceaa27b03204ce9e119": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "1b27274c717e44bbb3465f8b180fafbe": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "state": { - "_view_name": "ProgressView", - "style": "IPY_MODEL_d52357a2a3314020849b5953253a4a43", - "_dom_classes": [], - "description": "100%", - "_model_name": "FloatProgressModel", - "bar_style": "success", - "max": 128, - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "value": 128, - "_view_count": null, - "_view_module_version": "1.5.0", - "orientation": "horizontal", - "min": 0, - "description_tooltip": null, - "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_23423a617f8c4149a1bfe232b040b817" - } - }, - "c7490e5b0751438dac835b01cbe2f52a": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "state": { - "_view_name": "HTMLView", - "style": "IPY_MODEL_60983f5ed4a4424cade5cc9fa54a1b70", - "_dom_classes": [], - "description": "", - "_model_name": "HTMLModel", - "placeholder": "​", - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "value": " 128/128 [00:16<00:00, 7.56step/s, Objective=87159356784640.0]", - "_view_count": null, - "_view_module_version": "1.5.0", - "description_tooltip": null, - "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_7907b72c9b614515be23215053bf61dc" - } - }, - "d52357a2a3314020849b5953253a4a43": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "state": { - "_view_name": "StyleView", - "_model_name": "ProgressStyleModel", - "description_width": "initial", - "_view_module": "@jupyter-widgets/base", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.2.0", - "bar_color": null, - "_model_module": "@jupyter-widgets/controls" - } - }, - "23423a617f8c4149a1bfe232b040b817": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "60983f5ed4a4424cade5cc9fa54a1b70": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "state": { - "_view_name": "StyleView", - "_model_name": "DescriptionStyleModel", - "description_width": "", - "_view_module": "@jupyter-widgets/base", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.2.0", - "_model_module": "@jupyter-widgets/controls" - } - }, - "7907b72c9b614515be23215053bf61dc": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "32d789dbfb4f4a3baeabf116bc91f7a0": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "state": { - "_view_name": "HBoxView", - "_dom_classes": [], - "_model_name": "HBoxModel", - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.5.0", - "box_style": "", - "layout": "IPY_MODEL_ffe6e767db9f4d38b59e1c5a9d5c10ed", - "_model_module": "@jupyter-widgets/controls", - "children": [ - "IPY_MODEL_a9060e1913584e719d325695658615de", - "IPY_MODEL_9052569286ff4650b8ad9ba61a3aa15f" - ] - } - }, - "ffe6e767db9f4d38b59e1c5a9d5c10ed": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "a9060e1913584e719d325695658615de": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "state": { - "_view_name": "ProgressView", - "style": "IPY_MODEL_68d5449317e041e98e33616550667e24", - "_dom_classes": [], - "description": "100%", - "_model_name": "FloatProgressModel", - "bar_style": "success", - "max": 128, - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "value": 128, - "_view_count": null, - "_view_module_version": "1.5.0", - "orientation": "horizontal", - "min": 0, - "description_tooltip": null, - "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_cfd379157c144f2882d2e1b429f6b325" - } - }, - "9052569286ff4650b8ad9ba61a3aa15f": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "state": { - "_view_name": "HTMLView", - "style": "IPY_MODEL_bb093177f1cc46f0816172ba5967b424", - "_dom_classes": [], - "description": "", - "_model_name": "HTMLModel", - "placeholder": "​", - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "value": " 128/128 [00:32<00:00, 3.98step/s, Objective=4033437184.0]", - "_view_count": null, - "_view_module_version": "1.5.0", - "description_tooltip": null, - "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_3ce2f130d504444e9d8331afd7fb41f1" - } - }, - "68d5449317e041e98e33616550667e24": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "state": { - "_view_name": "StyleView", - "_model_name": "ProgressStyleModel", - "description_width": "initial", - "_view_module": "@jupyter-widgets/base", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.2.0", - "bar_color": null, - "_model_module": "@jupyter-widgets/controls" - } - }, - "cfd379157c144f2882d2e1b429f6b325": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "bb093177f1cc46f0816172ba5967b424": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "state": { - "_view_name": "StyleView", - "_model_name": "DescriptionStyleModel", - "description_width": "", - "_view_module": "@jupyter-widgets/base", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.2.0", - "_model_module": "@jupyter-widgets/controls" - } - }, - "3ce2f130d504444e9d8331afd7fb41f1": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "d2d81bfb52f04ce79e3c440d338a5c29": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "state": { - "_view_name": "HBoxView", - "_dom_classes": [], - "_model_name": "HBoxModel", - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.5.0", - "box_style": "", - "layout": "IPY_MODEL_b8326c412b084ec697df5b0ca05e9ccf", - "_model_module": "@jupyter-widgets/controls", - "children": [ - "IPY_MODEL_48d1fbc1a02c45bcb7fb1ebd2cd34dfb", - "IPY_MODEL_6efbfd4891f746cca643654566ee743c" - ] - } - }, - "b8326c412b084ec697df5b0ca05e9ccf": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "48d1fbc1a02c45bcb7fb1ebd2cd34dfb": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "state": { - "_view_name": "ProgressView", - "style": "IPY_MODEL_2403e147ece043a699622b9372012670", - "_dom_classes": [], - "description": "100%", - "_model_name": "FloatProgressModel", - "bar_style": "success", - "max": 128, - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "value": 128, - "_view_count": null, - "_view_module_version": "1.5.0", - "orientation": "horizontal", - "min": 0, - "description_tooltip": null, - "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_160db01ce9354f5fa04cd11f81df9743" - } - }, - "6efbfd4891f746cca643654566ee743c": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "state": { - "_view_name": "HTMLView", - "style": "IPY_MODEL_395e68770d8c47b697a517e861cb935a", - "_dom_classes": [], - "description": "", - "_model_name": "HTMLModel", - "placeholder": "​", - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "value": " 128/128 [00:44<00:00, 2.87step/s, Objective=24491804672.0]", - "_view_count": null, - "_view_module_version": "1.5.0", - "description_tooltip": null, - "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_52c7abe1e9af4a628823d675eac7323e" - } - }, - "2403e147ece043a699622b9372012670": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "state": { - "_view_name": "StyleView", - "_model_name": "ProgressStyleModel", - "description_width": "initial", - "_view_module": "@jupyter-widgets/base", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.2.0", - "bar_color": null, - "_model_module": "@jupyter-widgets/controls" - } - }, - "160db01ce9354f5fa04cd11f81df9743": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "395e68770d8c47b697a517e861cb935a": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "state": { - "_view_name": "StyleView", - "_model_name": "DescriptionStyleModel", - "description_width": "", - "_view_module": "@jupyter-widgets/base", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.2.0", - "_model_module": "@jupyter-widgets/controls" - } - }, - "52c7abe1e9af4a628823d675eac7323e": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "b2d90f4e80f24206bd89ea9681d7b775": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HBoxModel", - "state": { - "_view_name": "HBoxView", - "_dom_classes": [], - "_model_name": "HBoxModel", - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.5.0", - "box_style": "", - "layout": "IPY_MODEL_62db6cd41ac24cd5b89a60f7d836193e", - "_model_module": "@jupyter-widgets/controls", - "children": [ - "IPY_MODEL_6dff3e1dd3964cfb908f2ce4fd71f78c", - "IPY_MODEL_521accba1df54a95aaa787780c5b7162" - ] - } - }, - "62db6cd41ac24cd5b89a60f7d836193e": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "6dff3e1dd3964cfb908f2ce4fd71f78c": { - "model_module": "@jupyter-widgets/controls", - "model_name": "FloatProgressModel", - "state": { - "_view_name": "ProgressView", - "style": "IPY_MODEL_8eabb94361ab455f96c13a6784f36289", - "_dom_classes": [], - "description": "100%", - "_model_name": "FloatProgressModel", - "bar_style": "success", - "max": 128, - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "value": 128, - "_view_count": null, - "_view_module_version": "1.5.0", - "orientation": "horizontal", - "min": 0, - "description_tooltip": null, - "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_3b2af960bf19426586add01e1e4299b1" - } - }, - "521accba1df54a95aaa787780c5b7162": { - "model_module": "@jupyter-widgets/controls", - "model_name": "HTMLModel", - "state": { - "_view_name": "HTMLView", - "style": "IPY_MODEL_3484758cbb5e48efb4c29b4cb2276528", - "_dom_classes": [], - "description": "", - "_model_name": "HTMLModel", - "placeholder": "​", - "_view_module": "@jupyter-widgets/controls", - "_model_module_version": "1.5.0", - "value": " 128/128 [01:15<00:00, 1.70step/s, Objective=10076947456.0]", - "_view_count": null, - "_view_module_version": "1.5.0", - "description_tooltip": null, - "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_3c0c231696a84b2d9a2b84bc1ff1089d" - } - }, - "8eabb94361ab455f96c13a6784f36289": { - "model_module": "@jupyter-widgets/controls", - "model_name": "ProgressStyleModel", - "state": { - "_view_name": "StyleView", - "_model_name": "ProgressStyleModel", - "description_width": "initial", - "_view_module": "@jupyter-widgets/base", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.2.0", - "bar_color": null, - "_model_module": "@jupyter-widgets/controls" - } - }, - "3b2af960bf19426586add01e1e4299b1": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - }, - "3484758cbb5e48efb4c29b4cb2276528": { - "model_module": "@jupyter-widgets/controls", - "model_name": "DescriptionStyleModel", - "state": { - "_view_name": "StyleView", - "_model_name": "DescriptionStyleModel", - "description_width": "", - "_view_module": "@jupyter-widgets/base", - "_model_module_version": "1.5.0", - "_view_count": null, - "_view_module_version": "1.2.0", - "_model_module": "@jupyter-widgets/controls" - } - }, - "3c0c231696a84b2d9a2b84bc1ff1089d": { - "model_module": "@jupyter-widgets/base", - "model_name": "LayoutModel", - "state": { - "_view_name": "LayoutView", - "grid_template_rows": null, - "right": null, - "justify_content": null, - "_view_module": "@jupyter-widgets/base", - "overflow": null, - "_model_module_version": "1.2.0", - "_view_count": null, - "flex_flow": null, - "width": null, - "min_width": null, - "border": null, - "align_items": null, - "bottom": null, - "_model_module": "@jupyter-widgets/base", - "top": null, - "grid_column": null, - "overflow_y": null, - "overflow_x": null, - "grid_auto_flow": null, - "grid_area": null, - "grid_template_columns": null, - "flex": null, - "_model_name": "LayoutModel", - "justify_items": null, - "grid_row": null, - "max_height": null, - "align_content": null, - "visibility": null, - "align_self": null, - "height": null, - "min_height": null, - "padding": null, - "grid_auto_rows": null, - "grid_gap": null, - "max_width": null, - "order": null, - "_view_module_version": "1.2.0", - "grid_template_areas": null, - "object_position": null, - "object_fit": null, - "grid_auto_columns": null, - "margin": null, - "display": null, - "left": null - } - } - } - } - }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "VWy2Woand8P0" - }, - "source": [ - "# Miscellaneous visualizations with captum.optim\r\n", - "\r\n", - "This notebook demonstrates the use of the captum.optim submodule for visualization tasks such as neuron groups and caricatures." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "GWrStkUVEbOC" - }, - "source": [ - "%load_ext autoreload\n", - "%autoreload 2\n", - "\n", - "import torch\n", - "import torchvision\n", - "from captum.optim._models.inception_v1 import googlenet\n", - "\n", - "import captum.optim as optimviz\n", - "\n", - "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", - "\n", - "model = googlenet(pretrained=True).to(device).eval()" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rzb9RtdUfE_H" - }, - "source": [ - "We'll load some images for testing, and setup some helper functions." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "1Fj187brzzkT" - }, - "source": [ - "import numpy as np\r\n", - "from PIL import Image\r\n", - "\r\n", - "!wget https://storage.googleapis.com/lucid-static/building-blocks/examples/dog_cat.png\r\n", - "image = Image.open(\"dog_cat.png\").convert('RGB')\r\n", - "catdog_image = torch.as_tensor(np.array(image)).permute(2, 0, 1).unsqueeze(0) / 255\r\n", - "\r\n", - "!wget https://storage.googleapis.com/lucid-static/building-blocks/examples/flowers.png\r\n", - "image = Image.open(\"flowers.png\").convert('RGB')\r\n", - "flower_image = torch.as_tensor(np.array(image)).permute(2, 0, 1).unsqueeze(0) / 255" - ], - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "D46o5t8a4iVk" - }, - "source": [ - "import numpy as np\r\n", - "import matplotlib.pyplot as plt\r\n", - "\r\n", - "\r\n", - "def show(x: np.ndarray, scale: float = 255.0) -> None:\r\n", - " assert len(x.shape) == 3\r\n", - " x = x.permute(1,2,0).numpy() if torch.is_tensor(x) else x\r\n", - " if x.shape[2] == 1:\r\n", - " x = np.concatenate([x, x, x], 2)\r\n", - " x = x * scale\r\n", - " plt.imshow(x.astype(np.uint8))\r\n", - " plt.axis(\"off\")\r\n", - " plt.show()" - ], - "execution_count": 5, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "rwNBGUFJ0Z_P" - }, - "source": [ - "## Neuron Groups\r\n", - "\r\n", - "The code below let's us visualize Neuron Groups, so that we can see how detectors view different spatial regions of an input." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "Sc7gVr-QUQIE" - }, - "source": [ - "# Helper functions\r\n", - "\r\n", - "from captum.optim._utils.models import ActivationCatcher\r\n", - "\r\n", - "\r\n", - "def vis_direction(model, target, vec=None) -> None:\r\n", - " image = optimviz.images.NaturalImage((80,80)).to(device)\r\n", - " loss_fn = optimviz.loss.Direction(target, vec)\r\n", - " transforms = torch.nn.Sequential(\r\n", - " torch.nn.ReflectionPad2d(16),\r\n", - " optimviz.transform.RandomSpatialJitter(16),\r\n", - " optimviz.transform.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\r\n", - " torchvision.transforms.RandomRotation(degrees=(-5,5)),\r\n", - " optimviz.transform.RandomSpatialJitter(8),\r\n", - " optimviz.transform.CenterCrop(16),\r\n", - " ) \r\n", - " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", - " history = obj.optimize(optimviz.objectives.n_steps(128, False))\r\n", - " return image()._t\r\n", - "\r\n", - "\r\n", - "def neuron_groups(model_input, model, target, n_groups=6):\r\n", - " activations = optimviz.models.collect_activations(model, [target], model_input)[target].detach()\r\n", - " \r\n", - " reducer = optimviz.reducer.ChannelReducer(n_groups, \"NMF\")\r\n", - " spatial_factors = reducer.fit_transform(activations)[0]\r\n", - " channel_factors = reducer.components\r\n", - "\r\n", - " s_max, _ = spatial_factors.max(1)\r\n", - " x_peak = torch.argmax(s_max, 1)\r\n", - " ns_sorted = torch.argsort(x_peak)\r\n", - "\r\n", - " spatial_factors = spatial_factors[ns_sorted]\r\n", - " channel_factors = channel_factors[ns_sorted]\r\n", - "\r\n", - " group_vecs = [spatial_factors[i, ..., None]*channel_factors[i] for i in range(n_groups)]\r\n", - " \r\n", - " x_tensors = [factor.unsqueeze(0) / torch.quantile(spatial_factors,99/100) for factor in spatial_factors]\r\n", - "\r\n", - " show(model_input[0])\r\n", - " show(torch.cat(x_tensors[:3], 0))\r\n", - " show(torch.cat(x_tensors[3:], 0))\r\n", - "\r\n", - " A = []\r\n", - " for i in range(n_groups):\r\n", - " x_out = vis_direction(model, target, channel_factors[i])\r\n", - " A.append(x_out.detach().squeeze(0))\r\n", - "\r\n", - " grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=n_groups)\r\n", - " show(grid_img)" - ], - "execution_count": 10, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "4ZTCiTE60Lvn", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "outputId": "f87d542f-b0b0-42c9-a31c-37a753b3b8a9" - }, - "source": [ - "neuron_groups(catdog_image, model, model.mixed4d, 6)\r\n", - "neuron_groups(flower_image, model, model.mixed4d, 6)" - ], - "execution_count": 11, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAFm0lEQVR4nO3dvYqdZRSG4febmWTyI8QilSAEO0EFq+gBeAJWFiII2nsAAStREMSz0E4rbQQLsREsrIJoIQrBaKFG8zM/e38WtpMd+Z6EeSa5rjJhzYom92xIWLzTPM8D6LN13L8A4GjihFLihFLihFLihFI7m35ymqZj+6vcs+H8bjC7CnffCWYPtsPlqfUx7n5E/+FgnufpqB/3yQmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlNt5zHucXfzHcfTmYvRnu/jqY/TG8afwr/Xb7iN5UNvLJCaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaUe6MnYhWD25XD3R8HsnSey3W8/vnz23X+y3d9cz+ZXh9k8949PTiglTiglTiglTiglTiglTiglTiglTiglTiglTiglTiglTiglTiglTiglTii1+Z5zyr74jbPL2z83b0e7f31ztXj26ofraPcHZ5bP3roSrR7r97P5sRfOB5I/bg/jy4U+OaGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKGUOKHUNM93P7aZpim7xDl7fvHoS8/sRquf+2T53dZnX12Ldl/9afns9rPR6rF+Pbvzm3+/uHh2Zzwf7V6N28Hun6Ld8/TL4tnD8F5tnucjf9N8ckIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUKpzU8AjuX3mGOMMW4vvy38cuxHq7/4dvmvfX4lfPvw++UHfqv3stXj4FT4BV5dPHl+vBVtPj0uLZ49GJ9Hu29Ory0fnn+Ldt+NT04oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4oJU4odY8nAM+Fj5stf9JtLH/B7z9PBrPZ64Nj/B3MXg93H97jCvCe828snz3/cbb77AvLZ/c/jVZv3by8eHa9+i7a7QlAOGHECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaXECaU23nNuT1N0z5lcFqbfNfaC2fCI9YS7tHx0upKtvvDU8tkbP2S71+8Ewz9Hq91zwgkjTiglTiglTiglTiglTiglTiglTiglTiglTiglTiglTiglTiglTiglTii18Z7zzDHec55KFo8xVsHsnXD3QTh/vJKHUZ+ONu+Oi4tn98Z+tHuM5I3NP6PN7jnhhBEnlBInlBInlBInlBInlBInlBInlBInlBInlBInlBInlBInlBInlNp41bV3OvviqyMPYf6fg91s91gvH90Ob8amw+Wz6blZ/nxh8D9u61q2eeuP5cOHj0W7x05yKncu230XPjmhlDihlDihlDihlDihlDihlDihlDihlDihlDihlDihlDihlDihlDihlDih1OZX+sJ0D7eCRwDvpN83gifhdraz1VvBA4TJ24X3Yz45Rj2TPYV3cGpv+fAqvISdgj9vB/kV7VF8ckIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUIpcUKpaZ7vfu4y7UzZLUzwBOA4TN8ADJZP4d3VVvCMXjA6xhhjTm/GAuGl3dgNfs/WyRN+Y4xV8jl1K1o976+P/A/3yQmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlxAmlNt9zboX3nA/mZTR4qMzz7J4TThJxQilxQilxQilxQilxQilxQilxQilxQilxQilxQilxQilxQilxQqmdjT+bPOE3RpZ+em6WPqUHx8wnJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5QSJ5Ta+AQgcHx8ckIpcUIpcUIpcUIpcUIpcUKpfwHnILV7xogkrgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" - ], - "name": "stderr" - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" - ], - "name": "stderr" - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "m-rMQZVnzKei" - }, - "source": [ - "## Feature Inversion Caricatures\r\n", - "\r\n", - "\r\n", - "This an image visualization technique based on research by [Mahendran and Vedaldi](https://arxiv.org/pdf/1412.0035.pdf). \r\n", - "\r\n", - "Compared to their work, we use a dot product object and transform robustness." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "-gi3O0ZhpzOa" - }, - "source": [ - "# Helper classes & functions\r\n", - "\r\n", - "class StackImage(optimviz.images.ImageParameterization):\r\n", - " def __init__(\r\n", - " self,\r\n", - " init: torch.Tensor,\r\n", - " parameterization=None,\r\n", - " ) -> None:\r\n", - " super().__init__()\r\n", - " assert init.dim() == 4\r\n", - " self.image = torch.nn.Parameter(init)\r\n", - " self.parameterization = parameterization\r\n", - "\r\n", - " def forward(self) -> torch.Tensor:\r\n", - " image = self.parameterization()\r\n", - " return torch.cat([image, self.image], 0).refine_names(\"B\", \"C\", \"H\", \"W\")\r\n", - "\r\n", - "\r\n", - "class DotCompare(optimviz.loss.Loss):\r\n", - " def __init__(\r\n", - " self,\r\n", - " target: torch.nn.Module = None,\r\n", - " cossim_pow: float = 0\r\n", - " ) -> None:\r\n", - " super(optimviz.loss.Loss, self).__init__()\r\n", - " self.target = target\r\n", - " self.cossim_pow = cossim_pow\r\n", - "\r\n", - " def __call__(self, targets_to_values) -> torch.Tensor:\r\n", - " activations = targets_to_values[self.target]\r\n", - " assert activations.size(0) == 2\r\n", - " dot = torch.sum(activations[0] * activations[1])\r\n", - " mag = torch.sqrt(torch.sum(activations[0]**2))\r\n", - " cossim = dot / (1e-6 + mag)\r\n", - " return dot * cossim ** self.cossim_pow\r\n", - "\r\n", - "\r\n", - "def vis_feature_inversion(model, target, init, init2, cossim_pow=0) -> None:\r\n", - " image = optimviz.images.NaturalImage((224,224), batch=2, init=init).to(device)\r\n", - " init2 = image.decorrelate(init2.refine_names(\"B\", \"C\", \"H\", \"W\"), inverse=True)\r\n", - " image.parameterization = StackImage(init2, parameterization=image.parameterization)\r\n", - " loss_fn = DotCompare(target, cossim_pow=cossim_pow)\r\n", - " transforms = torch.nn.Sequential(\r\n", - " torch.nn.ReflectionPad2d(16),\r\n", - " optimviz.transform.RandomSpatialJitter(16),\r\n", - " optimviz.transform.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\r\n", - " torchvision.transforms.RandomRotation(degrees=(-5,5)),\r\n", - " optimviz.transform.RandomSpatialJitter(8),\r\n", - " optimviz.transform.CenterCrop(16),\r\n", - " ) \r\n", - " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", - " history = obj.optimize(optimviz.objectives.n_steps(128))\r\n", - " show(image()._t[0].detach())" - ], - "execution_count": 12, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "es6vyxRQrOXU", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000, - "referenced_widgets": [ - "8ac1934dd2a74116aa92e7e0f89b6866", - "1619e2ecc1194ceaa27b03204ce9e119", - "1b27274c717e44bbb3465f8b180fafbe", - "c7490e5b0751438dac835b01cbe2f52a", - "d52357a2a3314020849b5953253a4a43", - "23423a617f8c4149a1bfe232b040b817", - "60983f5ed4a4424cade5cc9fa54a1b70", - "7907b72c9b614515be23215053bf61dc", - "32d789dbfb4f4a3baeabf116bc91f7a0", - "ffe6e767db9f4d38b59e1c5a9d5c10ed", - "a9060e1913584e719d325695658615de", - "9052569286ff4650b8ad9ba61a3aa15f", - "68d5449317e041e98e33616550667e24", - "cfd379157c144f2882d2e1b429f6b325", - "bb093177f1cc46f0816172ba5967b424", - "3ce2f130d504444e9d8331afd7fb41f1", - "d2d81bfb52f04ce79e3c440d338a5c29", - "b8326c412b084ec697df5b0ca05e9ccf", - "48d1fbc1a02c45bcb7fb1ebd2cd34dfb", - "6efbfd4891f746cca643654566ee743c", - "2403e147ece043a699622b9372012670", - "160db01ce9354f5fa04cd11f81df9743", - "395e68770d8c47b697a517e861cb935a", - "52c7abe1e9af4a628823d675eac7323e", - "b2d90f4e80f24206bd89ea9681d7b775", - "62db6cd41ac24cd5b89a60f7d836193e", - "6dff3e1dd3964cfb908f2ce4fd71f78c", - "521accba1df54a95aaa787780c5b7162", - "8eabb94361ab455f96c13a6784f36289", - "3b2af960bf19426586add01e1e4299b1", - "3484758cbb5e48efb4c29b4cb2276528", - "3c0c231696a84b2d9a2b84bc1ff1089d" - ] - }, - "outputId": "03ed0d6c-37b9-4159-8161-fa35c9d4af47" - }, - "source": [ - "size = (224,224)\r\n", - "init2 = torch.nn.functional.interpolate(catdog_image, size=size)\r\n", - "init = torch.zeros(1, 3, size[0], size[1])\r\n", - "\r\n", - "vis_feature_inversion(model, model.conv1, init=init, init2=init2, cossim_pow=0.5)\r\n", - "vis_feature_inversion(model, model.conv2, init=init, init2=init2)\r\n", - "vis_feature_inversion(model, model.conv3, init=init, init2=init2)\r\n", - "vis_feature_inversion(model, model.mixed3a, init=init, init2=init2)" - ], - "execution_count": 13, - "outputs": [ - { - "output_type": "display_data", - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8ac1934dd2a74116aa92e7e0f89b6866", - "version_minor": 0, - "version_major": 2 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" - ] - }, - "metadata": { - "tags": [] - } - }, - { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" - ], - "name": "stderr" - }, - { - "output_type": "stream", - "text": [ - "\n" - ], - "name": "stdout" - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "32d789dbfb4f4a3baeabf116bc91f7a0", - "version_minor": 0, - "version_major": 2 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" - ] - }, - "metadata": { - "tags": [] - } - }, - { - "output_type": "stream", - "text": [ - "\n" - ], - "name": "stdout" - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d2d81bfb52f04ce79e3c440d338a5c29", - "version_minor": 0, - "version_major": 2 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" - ] - }, - "metadata": { - "tags": [] - } - }, - { - "output_type": "stream", - "text": [ - "\n" - ], - "name": "stdout" - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b2d90f4e80f24206bd89ea9681d7b775", - "version_minor": 0, - "version_major": 2 - }, - "text/plain": [ - "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" - ] - }, - "metadata": { - "tags": [] - } - }, - { - "output_type": "stream", - "text": [ - "\n" - ], - "name": "stdout" - }, - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - } - ] -} \ No newline at end of file diff --git a/tutorials/optimviz/CustomModules_OptimViz.ipynb b/tutorials/optimviz/CustomModules_OptimViz.ipynb new file mode 100644 index 0000000000..12294c18fc --- /dev/null +++ b/tutorials/optimviz/CustomModules_OptimViz.ipynb @@ -0,0 +1,541 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "CustomModules_OptimViz.ipynb", + "provenance": [], + "collapsed_sections": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "5c666868d62e4862a648cd0df15155ec": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "state": { + "_view_name": "HBoxView", + "_dom_classes": [], + "_model_name": "HBoxModel", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.5.0", + "box_style": "", + "layout": "IPY_MODEL_389469a07da6435eb2a1be7ea55f4f86", + "_model_module": "@jupyter-widgets/controls", + "children": [ + "IPY_MODEL_36b86b673b544cc5bdb5652eb31cabc9", + "IPY_MODEL_6d93392ab27048068aa8bb1d7ef01cf1" + ] + } + }, + "389469a07da6435eb2a1be7ea55f4f86": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "36b86b673b544cc5bdb5652eb31cabc9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "state": { + "_view_name": "ProgressView", + "style": "IPY_MODEL_2c759e9a43754fc4963a9631cc7702c5", + "_dom_classes": [], + "description": "100%", + "_model_name": "FloatProgressModel", + "bar_style": "success", + "max": 128, + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": 128, + "_view_count": null, + "_view_module_version": "1.5.0", + "orientation": "horizontal", + "min": 0, + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_8fa32da11a2a4401a57a50f80af7be32" + } + }, + "6d93392ab27048068aa8bb1d7ef01cf1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "state": { + "_view_name": "HTMLView", + "style": "IPY_MODEL_ba6b8e0c07074921a5faa7dbc29f3fe3", + "_dom_classes": [], + "description": "", + "_model_name": "HTMLModel", + "placeholder": "​", + "_view_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "value": " 128/128 [00:42<00:00, 2.99 step/s, Objective=356.1]", + "_view_count": null, + "_view_module_version": "1.5.0", + "description_tooltip": null, + "_model_module": "@jupyter-widgets/controls", + "layout": "IPY_MODEL_ea6b900b717c4e8f8051094882aeef1f" + } + }, + "2c759e9a43754fc4963a9631cc7702c5": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "ProgressStyleModel", + "description_width": "initial", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "bar_color": null, + "_model_module": "@jupyter-widgets/controls" + } + }, + "8fa32da11a2a4401a57a50f80af7be32": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + }, + "ba6b8e0c07074921a5faa7dbc29f3fe3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "state": { + "_view_name": "StyleView", + "_model_name": "DescriptionStyleModel", + "description_width": "", + "_view_module": "@jupyter-widgets/base", + "_model_module_version": "1.5.0", + "_view_count": null, + "_view_module_version": "1.2.0", + "_model_module": "@jupyter-widgets/controls" + } + }, + "ea6b900b717c4e8f8051094882aeef1f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "state": { + "_view_name": "LayoutView", + "grid_template_rows": null, + "right": null, + "justify_content": null, + "_view_module": "@jupyter-widgets/base", + "overflow": null, + "_model_module_version": "1.2.0", + "_view_count": null, + "flex_flow": null, + "width": null, + "min_width": null, + "border": null, + "align_items": null, + "bottom": null, + "_model_module": "@jupyter-widgets/base", + "top": null, + "grid_column": null, + "overflow_y": null, + "overflow_x": null, + "grid_auto_flow": null, + "grid_area": null, + "grid_template_columns": null, + "flex": null, + "_model_name": "LayoutModel", + "justify_items": null, + "grid_row": null, + "max_height": null, + "align_content": null, + "visibility": null, + "align_self": null, + "height": null, + "min_height": null, + "padding": null, + "grid_auto_rows": null, + "grid_gap": null, + "max_width": null, + "order": null, + "_view_module_version": "1.2.0", + "grid_template_areas": null, + "object_position": null, + "object_fit": null, + "grid_auto_columns": null, + "margin": null, + "display": null, + "left": null + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "2ylZPub2JTMH" + }, + "source": [ + "# Creating Custom Captum.optim Modules\n", + "Captum's Optim library contains an extensive list of optimization objectives, transforms, and input parameterizations. However, some cases may require adding new features to these areas of Captum's Optim library. Luckily adding them to Captum is easy!" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "GWrStkUVEbOC" + }, + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "from typing import Dict, List, Optional, Tuple, Union\n", + "\n", + "import torch\n", + "import torchvision\n", + "from captum.optim._models.inception_v1 import googlenet\n", + "\n", + "import captum.optim as optimviz\n", + "\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "model = googlenet(pretrained=True).to(device)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DffA7pFSFZY0" + }, + "source": [ + "# Custom Image Transforms\n", + "\n", + "If both Captum and Torchvision lack the transforms that you require, then you can create your own custom transforms.\n", + "\n", + "Custom image transform classes must contain a `forward()` function. The first transform in a list of transforms takes an input tensor with a shape of (B, C, W, H), and the final transform in a list of transforms will need to output a tensor with the same shape of (B, C, W, H). Captum and Torchvision's transforms normally expect and output a shape of (B, C, W, H).\n", + "\n", + "An optional `__init__()` function can be used as well.\n", + "\n", + "\n", + "Note that all custom transforms need to be autograd compatible, so that the gradient is not interrupted during the optimization process.\n" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hoyneR7FFTXK" + }, + "source": [ + "class CustomTransform(torch.nn.Module):\n", + " def __init__(self, val: int = 1) -> None:\n", + " super(CustomTransform, self).__init__()\n", + " self.val = val\n", + "\n", + " def forward(self, input: torch.Tensor) -> torch.Tensor:\n", + " return input * self.val" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2kjc9istEzVz" + }, + "source": [ + "# Custom Loss Functions\n", + "Captum's loss functions are composed of classes that the optimization function uses. Custom loss classes should inherit the base loss class.\n", + "\n", + "Custom loss functions must contain the following two functions:\n", + "\n", + "\n", + "* The `__init__()` function with that must at least contain a target variable. The target variable should be an nn.module or list of nn.modules to collect activations from. Other variables can be added after the target.\n", + "\n", + "* The `__call__()` function which takes activations from the target layer and then returns a loss value. Activations sent to the call function are extracted from a dictionary with the target as the key." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "LQZECwPoEdET" + }, + "source": [ + "class CustomLoss(optimviz.loss.Loss):\n", + " def __init__(self, target: Union[torch.nn.Module, List[torch.nn.Module]]):\n", + " super(optimviz.loss.Loss, self).__init__()\n", + " self.target = target\n", + "\n", + " def __call__(\n", + " self, target_activations: Dict[torch.nn.Module, Optional[torch.Tensor]]\n", + " ) -> torch.Tensor:\n", + " activations = target_activations[self.target] # Get activations from target\n", + " return activations" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "K45Xg0HGF3VH" + }, + "source": [ + "# Custom Image Parameterization\n", + "\n", + "\n", + "The image parameters that Captum's Optim library optimizes to produce visualizations is stored in a custom image parameterization class. \n", + "\n", + "Custom parameterization must contain the following two functions:\n", + "\n", + "### Init function\n", + "\n", + "The `__init__()` function has 3 input variables:\n", + "\n", + "* size (tuple, int): dimensions in the form height, width. \n", + "\n", + "* channels (int): the number of channels for the output tensor.\n", + "\n", + "* batch (int): the desired batch size to use.\n", + "\n", + "* init (torch.Tensor): An optional input tensor with a shape of: (B, C, W, H).\n", + "\n", + "Make sure that the tensor being optimized is wrapped in `torch.nn.Parameter` and that it can be called by the `forward()` function.\n", + "\n", + "### Forward function\n", + "\n", + "The `forward()` function has zero input varibles and returns a 4 dimension tensor with a shape of (B, C, W, H):\n", + "\n", + "* The tensor being optimized should be called from where it was saved in the init function. This tensor will then be returned when the forward function is called.\n", + "\n", + "* The dimensions of the output tensor should be named: 'B', 'C', 'H', and 'W'." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Hm2HLX9VFmAT" + }, + "source": [ + "class CustomImage(optimviz.images.ImageParameterization):\n", + " def __init__(\n", + " self,\n", + " size: Tuple[int, int] = (224, 224),\n", + " channels: int = 3,\n", + " batch: int = 1,\n", + " init: torch.Tensor = None,\n", + " ) -> None:\n", + " super().__init__()\n", + " if init is None:\n", + " assert size is not None\n", + " # Create random input with a shape of: B, C, W, H\n", + " init = torch.randn([batch, channels, size[0], size[1]])\n", + " else:\n", + " assert init.dim() == 4\n", + " self.image = torch.nn.Parameter(init) # Convert input to nn.Parameter()\n", + "\n", + " def forward(self) -> torch.Tensor:\n", + " return self.image.refine_names(\"B\", \"C\", \"H\", \"W\") # rename dimensions" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "x_AK29oiH9Z3" + }, + "source": [ + "# Running Captum with custom modules\n", + "\n", + "Below is a helper function that will let us quickly and easily experiment with our custom modules from above. Random scaling and random spatial jitter transforms are also included in the helper function to improve output quality." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "uQ9sEz8cG2El" + }, + "source": [ + "def visualize(model, target):\r\n", + " # Define our custom image parameterization, then add it to NaturalImage\r\n", + " image_param = CustomImage\r\n", + " image = optimviz.images.NaturalImage(size=(224, 224), parameterization=image_param)\r\n", + "\r\n", + " transforms = torch.nn.Sequential(\r\n", + " CustomTransform(), # Add our custom transform to the list of transforms\r\n", + "\r\n", + " # Additional transforms to improve output quality\r\n", + " optimviz.transform.RandomSpatialJitter(16),\r\n", + " optimviz.transform.RandomScale(scale=(1, 0.975, 1.025, 0.95, 1.05)),\r\n", + " )\r\n", + "\r\n", + " # Define our custom loss function as the loss function\r\n", + " loss_fn = CustomLoss(target)\r\n", + "\r\n", + " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", + " history = obj.optimize(optimviz.objectives.n_steps(128))\r\n", + " image().show()" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 298, + "referenced_widgets": [ + "5c666868d62e4862a648cd0df15155ec", + "389469a07da6435eb2a1be7ea55f4f86", + "36b86b673b544cc5bdb5652eb31cabc9", + "6d93392ab27048068aa8bb1d7ef01cf1", + "2c759e9a43754fc4963a9631cc7702c5", + "8fa32da11a2a4401a57a50f80af7be32", + "ba6b8e0c07074921a5faa7dbc29f3fe3", + "ea6b900b717c4e8f8051094882aeef1f" + ] + }, + "id": "3m5iQ2zfqV5F", + "outputId": "40b79b81-363c-49c6-8546-9b8ada61665a" + }, + "source": [ + "visualize(model, model.mixed4a)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5c666868d62e4862a648cd0df15155ec", + "version_minor": 0, + "version_major": 2 + }, + "text/plain": [ + "HBox(children=(FloatProgress(value=0.0, max=128.0), HTML(value='')))" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + } + ] +} \ No newline at end of file diff --git a/tutorials/InceptionV1_OptimViz.ipynb b/tutorials/optimviz/InceptionV1_OptimViz.ipynb similarity index 100% rename from tutorials/InceptionV1_OptimViz.ipynb rename to tutorials/optimviz/InceptionV1_OptimViz.ipynb diff --git a/tutorials/TorchVision_OptimViz.ipynb b/tutorials/optimviz/TorchVision_OptimViz.ipynb old mode 100755 new mode 100644 similarity index 100% rename from tutorials/TorchVision_OptimViz.ipynb rename to tutorials/optimviz/TorchVision_OptimViz.ipynb diff --git a/tutorials/WeightVisualization_OptimViz.ipynb b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb similarity index 99% rename from tutorials/WeightVisualization_OptimViz.ipynb rename to tutorials/optimviz/WeightVisualization_OptimViz.ipynb index 270e06a17c..7df4a26f5a 100644 --- a/tutorials/WeightVisualization_OptimViz.ipynb +++ b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb @@ -1381,4 +1381,4 @@ ] } ] -} \ No newline at end of file +} From bbfd07ddd38890bff9d3af4a54a7a8102a2959bb Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 17 Dec 2020 14:28:40 -0700 Subject: [PATCH 42/76] Remove set_image functions --- captum/optim/_param/image/images.py | 15 --------------- 1 file changed, 15 deletions(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index fd8c3e99a2..754094acd8 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -177,9 +177,6 @@ def setup_batch( ) return x - def set_image(self, x: torch.Tensor): - ... - class FFTImage(ImageParameterization): """Parameterize an image using inverse real 2D FFT""" @@ -243,10 +240,6 @@ def pytorch_fftfreq(v: int, d: float = 1.0) -> torch.Tensor: results[s:] = torch.arange(-(v // 2), 0) return results * (1.0 / (v * d)) - def set_image(self, correlated_image: torch.Tensor) -> None: - coeffs = self.torch_rfft(correlated_image) - self.fourier_coeffs = coeffs / self.spectrum_scale - def get_fft_funcs(self) -> Tuple[Callable, Callable]: """Support older versions of PyTorch""" try: @@ -295,9 +288,6 @@ def __init__( def forward(self) -> torch.Tensor: return self.image.refine_names("B", "C", "H", "W") - def set_image(self, correlated_image: torch.Tensor) -> None: - self.image = nn.Parameter(correlated_image) - class LaplacianImage(ImageParameterization): def __init__( @@ -503,8 +493,3 @@ def forward(self) -> torch.Tensor: image = self.decorrelate(image) image = image.rename(None) # TODO: the world is not yet ready return CudaImageTensor(self.squash_func(image)) - - def set_image(self, image: torch.Tensor) -> None: - logits = logit(image, epsilon=1e-4) - correlated = self.decorrelate(logits, inverse=True) - self.parameterization.set_image(correlated) From c3b135973a71d9443f6549fb90e36c4286dedd0e Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Thu, 17 Dec 2020 14:57:47 -0700 Subject: [PATCH 43/76] Minor correction & remove PyTorch UserWarnings --- .../WeightVisualization_OptimViz.ipynb | 216 ++++++++---------- 1 file changed, 93 insertions(+), 123 deletions(-) diff --git a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb index 7df4a26f5a..b66ddf008b 100644 --- a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb +++ b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb @@ -13,7 +13,7 @@ }, "widgets": { "application/vnd.jupyter.widget-state+json": { - "c916baaee35649f5b66baa43bdbb59df": { + "42fbaeeffcc940d980bd3a70d59ac759": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "state": { @@ -25,15 +25,15 @@ "_view_count": null, "_view_module_version": "1.5.0", "box_style": "", - "layout": "IPY_MODEL_2bb4d57151184551b6325e58524d720e", + "layout": "IPY_MODEL_6178f6a4bade4eb7a30b54b26d0f36fe", "_model_module": "@jupyter-widgets/controls", "children": [ - "IPY_MODEL_b999b5e8552d482ab4f1b0e1ea80d1e5", - "IPY_MODEL_b0e972107ae0425db050ce3784052c6f" + "IPY_MODEL_8a96fe98985c4a2c9305acd105c83305", + "IPY_MODEL_70895736a8674f8da04ba8659bdf6c6b" ] } }, - "2bb4d57151184551b6325e58524d720e": { + "6178f6a4bade4eb7a30b54b26d0f36fe": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { @@ -84,12 +84,12 @@ "left": null } }, - "b999b5e8552d482ab4f1b0e1ea80d1e5": { + "8a96fe98985c4a2c9305acd105c83305": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "state": { "_view_name": "ProgressView", - "style": "IPY_MODEL_601144387cf1405d9116818a81d88d3e", + "style": "IPY_MODEL_213eb42d051347e28f88699fb6a69ee5", "_dom_classes": [], "description": "100%", "_model_name": "FloatProgressModel", @@ -104,30 +104,30 @@ "min": 0, "description_tooltip": null, "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_40d7e3d2688a4065a78956f0d090b567" + "layout": "IPY_MODEL_2891473640954ee5b0a9249cc0611a7f" } }, - "b0e972107ae0425db050ce3784052c6f": { + "70895736a8674f8da04ba8659bdf6c6b": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "state": { "_view_name": "HTMLView", - "style": "IPY_MODEL_d8d9192ba2a44c4fa3a83fbbe2029886", + "style": "IPY_MODEL_b042731d18cf45fdb8f2df6eae416e65", "_dom_classes": [], "description": "", "_model_name": "HTMLModel", "placeholder": "​", "_view_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "value": " 128/128 [00:36<00:00, 3.53step/s, Objective=1022.5]", + "value": " 128/128 [02:57<00:00, 1.39s/ step, Objective=0.0]", "_view_count": null, "_view_module_version": "1.5.0", "description_tooltip": null, "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_3fc94e3ced87438288d8bff147eb34a6" + "layout": "IPY_MODEL_00bf36b045f444359f2e715363c226d4" } }, - "601144387cf1405d9116818a81d88d3e": { + "213eb42d051347e28f88699fb6a69ee5": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "state": { @@ -142,7 +142,7 @@ "_model_module": "@jupyter-widgets/controls" } }, - "40d7e3d2688a4065a78956f0d090b567": { + "2891473640954ee5b0a9249cc0611a7f": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { @@ -193,7 +193,7 @@ "left": null } }, - "d8d9192ba2a44c4fa3a83fbbe2029886": { + "b042731d18cf45fdb8f2df6eae416e65": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "state": { @@ -207,7 +207,7 @@ "_model_module": "@jupyter-widgets/controls" } }, - "3fc94e3ced87438288d8bff147eb34a6": { + "00bf36b045f444359f2e715363c226d4": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { @@ -258,7 +258,7 @@ "left": null } }, - "e132a09016234c159637c6df989eacba": { + "3894bed987e14d0f92e03bd548968877": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "state": { @@ -270,15 +270,15 @@ "_view_count": null, "_view_module_version": "1.5.0", "box_style": "", - "layout": "IPY_MODEL_0c755fb79f594742bafb743de238014e", + "layout": "IPY_MODEL_c8c2196005cb4e83992ea45bab85773a", "_model_module": "@jupyter-widgets/controls", "children": [ - "IPY_MODEL_ae636a95c5c7407aae95ebfa07237605", - "IPY_MODEL_204c67654d09436fbbf64c63c6e6114d" + "IPY_MODEL_b5127e0bd8cf4cf2a6a7b23000a7175b", + "IPY_MODEL_9b068cc9a9484573b35868b969e6ae55" ] } }, - "0c755fb79f594742bafb743de238014e": { + "c8c2196005cb4e83992ea45bab85773a": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { @@ -329,12 +329,12 @@ "left": null } }, - "ae636a95c5c7407aae95ebfa07237605": { + "b5127e0bd8cf4cf2a6a7b23000a7175b": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "state": { "_view_name": "ProgressView", - "style": "IPY_MODEL_41867ab292944ec9b511ca7691a7d44d", + "style": "IPY_MODEL_abeadfeae44c498f9e22b4dcffb9d926", "_dom_classes": [], "description": "100%", "_model_name": "FloatProgressModel", @@ -349,30 +349,30 @@ "min": 0, "description_tooltip": null, "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_bc84394660b4440f94864eb0936e6634" + "layout": "IPY_MODEL_ce65fff533e24a2295fcdee9c8cb1b4d" } }, - "204c67654d09436fbbf64c63c6e6114d": { + "9b068cc9a9484573b35868b969e6ae55": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "state": { "_view_name": "HTMLView", - "style": "IPY_MODEL_45a6c54c2d2c48a4975346c5b582f2f2", + "style": "IPY_MODEL_0df84d7b9c9c4d65afc3e6d3a813c10a", "_dom_classes": [], "description": "", "_model_name": "HTMLModel", "placeholder": "​", "_view_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "value": " 128/128 [00:45<00:00, 2.79step/s, Objective=4041.6]", + "value": " 128/128 [02:26<00:00, 1.14s/ step, Objective=4471.2]", "_view_count": null, "_view_module_version": "1.5.0", "description_tooltip": null, "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_d5232a8d98764bb38e0144c67a9be7d3" + "layout": "IPY_MODEL_f00ac77672a64cfdafccf97581775b78" } }, - "41867ab292944ec9b511ca7691a7d44d": { + "abeadfeae44c498f9e22b4dcffb9d926": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "state": { @@ -387,7 +387,7 @@ "_model_module": "@jupyter-widgets/controls" } }, - "bc84394660b4440f94864eb0936e6634": { + "ce65fff533e24a2295fcdee9c8cb1b4d": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { @@ -438,7 +438,7 @@ "left": null } }, - "45a6c54c2d2c48a4975346c5b582f2f2": { + "0df84d7b9c9c4d65afc3e6d3a813c10a": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "state": { @@ -452,7 +452,7 @@ "_model_module": "@jupyter-widgets/controls" } }, - "d5232a8d98764bb38e0144c67a9be7d3": { + "f00ac77672a64cfdafccf97581775b78": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { @@ -503,7 +503,7 @@ "left": null } }, - "17cd567871164a309ad8647234fc7e6e": { + "b588cd0a794e42f789729de0182f1723": { "model_module": "@jupyter-widgets/controls", "model_name": "HBoxModel", "state": { @@ -515,15 +515,15 @@ "_view_count": null, "_view_module_version": "1.5.0", "box_style": "", - "layout": "IPY_MODEL_68d7b1cbc7f54e05b83731c299a293c8", + "layout": "IPY_MODEL_81fe4386a7ea40dda821ebf7eca095bc", "_model_module": "@jupyter-widgets/controls", "children": [ - "IPY_MODEL_253faa5f26994760aba84c5cdc8c8edb", - "IPY_MODEL_18b3695da5fa4ceebffc88286b2c0aed" + "IPY_MODEL_7fd03615817f4e5b8996c1826fbc3e36", + "IPY_MODEL_924be6da1cf943c4b3010c43919f96d3" ] } }, - "68d7b1cbc7f54e05b83731c299a293c8": { + "81fe4386a7ea40dda821ebf7eca095bc": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { @@ -574,12 +574,12 @@ "left": null } }, - "253faa5f26994760aba84c5cdc8c8edb": { + "7fd03615817f4e5b8996c1826fbc3e36": { "model_module": "@jupyter-widgets/controls", "model_name": "FloatProgressModel", "state": { "_view_name": "ProgressView", - "style": "IPY_MODEL_bbb055348e9c4e99a36b4ce71195eaf0", + "style": "IPY_MODEL_3a01f27740754bdbb68bee7bcd0f2ca5", "_dom_classes": [], "description": "100%", "_model_name": "FloatProgressModel", @@ -594,30 +594,30 @@ "min": 0, "description_tooltip": null, "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_f33ed004c31a4347b5e644721ce2b6c8" + "layout": "IPY_MODEL_be742d9de0a64f21837d019cabb1081b" } }, - "18b3695da5fa4ceebffc88286b2c0aed": { + "924be6da1cf943c4b3010c43919f96d3": { "model_module": "@jupyter-widgets/controls", "model_name": "HTMLModel", "state": { "_view_name": "HTMLView", - "style": "IPY_MODEL_c6f6f5e291ba4032a1b0648f87720c35", + "style": "IPY_MODEL_6675818472864b579393dac79d1f235d", "_dom_classes": [], "description": "", "_model_name": "HTMLModel", "placeholder": "​", "_view_module": "@jupyter-widgets/controls", "_model_module_version": "1.5.0", - "value": " 128/128 [32:11<00:00, 15.09s/step, Objective=4029.8]", + "value": " 128/128 [01:30<00:00, 1.41 step/s, Objective=2683.3]", "_view_count": null, "_view_module_version": "1.5.0", "description_tooltip": null, "_model_module": "@jupyter-widgets/controls", - "layout": "IPY_MODEL_15a632adfb484d93b5317536805a6443" + "layout": "IPY_MODEL_b7fc8160950d41b6a73381f6308b88d8" } }, - "bbb055348e9c4e99a36b4ce71195eaf0": { + "3a01f27740754bdbb68bee7bcd0f2ca5": { "model_module": "@jupyter-widgets/controls", "model_name": "ProgressStyleModel", "state": { @@ -632,7 +632,7 @@ "_model_module": "@jupyter-widgets/controls" } }, - "f33ed004c31a4347b5e644721ce2b6c8": { + "be742d9de0a64f21837d019cabb1081b": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { @@ -683,7 +683,7 @@ "left": null } }, - "c6f6f5e291ba4032a1b0648f87720c35": { + "6675818472864b579393dac79d1f235d": { "model_module": "@jupyter-widgets/controls", "model_name": "DescriptionStyleModel", "state": { @@ -697,7 +697,7 @@ "_model_module": "@jupyter-widgets/controls" } }, - "15a632adfb484d93b5317536805a6443": { + "b7fc8160950d41b6a73381f6308b88d8": { "model_module": "@jupyter-widgets/base", "model_name": "LayoutModel", "state": { @@ -883,7 +883,7 @@ " history = obj.optimize(optimviz.objectives.n_steps(128, False))\r\n", " return image()._t" ], - "execution_count": null, + "execution_count": 4, "outputs": [] }, { @@ -896,7 +896,7 @@ "\r\n", "We can extract expanded weights with Captum.optim's get_expanded_weights function.\r\n", "\r\n", - "Below we extract the expanded weights from between the mixed3a and mixed3b layers. The output tensor is in the form of / has a shape of: `[output channels, input channels, y, x]`" + "Below we extract the expanded weights from between the mixed3a and mixed3b layers. The output tensor is in the form of / has a shape of: `[input channels, y, x, output channels]`, so we move the output channels to the front to match PyTorch's standard weight format." ] }, { @@ -908,7 +908,7 @@ "W_3a_3b = optimviz.circuits.get_expanded_weights(model, model.mixed3a, model.mixed3b)\r\n", "W_3a_3b = W_3a_3b.permute(3, 0, 1, 2) # Move output channels to front for simplicity" ], - "execution_count": null, + "execution_count": 5, "outputs": [] }, { @@ -968,40 +968,40 @@ "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 708, + "height": 579, "referenced_widgets": [ - "c916baaee35649f5b66baa43bdbb59df", - "2bb4d57151184551b6325e58524d720e", - "b999b5e8552d482ab4f1b0e1ea80d1e5", - "b0e972107ae0425db050ce3784052c6f", - "601144387cf1405d9116818a81d88d3e", - "40d7e3d2688a4065a78956f0d090b567", - "d8d9192ba2a44c4fa3a83fbbe2029886", - "3fc94e3ced87438288d8bff147eb34a6", - "e132a09016234c159637c6df989eacba", - "0c755fb79f594742bafb743de238014e", - "ae636a95c5c7407aae95ebfa07237605", - "204c67654d09436fbbf64c63c6e6114d", - "41867ab292944ec9b511ca7691a7d44d", - "bc84394660b4440f94864eb0936e6634", - "45a6c54c2d2c48a4975346c5b582f2f2", - "d5232a8d98764bb38e0144c67a9be7d3" + "42fbaeeffcc940d980bd3a70d59ac759", + "6178f6a4bade4eb7a30b54b26d0f36fe", + "8a96fe98985c4a2c9305acd105c83305", + "70895736a8674f8da04ba8659bdf6c6b", + "213eb42d051347e28f88699fb6a69ee5", + "2891473640954ee5b0a9249cc0611a7f", + "b042731d18cf45fdb8f2df6eae416e65", + "00bf36b045f444359f2e715363c226d4", + "3894bed987e14d0f92e03bd548968877", + "c8c2196005cb4e83992ea45bab85773a", + "b5127e0bd8cf4cf2a6a7b23000a7175b", + "9b068cc9a9484573b35868b969e6ae55", + "abeadfeae44c498f9e22b4dcffb9d926", + "ce65fff533e24a2295fcdee9c8cb1b4d", + "0df84d7b9c9c4d65afc3e6d3a813c10a", + "f00ac77672a64cfdafccf97581775b78" ] }, "id": "8pCOa_o4xF0w", - "outputId": "58960e52-94f0-4abb-aebe-b0045afe83b5" + "outputId": "bbb5120c-886f-49d1-fea7-dc366b649271" }, "source": [ "visualize_activations(model, model.mixed3a, 147)\r\n", "visualize_activations(model, model.mixed3b, 379)" ], - "execution_count": null, + "execution_count": 9, "outputs": [ { "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c916baaee35649f5b66baa43bdbb59df", + "model_id": "42fbaeeffcc940d980bd3a70d59ac759", "version_minor": 0, "version_major": 2 }, @@ -1013,18 +1013,6 @@ "tags": [] } }, - { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/torch/tensor.py:775: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at /pytorch/c10/core/TensorImpl.h:848.)\n", - " return super(Tensor, self).refine_names(names)\n", - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" - ], - "name": "stderr" - }, { "output_type": "stream", "text": [ @@ -1035,7 +1023,7 @@ { "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1049,7 +1037,7 @@ "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e132a09016234c159637c6df989eacba", + "model_id": "3894bed987e14d0f92e03bd548968877", "version_minor": 0, "version_major": 2 }, @@ -1071,7 +1059,7 @@ { "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1145,31 +1133,31 @@ "metadata": { "colab": { "base_uri": "https://localhost:8080/", - "height": 391, + "height": 298, "referenced_widgets": [ - "17cd567871164a309ad8647234fc7e6e", - "68d7b1cbc7f54e05b83731c299a293c8", - "253faa5f26994760aba84c5cdc8c8edb", - "18b3695da5fa4ceebffc88286b2c0aed", - "bbb055348e9c4e99a36b4ce71195eaf0", - "f33ed004c31a4347b5e644721ce2b6c8", - "c6f6f5e291ba4032a1b0648f87720c35", - "15a632adfb484d93b5317536805a6443" + "b588cd0a794e42f789729de0182f1723", + "81fe4386a7ea40dda821ebf7eca095bc", + "7fd03615817f4e5b8996c1826fbc3e36", + "924be6da1cf943c4b3010c43919f96d3", + "3a01f27740754bdbb68bee7bcd0f2ca5", + "be742d9de0a64f21837d019cabb1081b", + "6675818472864b579393dac79d1f235d", + "b7fc8160950d41b6a73381f6308b88d8" ] }, "id": "mgzEU3Iu2R5Y", - "outputId": "49aaa682-ce3b-4072-8a94-cadbd0842af0" + "outputId": "f1ae425b-3b71-471e-f8e2-1ecdedf2fd86" }, "source": [ "visualize_activations(model, model.mixed3b, 320)" ], - "execution_count": null, + "execution_count": 10, "outputs": [ { "output_type": "display_data", "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "17cd567871164a309ad8647234fc7e6e", + "model_id": "b588cd0a794e42f789729de0182f1723", "version_minor": 0, "version_major": 2 }, @@ -1181,16 +1169,6 @@ "tags": [] } }, - { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3448: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n", - "/usr/local/lib/python3.6/dist-packages/torch/nn/functional.py:3385: UserWarning: Default grid_sample and affine_grid behavior has changed to align_corners=False since 1.3.0. Please specify align_corners=True if the old behavior is desired. See the documentation of grid_sample for details.\n", - " warnings.warn(\"Default grid_sample and affine_grid behavior has changed \"\n" - ], - "name": "stderr" - }, { "output_type": "stream", "text": [ @@ -1201,7 +1179,7 @@ { "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1301,7 +1279,7 @@ "W_p_3a = optimviz.circuits.get_expanded_weights(model, model.pool1, model.mixed3a)\r\n", "W_p_3a = W_p_3a.permute(3, 0, 1, 2)" ], - "execution_count": null, + "execution_count": 11, "outputs": [] }, { @@ -1310,9 +1288,9 @@ "id": "3u0pjw04rgY6", "colab": { "base_uri": "https://localhost:8080/", - "height": 509 + "height": 453 }, - "outputId": "30ad9413-47b3-4176-b7be-d06bb9ce0ffe" + "outputId": "5ba59d03-2fbd-46d7-eee8-f30b93787815" }, "source": [ "highlow_units = [110, 180, 153, 106, 112, 186, 132, 136, 117, 113, 108, 70, 86, 88, 160]\r\n", @@ -1342,20 +1320,12 @@ "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", "show(grid_img)" ], - "execution_count": null, + "execution_count": 12, "outputs": [ - { - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.6/dist-packages/torch/tensor.py:775: UserWarning: Named tensors and all their associated APIs are an experimental feature and subject to change. Please do not use them for anything important until they are released as stable. (Triggered internally at /pytorch/c10/core/TensorImpl.h:848.)\n", - " return super(Tensor, self).refine_names(names)\n" - ], - "name": "stderr" - }, { "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1381,4 +1351,4 @@ ] } ] -} +} \ No newline at end of file From 2520d1cd6bda624b186682bc4c586ecc88121346 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 18 Dec 2020 14:22:31 -0700 Subject: [PATCH 44/76] Add simple n_channels to RGB function --- captum/optim/_utils/reducer.py | 62 +++++++++++++++++++++++++++++++ tests/optim/utils/test_reducer.py | 12 ++++++ 2 files changed, 74 insertions(+) diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index 9ef4796f56..eeba19a09d 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -1,3 +1,4 @@ +import math from typing import Any, Callable, List, Union import numpy as np @@ -128,3 +129,64 @@ def posneg(x: torch.Tensor, dim: int = 0) -> torch.Tensor: [torch.max(x, torch.full_like(x, 0)), torch.max(-x, torch.full_like(x, 0))], dim=dim, ) + + +def nchannels_to_rgb(x: torch.Tensor, warp: bool = True) -> torch.Tensor: + """ + Convert an NCHW image with n channels into a 3 channel RGB image. + + Args: + x (torch.Tensor): Image tensor to transform into RGB image. + warp (bool, optional): Whether or not to make colors more distinguishable. + Default: True + Returns: + *tensor* RGB image + """ + + def hue_to_rgb(angle: float) -> torch.Tensor: + """ + Create an RGB unit vector based on a hue of the input angle. + """ + + angle = angle - 360 * (angle // 360) + colors = torch.tensor( + [ + [1.0, 0.0, 0.0], + [0.7071, 0.7071, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.7071, 0.7071], + [0.0, 0.0, 1.0], + [0.7071, 0.0, 0.7071], + ] + ) + + idx = math.floor(angle / 60) + d = (angle - idx * 60) / 60 + + if warp: + + def adj(x: float) -> float: + return math.sin(x * math.pi / 2) + + d = adj(d) if idx % 2 == 0 else 1 - adj(1 - d) + + vec = (1 - d) * colors[idx] + d * colors[(idx + 1) % 6] + return vec / torch.norm(vec) + + assert x.dim() == 4 + + if (x < 0).any(): + x = posneg(x.permute(0, 2, 3, 1), -1).permute(0, 3, 1, 2) + + rgb = torch.zeros(1, 3, x.size(2), x.size(3), device=x.device) + nc = x.size(1) + for i in range(nc): + rgb = rgb + x[:, i][:, None, :, :] + rgb = rgb * hue_to_rgb(360 * i / nc).to(device=x.device)[None, :, None, None] + + rgb = rgb + torch.ones(x.size(2), x.size(3))[None, None, :, :] * ( + torch.sum(x, 1)[:, None] - torch.max(x, 1)[0][:, None] + ) + return (rgb / (1e-4 + torch.norm(rgb, dim=1, keepdim=True))) * torch.norm( + x, dim=1, keepdim=True + ) diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py index 6a99f01a89..d921364a69 100644 --- a/tests/optim/utils/test_reducer.py +++ b/tests/optim/utils/test_reducer.py @@ -144,5 +144,17 @@ def test_posneg(self) -> None: ) +class TestNChannelsToRGB(BaseTest): + def test_nchannels_to_rgb_collapse(self) -> None: + test_input = torch.randn(1, 6, 224, 224) + test_output = reducer.nchannels_to_rgb(test_input) + self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) + + def test_nchannels_to_rgb_increase(self) -> None: + test_input = torch.randn(1, 2, 224, 224) + test_output = reducer.nchannels_to_rgb(test_input) + self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) + + if __name__ == "__main__": unittest.main() From ff7cdffc48fc99087437537699da15f3f6fe742a Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Fri, 18 Dec 2020 20:00:57 -0700 Subject: [PATCH 45/76] Implement changes based on feedback --- captum/optim/_param/image/images.py | 20 ++++++++++++-------- captum/optim/_param/image/transform.py | 3 ++- tests/optim/param/test_images.py | 10 ++++++++++ 3 files changed, 24 insertions(+), 9 deletions(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index 754094acd8..c979ff6ef7 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -364,16 +364,17 @@ class SharedImage(ImageParameterization): def __init__( self, shapes: Union[Tuple[Tuple[int]], Tuple[int]] = None, - parameterization=None, + parameterization: ImageParameterization = None, offset: Union[int, Tuple[int], Tuple[Tuple[int]], None] = None, ) -> None: super().__init__() + assert shapes is not None A = [] shared_shapes = [shapes] if type(shapes[0]) is not tuple else shapes for shape in shared_shapes: assert len(shape) >= 2 and len(shape) <= 4 shape = ([1] * (4 - len(shape))) + list(shape) - batch, channels, height, width = shape[0], shape[1], shape[2], shape[3] + batch, channels, height, width = shape A.append(torch.nn.Parameter(torch.randn([batch, channels, height, width]))) self.shared_init = torch.nn.ParameterList(A) self.parameterization = parameterization @@ -388,7 +389,7 @@ def get_offset(self, offset: Union[int, Tuple[int]], n: int) -> List[List[int]]: offset = [([0] * (4 - len(offset))) + list(offset)] * n else: offset = [[offset] * 4] * n - offset = [[int(o) for o in v] for v in offset] + assert all([all([type(o) is int for o in v]) for v in offset]) return offset def apply_offset( @@ -403,10 +404,12 @@ def apply_offset( return A def interpolate_tensor( - self, x: torch.Tensor, size: InitSize, batch: int, channels: int + self, x: torch.Tensor, batch: int, channels: int, height: int, width: int ) -> torch.Tensor: """ Linear interpolation for 4D, 5D, and 6D tensors. + If the batch dimension needs to be resized, + we move it's location temporarily for F.interpolate. """ if x.size(1) == channels: @@ -414,8 +417,8 @@ def interpolate_tensor( else: mode = "trilinear" x = x.unsqueeze(0) - size = (channels, size[0], size[1]) - x = F.interpolate(x, size=size, mode=mode) + size = (channels, height, width) + x = F.interpolate(x, size=(height, width), mode=mode) x = x.squeeze(0) if len(size) == 3 else x if x.size(0) != batch: x = x.permute(1, 0, 2, 3) @@ -432,9 +435,10 @@ def forward(self) -> torch.Tensor: x = [ self.interpolate_tensor( shared_tensor, - (image.size(2), image.size(3)), image.size(0), image.size(1), + image.size(2), + image.size(3)), ) for shared_tensor in self.shared_init ] @@ -462,7 +466,7 @@ def __init__( size: InitSize = None, channels: int = 3, batch: int = 1, - parameterization=FFTImage, + parameterization: ImageParameterization = FFTImage, init: Optional[torch.Tensor] = None, decorrelate_init: bool = True, squash_func: Optional[SquashFunc] = None, diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index 65ae9a1dc6..ebfd4140df 100644 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -231,11 +231,12 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: class RGBToBGR(nn.Module): """ - Converts RGB images to BGR by switching the red and blue channels. + Converts an NCHW RGB image tensor to BGR by switching the red and blue channels. """ def forward(self, x: torch.Tensor) -> torch.Tensor: assert x.dim() == 4 + assert x.size(1) == 3 return x[:, [2, 1, 0]] diff --git a/tests/optim/param/test_images.py b/tests/optim/param/test_images.py index 3593b6cf87..a4989e8809 100644 --- a/tests/optim/param/test_images.py +++ b/tests/optim/param/test_images.py @@ -400,6 +400,8 @@ def test_sharedimage_single_shape_hw_forward(self) -> None: ) test_tensor = image_param.forward() + self.assertEqual(image_param.shared_init.dim(), 4) + self.assertEqual(image_param.shared_init.shape, (1, 1, 128 // 2, 128 // 2)) self.assertEqual(test_tensor.dim(), 4) self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) @@ -422,6 +424,8 @@ def test_sharedimage_single_shape_chw_forward(self) -> None: ) test_tensor = image_param.forward() + self.assertEqual(image_param.shared_init.dim(), 4) + self.assertEqual(image_param.shared_init.shape, (1, 1, 128 // 2, 128 // 2)) self.assertEqual(test_tensor.dim(), 4) self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) @@ -444,6 +448,8 @@ def test_sharedimage_single_shape_bchw_forward(self) -> None: ) test_tensor = image_param.forward() + self.assertEqual(image_param.shared_init.dim(), 4) + self.assertEqual(image_param.shared_init.shape, (1, 1, 128 // 2, 128 // 2)) self.assertEqual(test_tensor.dim(), 4) self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) @@ -473,6 +479,8 @@ def test_sharedimage_multiple_shapes_forward(self) -> None: ) test_tensor = image_param.forward() + self.assertEqual(image_param.shared_init.dim(), 4) + self.assertEqual(image_param.shared_init.shape, (1, 1, 128 // 2, 128 // 2)) self.assertEqual(test_tensor.dim(), 4) self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) @@ -502,6 +510,8 @@ def test_sharedimage_multiple_shapes_diff_len_forward(self) -> None: ) test_tensor = image_param.forward() + self.assertEqual(image_param.shared_init.dim(), 4) + self.assertEqual(image_param.shared_init.shape, (1, 1, 128 // 2, 128 // 2)) self.assertEqual(test_tensor.dim(), 4) self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) From a276a8c2b44948f372fbe936df802ca6b7ef5984 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sat, 19 Dec 2020 15:30:03 -0700 Subject: [PATCH 46/76] Implement additional changes based on feedback --- captum/optim/_param/image/images.py | 1019 +++++++++++++------------ captum/optim/_utils/models.py | 34 + tests/optim/param/test_images.py | 80 +- tests/optim/utils/test_model_utils.py | 14 + tests/optim/utils/test_reducer.py | 6 +- 5 files changed, 630 insertions(+), 523 deletions(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index c979ff6ef7..b9bab2ff1c 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -1,499 +1,520 @@ -from copy import deepcopy -from typing import Any, Callable, Dict, List, Optional, Tuple, Union - -import matplotlib.pyplot as plt -import numpy as np -import torch -import torch.nn as nn -import torch.nn.functional as F - -try: - from PIL import Image -except (ImportError, AssertionError): - print("The Pillow/PIL library is required to use Captum's Optim library") - -from captum.optim._param.image.transform import ToRGB -from captum.optim._utils.typing import InitSize, SquashFunc - - -class ImageTensor(torch.Tensor): - def __init__(self, data, **kwargs) -> None: - if not isinstance(data, torch.Tensor): - data = torch.as_tensor(data, **kwargs) - self._t = data - - @classmethod - def open(cls, path: str, scale: float = 255.0): - img_np = Image.open(path).convert("RGB") - img_np = np.array(img_np).astype(np.float32) - return cls(img_np.transpose(2, 0, 1) / scale) - - @classmethod - def __torch_function__( - self, - func: Callable, - types: Tuple, - args: Tuple = (), - kwargs: Optional[Dict] = None, - ) -> Any: - if kwargs is None: - kwargs = {} - args_t = [a._t if hasattr(a, "_t") else a for a in args] - return super().__torch_function__(func, types, args_t, **kwargs) - - def __repr__(self) -> str: - return f"ImageTensor(value={self._t})" - - def show(self, scale: float = 255.0) -> None: - if len(self.shape) == 3: - numpy_thing = self.cpu().detach().numpy().transpose(1, 2, 0) * scale - elif len(self.shape) == 4: - numpy_thing = self.cpu().detach().numpy()[0].transpose(1, 2, 0) * scale - plt.imshow(numpy_thing.astype(np.uint8)) - plt.axis("off") - plt.show() - - def export(self, filename: str, scale: float = 255.0) -> None: - colorspace = "RGB" if self.size(1) == 3 else "RGBA" - if len(self.shape) == 3: - numpy_thing = self.cpu().detach().numpy().transpose(1, 2, 0) * scale - elif len(self.shape) == 4: - numpy_thing = self.cpu().detach().numpy()[0].transpose(1, 2, 0) * scale - im = Image.fromarray(numpy_thing.astype("uint8"), colorspace) - im.save(filename) - - def cpu(self) -> "ImageTensor": - return self - - def cuda(self) -> "CudaImageTensor": - return CudaImageTensor(self._t, device="cuda") - - -class CudaImageTensor(object): - def __init__(self, data, **kwargs) -> None: - self._t = torch.as_tensor(data, **kwargs) - - @classmethod - def __torch_function__( - self, - func: Callable, - types: Tuple, - args: Tuple = (), - kwargs: Optional[Dict] = None, - ) -> Any: - if kwargs is None: - kwargs = {} - args_t = [a._t if hasattr(a, "_t") else a for a in args] - return super().__torch_function__(func, types, args_t, **kwargs) - - def __repr__(self) -> str: - return f"CudaImageTensor(value={self._t})" - - @property - def shape(self) -> torch.Size: - return self._t.shape - - @property - def size(self) -> torch.Size: - return self._t.size() - - def show(self) -> None: - self.cpu().show() - - def export(self, filename: str) -> None: - self.cpu().export(filename) - - def cpu(self) -> "ImageTensor": - return ImageTensor(self._t.cpu()) - - def cuda(self) -> "CudaImageTensor": - return self - - -# mean = [0.485, 0.456, 0.406] -# std = [0.229, 0.224, 0.225] - -# normalize = transforms.Normalize(mean=mean, std=std) - -# mean = torch.Tensor(mean)[None, :, None, None] -# std = torch.Tensor(std)[None, :, None, None] - - -# def denormalize(x: torch.Tensor): -# return std * x + mean - - -def logit(p: torch.Tensor, epsilon: float = 1e-6) -> torch.Tensor: - p = torch.clamp(p, min=epsilon, max=1.0 - epsilon) - assert p.min() >= 0 and p.max() < 1 - return torch.log(p / (1 - p)) - - -# def jitter(x: torch.Tensor, pad_width=2, pad_value=0.5): -# _, _, H, W = x.shape -# y = F.pad(x, 4 * (pad_width,), value=pad_value) -# idx, idy = np.random.randint(low=0, high=2 * pad_width, size=(2,)) -# return y[:, :, idx : idx + H, idy : idy + W] - - -# def color_correction(): -# S = np.asarray( -# [[0.26, 0.09, 0.02], [0.27, 0.00, -0.05], [0.27, -0.09, 0.03]] -# ).astype("float32") -# C = S / np.max(np.linalg.norm(S, axis=0)) -# C = torch.Tensor(C) -# return C.transpose(0, 1) - - -# def upsample(): -# upsample = torch.nn.Upsample(scale_factor=1.1, mode="bilinear", -# align_corners=True) - -# def up(x): -# upsample.scale_factor = ( -# 1 + np.random.randn(1)[0] / 50, -# 1 + np.random.randn(1)[0] / 50, -# ) -# return upsample(x) - -# return up - - -class InputParameterization(torch.nn.Module): - def forward(self): - raise NotImplementedError - - -class ImageParameterization(InputParameterization): - def setup_batch( - self, x: torch.Tensor, batch: int = 1, dim: int = 3 - ) -> torch.Tensor: - assert batch > 0 - x = x.unsqueeze(0) if x.dim() == dim and batch == 1 else x - x = ( - torch.stack([x.clone() for b in range(batch)]) - if x.dim() == dim and batch > 1 - else x - ) - return x - - -class FFTImage(ImageParameterization): - """Parameterize an image using inverse real 2D FFT""" - - def __init__( - self, - size: InitSize = None, - channels: int = 3, - batch: int = 1, - init: Optional[torch.Tensor] = None, - ) -> None: - super().__init__() - if init is None: - assert len(size) == 2 - self.size = size - else: - assert init.dim() == 3 or init.dim() == 4 - self.size = ( - (init.size(1), init.size(2)) - if init.dim() == 3 - else (init.size(2), init.size(3)) - ) - self.torch_rfft, self.torch_irfft = self.get_fft_funcs() - - frequencies = FFTImage.rfft2d_freqs(*self.size) - scale = 1.0 / torch.max( - frequencies, - torch.full_like(frequencies, 1.0 / (max(self.size[0], self.size[1]))), - ) - scale = scale * ((self.size[0] * self.size[1]) ** (1 / 2)) - spectrum_scale = scale[None, :, :, None] - self.register_buffer("spectrum_scale", spectrum_scale) - - if init is None: - coeffs_shape = (channels, self.size[0], self.size[1] // 2 + 1, 2) - random_coeffs = torch.randn( - coeffs_shape - ) # names=["C", "H_f", "W_f", "complex"] - fourier_coeffs = random_coeffs / 50 - else: - fourier_coeffs = self.torch_rfft(init) / spectrum_scale - - fourier_coeffs = self.setup_batch(fourier_coeffs, batch, 4) - self.fourier_coeffs = nn.Parameter(fourier_coeffs) - - @staticmethod - def rfft2d_freqs(height: int, width: int) -> torch.Tensor: - """Computes 2D spectrum frequencies.""" - fy = FFTImage.pytorch_fftfreq(height)[:, None] - # on odd input dimensions we need to keep one additional frequency - wadd = 2 if width % 2 == 1 else 1 - fx = FFTImage.pytorch_fftfreq(width)[: width // 2 + wadd] - return torch.sqrt((fx * fx) + (fy * fy)) - - @staticmethod - def pytorch_fftfreq(v: int, d: float = 1.0) -> torch.Tensor: - """PyTorch version of np.fft.fftfreq""" - results = torch.empty(v) - s = (v - 1) // 2 + 1 - results[:s] = torch.arange(0, s) - results[s:] = torch.arange(-(v // 2), 0) - return results * (1.0 / (v * d)) - - def get_fft_funcs(self) -> Tuple[Callable, Callable]: - """Support older versions of PyTorch""" - try: - import torch.fft - - torch_rfft = lambda x: torch.view_as_real(torch.fft.rfftn(x, s=self.size)) # type: ignore # noqa: E731 E501 - - def torch_irfft(x: torch.Tensor) -> torch.Tensor: - if type(x) is not torch.complex64: - x = torch.view_as_complex(x) - return torch.fft.irfftn(x, s=self.size) # type: ignore - - except (ImportError, AssertionError): - import torch - - torch_rfft = lambda x: torch.rfft(x, signal_ndim=2) # noqa: E731 - torch_irfft = lambda x: torch.irfft(x, signal_ndim=2)[ # noqa: E731 - :, :, : self.size[0], : self.size[1] # noqa: E731 - ] # noqa: E731 - return torch_rfft, torch_irfft - - def forward(self) -> torch.Tensor: - h, w = self.size - scaled_spectrum = self.fourier_coeffs * self.spectrum_scale - output = self.torch_irfft(scaled_spectrum) - return output.refine_names("B", "C", "H", "W") - - -class PixelImage(ImageParameterization): - def __init__( - self, - size: InitSize = None, - channels: int = 3, - batch: int = 1, - init: Optional[torch.Tensor] = None, - ) -> None: - super().__init__() - if init is None: - assert size is not None and channels is not None and batch is not None - init = torch.randn([channels, size[0], size[1]]) / 10 + 0.5 - else: - assert init.shape[0] == 3 - init = self.setup_batch(init, batch) - self.image = nn.Parameter(init) - - def forward(self) -> torch.Tensor: - return self.image.refine_names("B", "C", "H", "W") - - -class LaplacianImage(ImageParameterization): - def __init__( - self, - size: InitSize = None, - channels: int = 3, - batch: int = 1, - init: Optional[torch.Tensor] = None, - ) -> None: - super().__init__() - power = 0.1 - - if init is None: - tensor_params, self.scaler = self.setup_input(size, channels, power, init) - - self.tensor_params = torch.nn.ModuleList( - [deepcopy(tensor_params) for b in range(batch)] - ) - else: - init = init.unsqueeze(0) if init.dim() == 3 else init - P = [] - for b in range(init.size(0)): - tensor_params, self.scaler = self.setup_input( - size, channels, power, init[b].unsqueeze(0) - ) - P.append(tensor_params) - self.tensor_params = torch.nn.ModuleList(P) - - def setup_input( - self, - size: InitSize, - channels: int, - power: float = 0.1, - init: Optional[torch.Tensor] = None, - ) -> Tuple[List[torch.Tensor], List[torch.nn.Upsample]]: - tensor_params, scaler = [], [] - scale_list = [1, 2, 4, 8, 16, 32] - for scale in scale_list: - h, w = int(size[0] // scale), int(size[1] // scale) - if init is None: - x = torch.randn([1, channels, h, w]) / 10 - else: - x = F.interpolate(init.clone(), size=(h, w), mode="bilinear") - x = x / 6 # Prevents output from being all white - upsample = torch.nn.Upsample(scale_factor=scale, mode="nearest") - x = x * (scale ** power) / (32 ** power) - x = torch.nn.Parameter(x) - tensor_params.append(x) - scaler.append(upsample) - tensor_params = torch.nn.ParameterList(tensor_params) - return tensor_params, scaler - - def create_tensor(self, params_list: torch.nn.ParameterList) -> torch.Tensor: - A = [] - for xi, upsamplei in zip(params_list, self.scaler): - A.append(upsamplei(xi)) - return torch.sum(torch.cat(A), 0) + 0.5 - - def forward(self) -> torch.Tensor: - A = [] - for params_list in self.tensor_params: - tensor = self.create_tensor(params_list) - A.append(tensor) - return torch.stack(A).refine_names("B", "C", "H", "W") - - -class SharedImage(ImageParameterization): - """ - Share some image parameters across the batch. - Mordvintsev, et al., "Differentiable Image Parameterizations", Distill, 2018. - https://distill.pub/2018/differentiable-parameterizations/ - """ - - def __init__( - self, - shapes: Union[Tuple[Tuple[int]], Tuple[int]] = None, - parameterization: ImageParameterization = None, - offset: Union[int, Tuple[int], Tuple[Tuple[int]], None] = None, - ) -> None: - super().__init__() - assert shapes is not None - A = [] - shared_shapes = [shapes] if type(shapes[0]) is not tuple else shapes - for shape in shared_shapes: - assert len(shape) >= 2 and len(shape) <= 4 - shape = ([1] * (4 - len(shape))) + list(shape) - batch, channels, height, width = shape - A.append(torch.nn.Parameter(torch.randn([batch, channels, height, width]))) - self.shared_init = torch.nn.ParameterList(A) - self.parameterization = parameterization - self.offset = self.get_offset(offset, len(A)) if offset is not None else None - - def get_offset(self, offset: Union[int, Tuple[int]], n: int) -> List[List[int]]: - if type(offset) is tuple or type(offset) is list: - if type(offset[0]) is tuple or type(offset[0]) is list: - assert len(offset) == n and all(len(t) == 4 for t in offset) - else: - assert len(offset) >= 1 and len(offset) <= 4 - offset = [([0] * (4 - len(offset))) + list(offset)] * n - else: - offset = [[offset] * 4] * n - assert all([all([type(o) is int for o in v]) for v in offset]) - return offset - - def apply_offset( - self, x_list: List[torch.Tensor], size: Tuple[int] - ) -> List[torch.Tensor]: - assert len(size) == 4 - A = [] - for x, offset in zip(x_list, self.offset): - x = F.pad(x, offset, "reflect") - x = x[: size[0], : size[1], : size[2], : size[3]] - A.append(x) - return A - - def interpolate_tensor( - self, x: torch.Tensor, batch: int, channels: int, height: int, width: int - ) -> torch.Tensor: - """ - Linear interpolation for 4D, 5D, and 6D tensors. - If the batch dimension needs to be resized, - we move it's location temporarily for F.interpolate. - """ - - if x.size(1) == channels: - mode = "bilinear" - else: - mode = "trilinear" - x = x.unsqueeze(0) - size = (channels, height, width) - x = F.interpolate(x, size=(height, width), mode=mode) - x = x.squeeze(0) if len(size) == 3 else x - if x.size(0) != batch: - x = x.permute(1, 0, 2, 3) - x = F.interpolate( - x.unsqueeze(0), - size=(batch, x.size(2), x.size(3)), - mode="trilinear", - ).squeeze(0) - x = x.permute(1, 0, 2, 3) - return x - - def forward(self) -> torch.Tensor: - image = self.parameterization() - x = [ - self.interpolate_tensor( - shared_tensor, - image.size(0), - image.size(1), - image.size(2), - image.size(3)), - ) - for shared_tensor in self.shared_init - ] - if self.offset is not None: - x = self.apply_offset(x, tuple(image.size())) - return (image + sum(x)).refine_names("B", "C", "H", "W") - - -class NaturalImage(ImageParameterization): - r"""Outputs an optimizable input image. - - By convention, single images are CHW and float32s in [0,1]. - The underlying parameterization is decorrelated via a ToRGB transform. - When used with the (default) FFT parameterization, this results in a fully - uncorrelated image parameterization. :-) - - If a model requires a normalization step, such as normalizing imagenet RGB values, - or rescaling to [0,255], it can perform those steps with the provided transforms or - inside its computation. - For example, our GoogleNet factory function has a `transform_input=True` argument. - """ - - def __init__( - self, - size: InitSize = None, - channels: int = 3, - batch: int = 1, - parameterization: ImageParameterization = FFTImage, - init: Optional[torch.Tensor] = None, - decorrelate_init: bool = True, - squash_func: Optional[SquashFunc] = None, - ) -> None: - super().__init__() - self.decorrelate = ToRGB(transform_name="klt") - if init is not None: - assert init.dim() == 3 or init.dim() == 4 - if decorrelate_init: - init = ( - init.refine_names("B", "C", "H", "W") - if init.dim() == 4 - else init.refine_names("C", "H", "W") - ) - init = self.decorrelate(init, inverse=True).rename(None) - if squash_func is None: - squash_func: SquashFunc = lambda x: x.clamp(0, 1) - else: - if squash_func is None: - squash_func: SquashFunc = lambda x: torch.sigmoid(x) - self.squash_func = squash_func - self.parameterization = parameterization( - size=size, channels=channels, batch=batch, init=init - ) - - def forward(self) -> torch.Tensor: - image = self.parameterization() - image = self.decorrelate(image) - image = image.rename(None) # TODO: the world is not yet ready - return CudaImageTensor(self.squash_func(image)) +from copy import deepcopy +from typing import Any, Callable, Dict, List, Optional, Tuple, Union + +import matplotlib.pyplot as plt +import numpy as np +import torch +import torch.nn as nn +import torch.nn.functional as F + +try: + from PIL import Image +except (ImportError, AssertionError): + print("The Pillow/PIL library is required to use Captum's Optim library") + +from captum.optim._param.image.transform import ToRGB +from captum.optim._utils.models import pad_reflective_a4d +from captum.optim._utils.typing import InitSize, SquashFunc + + +class ImageTensor(torch.Tensor): + def __init__(self, data, **kwargs) -> None: + if not isinstance(data, torch.Tensor): + data = torch.as_tensor(data, **kwargs) + self._t = data + + @classmethod + def open(cls, path: str, scale: float = 255.0): + img_np = Image.open(path).convert("RGB") + img_np = np.array(img_np).astype(np.float32) + return cls(img_np.transpose(2, 0, 1) / scale) + + @classmethod + def __torch_function__( + self, + func: Callable, + types: Tuple, + args: Tuple = (), + kwargs: Optional[Dict] = None, + ) -> Any: + if kwargs is None: + kwargs = {} + args_t = [a._t if hasattr(a, "_t") else a for a in args] + return super().__torch_function__(func, types, args_t, **kwargs) + + def __repr__(self) -> str: + return f"ImageTensor(value={self._t})" + + def show(self, scale: float = 255.0) -> None: + if len(self.shape) == 3: + numpy_thing = self.cpu().detach().numpy().transpose(1, 2, 0) * scale + elif len(self.shape) == 4: + numpy_thing = self.cpu().detach().numpy()[0].transpose(1, 2, 0) * scale + plt.imshow(numpy_thing.astype(np.uint8)) + plt.axis("off") + plt.show() + + def export(self, filename: str, scale: float = 255.0) -> None: + colorspace = "RGB" if self.size(1) == 3 else "RGBA" + if len(self.shape) == 3: + numpy_thing = self.cpu().detach().numpy().transpose(1, 2, 0) * scale + elif len(self.shape) == 4: + numpy_thing = self.cpu().detach().numpy()[0].transpose(1, 2, 0) * scale + im = Image.fromarray(numpy_thing.astype("uint8"), colorspace) + im.save(filename) + + def cpu(self) -> "ImageTensor": + return self + + def cuda(self) -> "CudaImageTensor": + return CudaImageTensor(self._t, device="cuda") + + +class CudaImageTensor(object): + def __init__(self, data, **kwargs) -> None: + self._t = torch.as_tensor(data, **kwargs) + + @classmethod + def __torch_function__( + self, + func: Callable, + types: Tuple, + args: Tuple = (), + kwargs: Optional[Dict] = None, + ) -> Any: + if kwargs is None: + kwargs = {} + args_t = [a._t if hasattr(a, "_t") else a for a in args] + return super().__torch_function__(func, types, args_t, **kwargs) + + def __repr__(self) -> str: + return f"CudaImageTensor(value={self._t})" + + @property + def shape(self) -> torch.Size: + return self._t.shape + + @property + def size(self) -> torch.Size: + return self._t.size() + + def show(self) -> None: + self.cpu().show() + + def export(self, filename: str) -> None: + self.cpu().export(filename) + + def cpu(self) -> "ImageTensor": + return ImageTensor(self._t.cpu()) + + def cuda(self) -> "CudaImageTensor": + return self + + +# mean = [0.485, 0.456, 0.406] +# std = [0.229, 0.224, 0.225] + +# normalize = transforms.Normalize(mean=mean, std=std) + +# mean = torch.Tensor(mean)[None, :, None, None] +# std = torch.Tensor(std)[None, :, None, None] + + +# def denormalize(x: torch.Tensor): +# return std * x + mean + + +def logit(p: torch.Tensor, epsilon: float = 1e-6) -> torch.Tensor: + p = torch.clamp(p, min=epsilon, max=1.0 - epsilon) + assert p.min() >= 0 and p.max() < 1 + return torch.log(p / (1 - p)) + + +# def jitter(x: torch.Tensor, pad_width=2, pad_value=0.5): +# _, _, H, W = x.shape +# y = F.pad(x, 4 * (pad_width,), value=pad_value) +# idx, idy = np.random.randint(low=0, high=2 * pad_width, size=(2,)) +# return y[:, :, idx : idx + H, idy : idy + W] + + +# def color_correction(): +# S = np.asarray( +# [[0.26, 0.09, 0.02], [0.27, 0.00, -0.05], [0.27, -0.09, 0.03]] +# ).astype("float32") +# C = S / np.max(np.linalg.norm(S, axis=0)) +# C = torch.Tensor(C) +# return C.transpose(0, 1) + + +# def upsample(): +# upsample = torch.nn.Upsample(scale_factor=1.1, mode="bilinear", +# align_corners=True) + +# def up(x): +# upsample.scale_factor = ( +# 1 + np.random.randn(1)[0] / 50, +# 1 + np.random.randn(1)[0] / 50, +# ) +# return upsample(x) + +# return up + + +class InputParameterization(torch.nn.Module): + def forward(self): + raise NotImplementedError + + +class ImageParameterization(InputParameterization): + def setup_batch( + self, x: torch.Tensor, batch: int = 1, dim: int = 3 + ) -> torch.Tensor: + assert batch > 0 + x = x.unsqueeze(0) if x.dim() == dim and batch == 1 else x + x = ( + torch.stack([x.clone() for b in range(batch)]) + if x.dim() == dim and batch > 1 + else x + ) + return x + + +class FFTImage(ImageParameterization): + """Parameterize an image using inverse real 2D FFT""" + + def __init__( + self, + size: InitSize = None, + channels: int = 3, + batch: int = 1, + init: Optional[torch.Tensor] = None, + ) -> None: + super().__init__() + if init is None: + assert len(size) == 2 + self.size = size + else: + assert init.dim() == 3 or init.dim() == 4 + self.size = ( + (init.size(1), init.size(2)) + if init.dim() == 3 + else (init.size(2), init.size(3)) + ) + self.torch_rfft, self.torch_irfft = self.get_fft_funcs() + + frequencies = FFTImage.rfft2d_freqs(*self.size) + scale = 1.0 / torch.max( + frequencies, + torch.full_like(frequencies, 1.0 / (max(self.size[0], self.size[1]))), + ) + scale = scale * ((self.size[0] * self.size[1]) ** (1 / 2)) + spectrum_scale = scale[None, :, :, None] + self.register_buffer("spectrum_scale", spectrum_scale) + + if init is None: + coeffs_shape = (channels, self.size[0], self.size[1] // 2 + 1, 2) + random_coeffs = torch.randn( + coeffs_shape + ) # names=["C", "H_f", "W_f", "complex"] + fourier_coeffs = random_coeffs / 50 + else: + fourier_coeffs = self.torch_rfft(init) / spectrum_scale + + fourier_coeffs = self.setup_batch(fourier_coeffs, batch, 4) + self.fourier_coeffs = nn.Parameter(fourier_coeffs) + + @staticmethod + def rfft2d_freqs(height: int, width: int) -> torch.Tensor: + """Computes 2D spectrum frequencies.""" + fy = FFTImage.pytorch_fftfreq(height)[:, None] + # on odd input dimensions we need to keep one additional frequency + wadd = 2 if width % 2 == 1 else 1 + fx = FFTImage.pytorch_fftfreq(width)[: width // 2 + wadd] + return torch.sqrt((fx * fx) + (fy * fy)) + + @staticmethod + def pytorch_fftfreq(v: int, d: float = 1.0) -> torch.Tensor: + """PyTorch version of np.fft.fftfreq""" + results = torch.empty(v) + s = (v - 1) // 2 + 1 + results[:s] = torch.arange(0, s) + results[s:] = torch.arange(-(v // 2), 0) + return results * (1.0 / (v * d)) + + def get_fft_funcs(self) -> Tuple[Callable, Callable]: + """Support older versions of PyTorch""" + try: + import torch.fft + + torch_rfft = lambda x: torch.view_as_real(torch.fft.rfftn(x, s=self.size)) # type: ignore # noqa: E731 E501 + + def torch_irfft(x: torch.Tensor) -> torch.Tensor: + if type(x) is not torch.complex64: + x = torch.view_as_complex(x) + return torch.fft.irfftn(x, s=self.size) # type: ignore + + except (ImportError, AssertionError): + import torch + + torch_rfft = lambda x: torch.rfft(x, signal_ndim=2) # noqa: E731 + torch_irfft = lambda x: torch.irfft(x, signal_ndim=2)[ # noqa: E731 + :, :, : self.size[0], : self.size[1] # noqa: E731 + ] # noqa: E731 + return torch_rfft, torch_irfft + + def forward(self) -> torch.Tensor: + h, w = self.size + scaled_spectrum = self.fourier_coeffs * self.spectrum_scale + output = self.torch_irfft(scaled_spectrum) + return output.refine_names("B", "C", "H", "W") + + +class PixelImage(ImageParameterization): + def __init__( + self, + size: InitSize = None, + channels: int = 3, + batch: int = 1, + init: Optional[torch.Tensor] = None, + ) -> None: + super().__init__() + if init is None: + assert size is not None and channels is not None and batch is not None + init = torch.randn([channels, size[0], size[1]]) / 10 + 0.5 + else: + assert init.shape[0] == 3 + init = self.setup_batch(init, batch) + self.image = nn.Parameter(init) + + def forward(self) -> torch.Tensor: + return self.image.refine_names("B", "C", "H", "W") + + +class LaplacianImage(ImageParameterization): + def __init__( + self, + size: InitSize = None, + channels: int = 3, + batch: int = 1, + init: Optional[torch.Tensor] = None, + ) -> None: + super().__init__() + power = 0.1 + + if init is None: + tensor_params, self.scaler = self.setup_input(size, channels, power, init) + + self.tensor_params = torch.nn.ModuleList( + [deepcopy(tensor_params) for b in range(batch)] + ) + else: + init = init.unsqueeze(0) if init.dim() == 3 else init + P = [] + for b in range(init.size(0)): + tensor_params, self.scaler = self.setup_input( + size, channels, power, init[b].unsqueeze(0) + ) + P.append(tensor_params) + self.tensor_params = torch.nn.ModuleList(P) + + def setup_input( + self, + size: InitSize, + channels: int, + power: float = 0.1, + init: Optional[torch.Tensor] = None, + ) -> Tuple[List[torch.Tensor], List[torch.nn.Upsample]]: + tensor_params, scaler = [], [] + scale_list = [1, 2, 4, 8, 16, 32] + for scale in scale_list: + h, w = int(size[0] // scale), int(size[1] // scale) + if init is None: + x = torch.randn([1, channels, h, w]) / 10 + else: + x = F.interpolate(init.clone(), size=(h, w), mode="bilinear") + x = x / 6 # Prevents output from being all white + upsample = torch.nn.Upsample(scale_factor=scale, mode="nearest") + x = x * (scale ** power) / (32 ** power) + x = torch.nn.Parameter(x) + tensor_params.append(x) + scaler.append(upsample) + tensor_params = torch.nn.ParameterList(tensor_params) + return tensor_params, scaler + + def create_tensor(self, params_list: torch.nn.ParameterList) -> torch.Tensor: + A = [] + for xi, upsamplei in zip(params_list, self.scaler): + A.append(upsamplei(xi)) + return torch.sum(torch.cat(A), 0) + 0.5 + + def forward(self) -> torch.Tensor: + A = [] + for params_list in self.tensor_params: + tensor = self.create_tensor(params_list) + A.append(tensor) + return torch.stack(A).refine_names("B", "C", "H", "W") + + +class SharedImage(ImageParameterization): + """ + Share some image parameters across the batch to increase spatial alignment, + by using interpolated lower resolution tensors. + This is sort of like a laplacian pyramid but more general. + + Offsets are similar to phase in Fourier transforms, and can be applied to + any dimension. + + Mordvintsev, et al., "Differentiable Image Parameterizations", Distill, 2018. + https://distill.pub/2018/differentiable-parameterizations/ + """ + + def __init__( + self, + shapes: Union[Tuple[Tuple[int]], Tuple[int]] = None, + parameterization: ImageParameterization = None, + offset: Union[int, Tuple[int], Tuple[Tuple[int]], None] = None, + ) -> None: + super().__init__() + assert shapes is not None + A = [] + shared_shapes = [shapes] if type(shapes[0]) is not tuple else shapes + for shape in shared_shapes: + assert len(shape) >= 2 and len(shape) <= 4 + shape = ([1] * (4 - len(shape))) + list(shape) + batch, channels, height, width = shape + A.append(torch.nn.Parameter(torch.randn([batch, channels, height, width]))) + self.shared_init = torch.nn.ParameterList(A) + self.parameterization = parameterization + self.offset = self.get_offset(offset, len(A)) if offset is not None else None + + def get_offset(self, offset: Union[int, Tuple[int]], n: int) -> List[List[int]]: + if type(offset) is tuple or type(offset) is list: + if type(offset[0]) is tuple or type(offset[0]) is list: + assert len(offset) == n and all(len(t) == 4 for t in offset) + else: + assert len(offset) >= 1 and len(offset) <= 4 + offset = [([0] * (4 - len(offset))) + list(offset)] * n + else: + offset = [[offset] * 4] * n + offset = [list(v) for v in offset] + assert all([all([type(o) is int for o in v]) for v in offset]) + return offset + + def apply_offset(self, x_list: List[torch.Tensor]) -> List[torch.Tensor]: + A = [] + for x, offset in zip(x_list, self.offset): + assert x.dim() == 4 + size = list(x.size()) + + offset_pad = ( + [abs(offset[0])] * 2 + + [abs(offset[1])] * 2 + + [abs(offset[2])] * 2 + + [abs(offset[3])] * 2 + ) + offset_pad.reverse() + + x = pad_reflective_a4d(x, offset_pad) + + for o, s in zip(offset, range(x.dim())): + x = torch.roll(x, shifts=o, dims=s) + + x = x[: size[0], : size[1], : size[2], : size[3]] + A.append(x) + return A + + def interpolate_tensor( + self, x: torch.Tensor, batch: int, channels: int, height: int, width: int + ) -> torch.Tensor: + """ + Linear interpolation for 4D, 5D, and 6D tensors. + If the batch dimension needs to be resized, + we move it's location temporarily for F.interpolate. + """ + + if x.size(1) == channels: + mode = "bilinear" + size = (height, width) + else: + mode = "trilinear" + x = x.unsqueeze(0) + size = (channels, height, width) + x = F.interpolate(x, size=size, mode=mode) + x = x.squeeze(0) if len(size) == 3 else x + if x.size(0) != batch: + x = x.permute(1, 0, 2, 3) + x = F.interpolate( + x.unsqueeze(0), + size=(batch, x.size(2), x.size(3)), + mode="trilinear", + ).squeeze(0) + x = x.permute(1, 0, 2, 3) + return x + + def forward(self) -> torch.Tensor: + image = self.parameterization() + x = [ + self.interpolate_tensor( + shared_tensor, + image.size(0), + image.size(1), + image.size(2), + image.size(3), + ) + for shared_tensor in self.shared_init + ] + if self.offset is not None: + x = self.apply_offset(x) + return (image + sum(x)).refine_names("B", "C", "H", "W") + + +class NaturalImage(ImageParameterization): + r"""Outputs an optimizable input image. + + By convention, single images are CHW and float32s in [0,1]. + The underlying parameterization is decorrelated via a ToRGB transform. + When used with the (default) FFT parameterization, this results in a fully + uncorrelated image parameterization. :-) + + If a model requires a normalization step, such as normalizing imagenet RGB values, + or rescaling to [0,255], it can perform those steps with the provided transforms or + inside its computation. + For example, our GoogleNet factory function has a `transform_input=True` argument. + """ + + def __init__( + self, + size: InitSize = None, + channels: int = 3, + batch: int = 1, + parameterization: ImageParameterization = FFTImage, + init: Optional[torch.Tensor] = None, + decorrelate_init: bool = True, + squash_func: Optional[SquashFunc] = None, + ) -> None: + super().__init__() + self.decorrelate = ToRGB(transform_name="klt") + if init is not None: + assert init.dim() == 3 or init.dim() == 4 + if decorrelate_init: + init = ( + init.refine_names("B", "C", "H", "W") + if init.dim() == 4 + else init.refine_names("C", "H", "W") + ) + init = self.decorrelate(init, inverse=True).rename(None) + if squash_func is None: + squash_func: SquashFunc = lambda x: x.clamp(0, 1) + else: + if squash_func is None: + squash_func: SquashFunc = lambda x: torch.sigmoid(x) + self.squash_func = squash_func + self.parameterization = parameterization( + size=size, channels=channels, batch=batch, init=init + ) + + def forward(self) -> torch.Tensor: + image = self.parameterization() + image = self.decorrelate(image) + image = image.rename(None) # TODO: the world is not yet ready + return CudaImageTensor(self.squash_func(image)) diff --git a/captum/optim/_utils/models.py b/captum/optim/_utils/models.py index 1eee8a24c6..4920253d59 100644 --- a/captum/optim/_utils/models.py +++ b/captum/optim/_utils/models.py @@ -157,6 +157,40 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: ) +def pad_reflective_a4d(x: torch.Tensor, padding: List[int]) -> torch.Tensor: + """ + Reflective padding for all 4 dimensions of an NCHW tensor + """ + + assert x.dim() == 4 + assert len(padding) == 8 + + # Pad width + if padding[0] != 0: + x = torch.cat([x, x.flip([3])[..., 0 : padding[0]]], dim=3) + if padding[1] != 0: + x = torch.cat([x.flip([3])[..., -padding[1] :], x], dim=3) + + # Pad height + if padding[2] != 0: + x = torch.cat([x, x.flip([2])[..., 0 : padding[2], :]], dim=2) + if padding[3] != 0: + x = torch.cat([x.flip([2])[..., -padding[3] :, :], x], dim=2) + + # Pad channels + if padding[4] != 0: + x = torch.cat([x, x.flip([1])[:, 0 : padding[4]]], dim=1) + if padding[5] != 0: + x = torch.cat([x.flip([1])[:, -padding[5] :], x], dim=1) + + # Pad batch + if padding[6] != 0: + x = torch.cat([x, x.flip([0])[0 : padding[6]]], dim=0) + if padding[7] != 0: + x = torch.cat([x.flip([0])[-padding[7] :], x], dim=0) + return x + + def collect_activations( model, targets: Union[nn.Module, List[nn.Module]], diff --git a/tests/optim/param/test_images.py b/tests/optim/param/test_images.py index a4989e8809..c8b9984aac 100644 --- a/tests/optim/param/test_images.py +++ b/tests/optim/param/test_images.py @@ -1,11 +1,12 @@ #!/usr/bin/env python3 import unittest +from typing import List import numpy as np import torch -import torch.nn.functional as F from captum.optim._param.image import images +from captum.optim._utils.models import pad_reflective_a4d from tests.helpers.basic import ( BaseTest, assertArraysAlmostEqual, @@ -280,7 +281,7 @@ def test_sharedimage_get_offset_exact(self) -> None: self.assertEqual(len(offset), 3) self.assertEqual(offset, [[int(o) for o in v] for v in offset_vals]) - def test_sharedimage_apply_offset_single_set_four_numbers(self) -> None: + def test_sharedimage_get_offset_single_set_four_numbers(self) -> None: if torch.__version__ == "1.2.0": raise unittest.SkipTest( "Skipping SharedImage test due to insufficient Torch version." @@ -297,7 +298,7 @@ def test_sharedimage_apply_offset_single_set_four_numbers(self) -> None: self.assertEqual(len(offset), 3) self.assertEqual(offset, [list(offset_vals)] * 3) - def test_sharedimage_apply_offset_single_set_three_numbers(self) -> None: + def test_sharedimage_get_offset_single_set_three_numbers(self) -> None: if torch.__version__ == "1.2.0": raise unittest.SkipTest( "Skipping SharedImage test due to insufficient Torch version." @@ -314,7 +315,7 @@ def test_sharedimage_apply_offset_single_set_three_numbers(self) -> None: self.assertEqual(len(offset), 3) self.assertEqual(offset, [[0] + list(offset_vals)] * 3) - def test_sharedimage_apply_offset_single_set_two_numbers(self) -> None: + def test_sharedimage_get_offset_single_set_two_numbers(self) -> None: if torch.__version__ == "1.2.0": raise unittest.SkipTest( "Skipping SharedImage test due to insufficient Torch version." @@ -331,6 +332,29 @@ def test_sharedimage_apply_offset_single_set_two_numbers(self) -> None: self.assertEqual(len(offset), 3) self.assertEqual(offset, [[0, 0] + list(offset_vals)] * 3) + def apply_offset_compare( + self, x_list: List[torch.Tensor], offset_list: List[List[int]] + ) -> List[torch.Tensor]: + A = [] + for x, offset in zip(x_list, offset_list): + size = list(x.size()) + offset_pad = ( + [abs(offset[0])] * 2 + + [abs(offset[1])] * 2 + + [abs(offset[2])] * 2 + + [abs(offset[3])] * 2 + ) + offset_pad.reverse() + + x = pad_reflective_a4d(x, offset_pad) + + for o, s in zip(offset, range(x.dim())): + x = torch.roll(x, shifts=o, dims=s) + + x = x[: size[0], : size[1], : size[2], : size[3]] + A.append(x) + return A + def test_apply_offset(self): if torch.__version__ == "1.2.0": raise unittest.SkipTest( @@ -345,15 +369,13 @@ def test_apply_offset(self): ) test_x_list = [torch.ones(*size) for x in range(size[0])] - output_A = image_param.apply_offset(test_x_list, size) + output_A = image_param.apply_offset(test_x_list) x_list = [torch.ones(*size) for x in range(size[0])] + self.assertEqual(image_param.offset, [list(offset_vals)]) + offset_list = image_param.offset - expected_A = [] - for x, offset in zip(x_list, offset_list): - x = F.pad(x, offset, "reflect") - x = x[: size[0], : size[1], : size[2], : size[3]] - expected_A.append(x) + expected_A = self.apply_offset_compare(x_list, offset_list) for t_expected, t_output in zip(expected_A, output_A): assertTensorAlmostEqual(self, t_expected, t_output) @@ -375,7 +397,7 @@ def test_interpolate_tensor(self) -> None: test_tensor = torch.ones(6, 4, 128, 128) output_tensor = image_param.interpolate_tensor( - test_tensor, size, batch, channels + test_tensor, batch, channels, size[0], size[1] ) self.assertEqual(output_tensor.dim(), 4) @@ -400,8 +422,11 @@ def test_sharedimage_single_shape_hw_forward(self) -> None: ) test_tensor = image_param.forward() - self.assertEqual(image_param.shared_init.dim(), 4) - self.assertEqual(image_param.shared_init.shape, (1, 1, 128 // 2, 128 // 2)) + self.assertIsNone(image_param.offset) + self.assertEqual(image_param.shared_init[0].dim(), 4) + self.assertEqual( + list(image_param.shared_init[0].shape), [1, 1] + list(shared_shapes) + ) self.assertEqual(test_tensor.dim(), 4) self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) @@ -424,8 +449,11 @@ def test_sharedimage_single_shape_chw_forward(self) -> None: ) test_tensor = image_param.forward() - self.assertEqual(image_param.shared_init.dim(), 4) - self.assertEqual(image_param.shared_init.shape, (1, 1, 128 // 2, 128 // 2)) + self.assertIsNone(image_param.offset) + self.assertEqual(image_param.shared_init[0].dim(), 4) + self.assertEqual( + list(image_param.shared_init[0].shape), [1] + list(shared_shapes) + ) self.assertEqual(test_tensor.dim(), 4) self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) @@ -448,8 +476,9 @@ def test_sharedimage_single_shape_bchw_forward(self) -> None: ) test_tensor = image_param.forward() - self.assertEqual(image_param.shared_init.dim(), 4) - self.assertEqual(image_param.shared_init.shape, (1, 1, 128 // 2, 128 // 2)) + self.assertIsNone(image_param.offset) + self.assertEqual(image_param.shared_init[0].dim(), 4) + self.assertEqual(list(image_param.shared_init[0].shape), list(shared_shapes)) self.assertEqual(test_tensor.dim(), 4) self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) @@ -479,8 +508,12 @@ def test_sharedimage_multiple_shapes_forward(self) -> None: ) test_tensor = image_param.forward() - self.assertEqual(image_param.shared_init.dim(), 4) - self.assertEqual(image_param.shared_init.shape, (1, 1, 128 // 2, 128 // 2)) + self.assertIsNone(image_param.offset) + for i in range(len(shared_shapes)): + self.assertEqual(image_param.shared_init[i].dim(), 4) + self.assertEqual( + list(image_param.shared_init[i].shape), list(shared_shapes[i]) + ) self.assertEqual(test_tensor.dim(), 4) self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) @@ -510,8 +543,13 @@ def test_sharedimage_multiple_shapes_diff_len_forward(self) -> None: ) test_tensor = image_param.forward() - self.assertEqual(image_param.shared_init.dim(), 4) - self.assertEqual(image_param.shared_init.shape, (1, 1, 128 // 2, 128 // 2)) + self.assertIsNone(image_param.offset) + for i in range(len(shared_shapes)): + self.assertEqual(image_param.shared_init[i].dim(), 4) + s_shape = list(shared_shapes[i]) + s_shape = ([1] * (4 - len(s_shape))) + list(s_shape) + self.assertEqual(list(image_param.shared_init[i].shape), s_shape) + self.assertEqual(test_tensor.dim(), 4) self.assertEqual(test_tensor.size(0), batch) self.assertEqual(test_tensor.size(1), channels) diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index bfc7339dfa..ce167520c1 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -9,6 +9,20 @@ from tests.helpers.basic import BaseTest, assertTensorAlmostEqual +class TestPadReflectiveA4D(BaseTest): + def test_pad_reflective_a4d(self) -> None: + x = torch.ones(1, 3, 4, 4) + padding = [2] * 8 + x_out = model_utils.pad_reflective_a4d(x, padding) + self.assertEqual(list(x_out.shape), [4, 7, 8, 8]) + + def test_pad_reflective_a4d_zeros(self) -> None: + x = torch.ones(1, 3, 4, 4) + padding = [0] * 8 + x_out = model_utils.pad_reflective_a4d(x, padding) + self.assertEqual(x_out.shape, x.shape) + + class TestConv2dSame(BaseTest): def test_conv2d_same(self) -> None: x = torch.ones(64, 32, 100, 20) diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py index d921364a69..4cc9f5211b 100644 --- a/tests/optim/utils/test_reducer.py +++ b/tests/optim/utils/test_reducer.py @@ -9,7 +9,7 @@ from tests.helpers.basic import BaseTest -class TestReductionAlgorithm(object): +class FakeReductionAlgorithm(object): """ Fake reduction algorithm for testing """ @@ -58,7 +58,7 @@ def test_channelreducer_pytorch_pca(self) -> None: def test_channelreducer_pytorch_custom_alg(self) -> None: test_input = torch.randn(1, 32, 224, 224).abs() - reduction_alg = TestReductionAlgorithm + reduction_alg = FakeReductionAlgorithm c_reducer = reducer.ChannelReducer( n_components=3, reduction_alg=reduction_alg, max_iter=100 ) @@ -66,7 +66,7 @@ def test_channelreducer_pytorch_custom_alg(self) -> None: self.assertEquals(test_output.size(1), 3) def test_channelreducer_pytorch_custom_alg_components(self) -> None: - reduction_alg = TestReductionAlgorithm + reduction_alg = FakeReductionAlgorithm c_reducer = reducer.ChannelReducer( n_components=3, reduction_alg=reduction_alg, max_iter=100 ) From 1f18010925d9e084bad3c424b6896989644a228b Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 20 Dec 2020 11:05:56 -0700 Subject: [PATCH 47/76] Fix neuron objectives * Fix NeuronDirection * Fix ActivationWeights * Fix NeuronActivation --- captum/optim/_core/loss.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index c05f1c53d8..61df4c3448 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -75,7 +75,7 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations.size(2), activations.size(3), self.x, self.y ) - return activations[:, self.channel_index, _x, _y] + return activations[:, self.channel_index, _x : _x + 1, _y : _y + 1] class DeepDream(Loss): @@ -269,16 +269,16 @@ def __init__( self, target: nn.Module, vec: torch.Tensor, - channel_index: int, x: Optional[int] = None, y: Optional[int] = None, + channel_index: Optional[int] = None, ) -> None: super(Loss, self).__init__() self.target = target self.direction = vec.reshape((1, -1, 1, 1)) - self.channel_index = channel_index self.x = x self.y = y + self.channel_index = channel_index def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: activations = targets_to_values[self.target] @@ -288,8 +288,10 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: _x, _y = get_neuron_pos( activations.size(2), activations.size(3), self.x, self.y ) - activations = activations[:, self.channel_index, _x, _y] - return torch.cosine_similarity(self.direction, activations[None, None, None]) + activations = activations[:, :, _x : _x + 1, _y : _y + 1] + if self.channel_index is not None: + activations = activations[:, self.channel_index, ...][:, None, ...] + return torch.cosine_similarity(self.direction, activations) class TensorDirection(Loss): @@ -359,7 +361,9 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: _x, _y = get_neuron_pos( activations.size(2), activations.size(3), self.x, self.y ) - activations = activations[..., _x, _y].squeeze() * self.weights + activations = ( + activations[..., _x : _x + 1, _y : _y + 1].squeeze() * self.weights + ) else: activations = activations[ ..., self.y : self.y + self.wy, self.x : self.x + self.wx From 4ae005e5028d702113ebd2591d76fb4213a24d0a Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Sun, 20 Dec 2020 18:52:25 -0700 Subject: [PATCH 48/76] DirectionNeuron -> NeuronDirection --- captum/optim/_core/loss.py | 2 +- .../optimviz/WeightVisualization_OptimViz.ipynb | 14 +++++++------- 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 61df4c3448..281e50fe43 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -258,7 +258,7 @@ def __call__(self, targets_to_values: ModuleOutputMapping) -> torch.Tensor: return torch.cosine_similarity(self.direction, activations) -class DirectionNeuron(Loss): +class NeuronDirection(Loss): """ Visualize a single (x, y) position for a direction vector. Carter, et al., "Activation Atlas", Distill, 2019. diff --git a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb index b66ddf008b..dee2bdb285 100644 --- a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb +++ b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb @@ -875,7 +875,7 @@ "def vis_multi(model, target, channel, vec=None) -> None:\r\n", " image = optimviz.images.NaturalImage((60,60)).to(device)\r\n", " if vec is not None:\r\n", - " loss_fn = optimviz.loss.DirectionNeuron(target, vec, channel)\r\n", + " loss_fn = optimviz.loss.NeuronDirection(target, vec, channel)\r\n", " else:\r\n", " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", " transforms = torch.nn.Sequential(optimviz.transform.RandomSpatialJitter(1)) \r\n", @@ -883,7 +883,7 @@ " history = obj.optimize(optimviz.objectives.n_steps(128, False))\r\n", " return image()._t" ], - "execution_count": 4, + "execution_count": null, "outputs": [] }, { @@ -908,7 +908,7 @@ "W_3a_3b = optimviz.circuits.get_expanded_weights(model, model.mixed3a, model.mixed3b)\r\n", "W_3a_3b = W_3a_3b.permute(3, 0, 1, 2) # Move output channels to front for simplicity" ], - "execution_count": 5, + "execution_count": null, "outputs": [] }, { @@ -995,7 +995,7 @@ "visualize_activations(model, model.mixed3a, 147)\r\n", "visualize_activations(model, model.mixed3b, 379)" ], - "execution_count": 9, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -1151,7 +1151,7 @@ "source": [ "visualize_activations(model, model.mixed3b, 320)" ], - "execution_count": 10, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -1279,7 +1279,7 @@ "W_p_3a = optimviz.circuits.get_expanded_weights(model, model.pool1, model.mixed3a)\r\n", "W_p_3a = W_p_3a.permute(3, 0, 1, 2)" ], - "execution_count": 11, + "execution_count": null, "outputs": [] }, { @@ -1320,7 +1320,7 @@ "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", "show(grid_img)" ], - "execution_count": 12, + "execution_count": null, "outputs": [ { "output_type": "display_data", From 995eb36af714493f4ce02fc315040fa3391fb896 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 21 Dec 2020 13:52:47 -0700 Subject: [PATCH 49/76] Fix 4 dimensional reflection padding --- captum/optim/_utils/models.py | 74 +++++++++++++++++++-------- tests/optim/utils/test_model_utils.py | 31 +++++++++-- 2 files changed, 80 insertions(+), 25 deletions(-) diff --git a/captum/optim/_utils/models.py b/captum/optim/_utils/models.py index 4920253d59..d3c9650c67 100644 --- a/captum/optim/_utils/models.py +++ b/captum/optim/_utils/models.py @@ -165,29 +165,63 @@ def pad_reflective_a4d(x: torch.Tensor, padding: List[int]) -> torch.Tensor: assert x.dim() == 4 assert len(padding) == 8 - # Pad width - if padding[0] != 0: - x = torch.cat([x, x.flip([3])[..., 0 : padding[0]]], dim=3) - if padding[1] != 0: - x = torch.cat([x.flip([3])[..., -padding[1] :], x], dim=3) - - # Pad height - if padding[2] != 0: - x = torch.cat([x, x.flip([2])[..., 0 : padding[2], :]], dim=2) - if padding[3] != 0: - x = torch.cat([x.flip([2])[..., -padding[3] :, :], x], dim=2) + if x.size(0) == 2: + assert sum(padding[6:]) == 0 + if x.size(1) == 2: + assert sum(padding[4:6]) == 0 + + # Pad batch + if x.size(0) > 2: + if padding[6] != 0: + x = torch.cat([x, x.flip([0])[1 : (padding[6] + 1)]], dim=0) + if padding[7] != 0: + x = torch.cat([x.flip([0])[-(padding[7] + 1) : -1], x], dim=0) + + elif x.size(0) == 1: + P = [] + if padding[6] != 0: + P.append( + torch.cat( + [x if (i + 1) % 2 == 0 else x.flip([0]) for i in range(padding[6])] + ) + ) + P.append(x) + if padding[7] != 0: + P.append( + torch.cat( + [x if (i + 1) % 2 == 0 else x.flip([0]) for i in range(padding[7])] + ) + ) + x = torch.cat(P) # Pad channels - if padding[4] != 0: - x = torch.cat([x, x.flip([1])[:, 0 : padding[4]]], dim=1) - if padding[5] != 0: - x = torch.cat([x.flip([1])[:, -padding[5] :], x], dim=1) + if x.size(1) > 2: + if padding[4] != 0: + x = torch.cat([x, x.flip([1])[:, 1 : (padding[4] + 1)]], dim=1) + if padding[5] != 0: + x = torch.cat([x.flip([1])[:, -(padding[5] + 1) : -1], x], dim=1) + + elif x.size(1) == 1: + P = [] + if padding[4] != 0: + P.append( + torch.cat( + [x if (i + 1) % 2 == 0 else x.flip([1]) for i in range(padding[4])], + dim=1, + ) + ) + P.append(x) + if padding[5] != 0: + P.append( + torch.cat( + [x if (i + 1) % 2 == 0 else x.flip([1]) for i in range(padding[5])], + dim=1, + ) + ) + x = torch.cat(P, dim=1) - # Pad batch - if padding[6] != 0: - x = torch.cat([x, x.flip([0])[0 : padding[6]]], dim=0) - if padding[7] != 0: - x = torch.cat([x.flip([0])[-padding[7] :], x], dim=0) + # Pad height and width + x = torch.nn.functional.pad(x, padding[:4], "reflect") return x diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index ce167520c1..e5f9702794 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -1,6 +1,7 @@ #!/usr/bin/env python3 import unittest +import numpy as np import torch import torch.nn.functional as F @@ -10,17 +11,37 @@ class TestPadReflectiveA4D(BaseTest): - def test_pad_reflective_a4d(self) -> None: - x = torch.ones(1, 3, 4, 4) + def test_pad_reflective_a4d_b1_c1(self) -> None: + b = 1 + c = 1 + x = torch.arange(0, b * c * 4 * 4).view(b, c, 4, 4).float() padding = [2] * 8 + x_out = model_utils.pad_reflective_a4d(x, padding) - self.assertEqual(list(x_out.shape), [4, 7, 8, 8]) + x_out_np = torch.as_tensor(np.pad(x.numpy(), (2), mode="reflect")) + + assertTensorAlmostEqual(self, x_out, x_out_np) + + def test_pad_reflective_a4d_b3_c3(self) -> None: + b = 3 + c = 3 + x = torch.arange(0, b * c * 4 * 4).view(b, c, 4, 4).float() + padding = [2] * 8 + + x_out = model_utils.pad_reflective_a4d(x, padding) + x_out_np = torch.as_tensor(np.pad(x.numpy(), (2), mode="reflect")) + + assertTensorAlmostEqual(self, x_out, x_out_np) def test_pad_reflective_a4d_zeros(self) -> None: - x = torch.ones(1, 3, 4, 4) + b = 1 + c = 3 + x = torch.arange(0, b * c * 4 * 4).view(b, c, 4, 4).float() padding = [0] * 8 + x_out = model_utils.pad_reflective_a4d(x, padding) - self.assertEqual(x_out.shape, x.shape) + + assertTensorAlmostEqual(self, x_out, x) class TestConv2dSame(BaseTest): From 50a726fa9a6740632d3d352f1392cf1e1034ffc3 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 21 Dec 2020 19:26:13 -0700 Subject: [PATCH 50/76] Implement first batch of changes based on feedback --- captum/optim/_core/output_hook.py | 21 +++++ captum/optim/_param/image/transform.py | 25 +++++- captum/optim/_utils/circuits.py | 90 ++++++++++--------- captum/optim/_utils/models.py | 31 ++----- captum/optim/_utils/typing.py | 1 + tests/optim/core/__init__.py | 1 + tests/optim/core/test_output_hook.py | 28 ++++++ tests/optim/param/test_transforms.py | 16 ++++ tests/optim/utils/test_model_utils.py | 17 ---- .../WeightVisualization_OptimViz.ipynb | 55 ++++++------ 10 files changed, 170 insertions(+), 115 deletions(-) create mode 100644 tests/optim/core/__init__.py create mode 100644 tests/optim/core/test_output_hook.py diff --git a/captum/optim/_core/output_hook.py b/captum/optim/_core/output_hook.py index 8bd365075a..c67d98d099 100755 --- a/captum/optim/_core/output_hook.py +++ b/captum/optim/_core/output_hook.py @@ -4,6 +4,7 @@ import torch.nn as nn # from clarity.pytorch import ModuleOutputMapping +from captum.optim._utils.typing import ModelInputType class AbortForwardException(Exception): @@ -88,3 +89,23 @@ def remove_hooks(self) -> None: def __del__(self) -> None: # print(f"DEL HOOKS!: {list(self.outputs.keys())}") self.remove_hooks() + + +class ActivationFetcher: + """ + Simple module for collecting activations from model targets. + """ + + def __init__(self, model, targets: Union[nn.Module, List[nn.Module]]) -> None: + super(ActivationCatcher, self).__init__() + self.model = model + self.layers = ModuleOutputsHook(targets) + + def __call__(self, input_t: ModelInputType) -> ModuleOutputMapping: + try: + with suppress(AbortForwardException): + self.model(input_t) + activations = self.layers.consume_outputs() + finally: + self.layers.remove_hooks() + return activations diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index ebfd4140df..abab122d25 100644 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -1,6 +1,6 @@ import math import numbers -from typing import Optional, Sequence, Union +from typing import List, Optional, Sequence, Union import torch import torch.nn as nn @@ -146,6 +146,29 @@ def forward(self, input: torch.Tensor) -> torch.Tensor: return input[..., sh : sh + h_crop, sw : sw + w_crop] +def center_crop_shape(input: torch.Tensor, output_size: List[int]) -> torch.Tensor: + """ + Crop NCHW & CHW outputs by specifying the desired output shape. + """ + + assert input.dim() == 4 or input.dim() == 3 + output_size = [output_size] if not hasattr(output_size, "__iter__") else output_size + assert len(output_size) == 1 or len(output_size) == 2 + output_size = output_size * 2 if len(output_size) == 1 else output_size + + if input.dim() == 4: + h, w = input.size(2), input.size(3) + if input.dim() == 3: + h, w = input.size(1), input.size(2) + + h_crop = h - int(round((h - output_size[0]) / 2.0)) + w_crop = w - int(round((w - output_size[1]) / 2.0)) + + return input[ + ..., h_crop - output_size[0] : h_crop, w_crop - output_size[1] : w_crop + ] + + def rand_select(transform_values: TransformValList) -> TransformVal: """ Randomly return a value from the provided tuple or list diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index e2126bf262..2735da05ed 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -1,41 +1,49 @@ -import torch -import torch.nn as nn - -from captum.optim._utils.models import collect_activations - - -def get_expanded_weights( - model, - target1: nn.Module, - target2: nn.Module, - model_input: torch.Tensor = torch.zeros(1, 3, 224, 224), -) -> torch.Tensor: - """ - Extract meaningful weight interactions from between neurons which aren’t - literally adjacent in a neural network, or where the weights aren’t directly - represented in a single weight tensor. - - Schubert, et al., "Visualizing Weights", Distill, 2020. - See: https://distill.pub/2020/circuits/visualizing-weights/ - """ - - activations = collect_activations(model, [target1, target2], model_input) - activ1 = activations[target1] - activ2 = activations[target2] - - if activ2.dim() == 4: - t_offset_h, t_offset_w = (activ2.size(2) - 1) // 2, (activ2.size(3) - 1) // 2 - t_center = activ2[:, :, t_offset_h, t_offset_w] - elif activ2.dim() == 2: - t_center = activ2 - - A = [] - for i in range(activ2.size(1)): - x = torch.autograd.grad( - outputs=t_center[:, i], - inputs=[activ1], - grad_outputs=torch.ones_like(t_center[:, i]), - retain_graph=True, - )[0] - A.append(x) - return torch.stack(A, -1)[0] +from typing import Optional + +import torch +import torch.nn as nn + +from captum.optim._param.image.transform import center_crop_shape +from captum.optim._utils.models import collect_activations +from captum.optim._utils.typing import TransformSize + + +def get_expanded_weights( + model, + target1: nn.Module, + target2: nn.Module, + crop_shape: Optional[TransformSize] = None, + model_input: torch.Tensor = torch.zeros(1, 3, 224, 224), +) -> torch.Tensor: + """ + Extract meaningful weight interactions from between neurons which aren’t + literally adjacent in a neural network, or where the weights aren’t directly + represented in a single weight tensor. + Schubert, et al., "Visualizing Weights", Distill, 2020. + See: https://distill.pub/2020/circuits/visualizing-weights/ + """ + + activations = collect_activations(model, [target1, target2], model_input) + activ1 = activations[target1] + activ2 = activations[target2] + + if activ2.dim() == 4: + t_offset_h, t_offset_w = (activ2.size(2) - 1) // 2, (activ2.size(3) - 1) // 2 + t_center = activ2[:, :, t_offset_h, t_offset_w] + elif activ2.dim() == 2: + t_center = activ2 + + A = [] + for i in range(activ2.size(1)): + x = torch.autograd.grad( + outputs=t_center[:, i], + inputs=[activ1], + grad_outputs=torch.ones_like(t_center[:, i]), + retain_graph=True, + )[0] + A.append(x.squeeze(0)) + exapnded_weights = torch.stack(A, 0) + + if crop_shape is not None: + exapnded_weights = center_crop_shape(exapnded_weights, crop_shape) + return exapnded_weights diff --git a/captum/optim/_utils/models.py b/captum/optim/_utils/models.py index d3c9650c67..82437fbb33 100644 --- a/captum/optim/_utils/models.py +++ b/captum/optim/_utils/models.py @@ -6,8 +6,8 @@ import torch.nn as nn import torch.nn.functional as F -from captum.optim._core.output_hook import AbortForwardException, ModuleOutputsHook -from captum.optim._utils.typing import ModuleOutputMapping +from captum.optim._core.output_hook import ActivationFetcher +from captum.optim._utils.typing import ModelInputType, ModuleOutputMapping def get_model_layers(model) -> List[str]: @@ -228,33 +228,12 @@ def pad_reflective_a4d(x: torch.Tensor, padding: List[int]) -> torch.Tensor: def collect_activations( model, targets: Union[nn.Module, List[nn.Module]], - model_input: torch.Tensor = torch.zeros(1, 3, 224, 224), + model_input: ModelInputType = torch.zeros(1, 3, 224, 224), ) -> ModuleOutputMapping: """ Collect target activations for a model. """ - catch_activ = ActivationCatcher(targets) - activ_out = catch_activ(model, model_input) + catch_activ = ActivationCatcher(model, targets) + activ_out = catch_activ(model_input) return activ_out - - -class ActivationCatcher(object): - """ - Simple module for collecting activations from model targets. - """ - - def __init__(self, targets: Union[nn.Module, List[nn.Module]]) -> None: - super(ActivationCatcher, self).__init__() - self.layers = ModuleOutputsHook(targets) - - def __call__(self, model, input_t: torch.Tensor) -> ModuleOutputMapping: - try: - with suppress(AbortForwardException): - model(input_t) - activations = self.layers.consume_outputs() - self.layers.remove_hooks() - return activations - except (Exception, BaseException) as e: - self.layers.remove_hooks() - raise e diff --git a/captum/optim/_utils/typing.py b/captum/optim/_utils/typing.py index d577766db1..3b1fa2e390 100755 --- a/captum/optim/_utils/typing.py +++ b/captum/optim/_utils/typing.py @@ -38,3 +38,4 @@ def cleanup(self): TransformValList = Union[Sequence[int], Sequence[float], Tensor] TransformVal = Union[int, float, Tensor] TransformSize = Union[List[int], Tuple[int], int] +ModelInputType = Union[Tuple[Tensor], Tensor] diff --git a/tests/optim/core/__init__.py b/tests/optim/core/__init__.py new file mode 100644 index 0000000000..f953efcd31 --- /dev/null +++ b/tests/optim/core/__init__.py @@ -0,0 +1 @@ +# Core tests diff --git a/tests/optim/core/test_output_hook.py b/tests/optim/core/test_output_hook.py new file mode 100644 index 0000000000..e4c568c27e --- /dev/null +++ b/tests/optim/core/test_output_hook.py @@ -0,0 +1,28 @@ +#!/usr/bin/env python3 +import unittest + +import torch + +import captum.optim._core.output_hook as output_hook +from tests.helpers.basic import BaseTest + + +class TestActivationFetcher(BaseTest): + def test_activation_fetcher(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping ActivationFetcher test due to insufficient Torch version." + ) + model = googlenet(pretrained=True) + try: + catch_activ = output_hook.ActivationFetcher(model, targets=[model.mixed4d]) + activ_out = catch_activ(torch.zeros(1, 3, 224, 224)) + self.assertIsInstance(activ_out, dict) + test = True + except Exception: + test = False + self.assertTrue(test) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index 8b52edf6d9..b7186e8b4d 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -168,6 +168,22 @@ def test_center_crop_two_numbers(self) -> None: assertArraysAlmostEqual(cropped_tensor.numpy(), cropped_array, 0) +class TestCenterCropShape(BaseTest): + def test_center_crop_shape_tuple(self) -> None: + x = torch.ones(32, 16, 28, 28) + + x_out = transform.center_crop_shape(x, (5, 5)) + + self.AssertEqual(list(x_out.shape), [32, 16, 5, 5]) + + def test_center_crop_shape_int(self) -> None: + x = torch.ones(32, 16, 28, 28) + + x_out = transform.center_crop_shape(x, 5) + + self.AssertEqual(list(x_out.shape), [32, 16, 5, 5]) + + class TestBlendAlpha(BaseTest): def test_blend_alpha(self) -> None: rgb_tensor = torch.ones(3, 3, 3) diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index e5f9702794..83e63d9559 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -334,23 +334,6 @@ def test_get_layers_torchvision_alexnet(self) -> None: self.assertEqual(collected_layers, expected_list) -class TestActivationCatcher(BaseTest): - def test_activation_catcher(self) -> None: - if torch.__version__ == "1.2.0": - raise unittest.SkipTest( - "Skipping ActivationCatcher test due to insufficient Torch version." - ) - model = googlenet(pretrained=True) - try: - catch_activ = model_utils.ActivationCatcher(targets=[model.mixed4d]) - activ_out = catch_activ(model, torch.zeros(1, 3, 224, 224)) - self.assertIsInstance(activ_out, dict) - test = True - except Exception: - test = False - self.assertTrue(test) - - class TestCollectActivations(BaseTest): def test_collect_activations(self) -> None: if torch.__version__ == "1.2.0": diff --git a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb index dee2bdb285..f4fd67ce8e 100644 --- a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb +++ b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb @@ -875,7 +875,7 @@ "def vis_multi(model, target, channel, vec=None) -> None:\r\n", " image = optimviz.images.NaturalImage((60,60)).to(device)\r\n", " if vec is not None:\r\n", - " loss_fn = optimviz.loss.NeuronDirection(target, vec, channel)\r\n", + " loss_fn = optimviz.loss.Direction(target, vec)\r\n", " else:\r\n", " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", " transforms = torch.nn.Sequential(optimviz.transform.RandomSpatialJitter(1)) \r\n", @@ -883,7 +883,7 @@ " history = obj.optimize(optimviz.objectives.n_steps(128, False))\r\n", " return image()._t" ], - "execution_count": null, + "execution_count": 75, "outputs": [] }, { @@ -896,7 +896,7 @@ "\r\n", "We can extract expanded weights with Captum.optim's get_expanded_weights function.\r\n", "\r\n", - "Below we extract the expanded weights from between the mixed3a and mixed3b layers. The output tensor is in the form of / has a shape of: `[input channels, y, x, output channels]`, so we move the output channels to the front to match PyTorch's standard weight format." + "Below we extract the 5 by 5 expanded weights from between the mixed3a and mixed3b layers. The output tensor is in the form of / has a shape of: `[output channels, input channels, y, x]`" ] }, { @@ -905,8 +905,7 @@ "id": "IWbzbWvGTj0-" }, "source": [ - "W_3a_3b = optimviz.circuits.get_expanded_weights(model, model.mixed3a, model.mixed3b)\r\n", - "W_3a_3b = W_3a_3b.permute(3, 0, 1, 2) # Move output channels to front for simplicity" + "W_3a_3b = optimviz.circuits.get_expanded_weights(model, model.mixed3a, model.mixed3b, 5)" ], "execution_count": null, "outputs": [] @@ -930,14 +929,13 @@ "height": 248 }, "id": "BiAXnE0zqyFP", - "outputId": "e4b6c784-17c9-468b-c202-364faf6de12a" + "outputId": "ac0bee4a-7bbd-423d-dd92-279a13af4b05" }, "source": [ "W_3a_3b_hm = tensor_heatmap(W_3a_3b[379, 147, ...] / W_3a_3b[379, ...].max())\r\n", - "W_3a_3b_hm = W_3a_3b_hm[:, 11:16, 11:16] # crop away border\r\n", "show(W_3a_3b_hm)" ], - "execution_count": null, + "execution_count": 9, "outputs": [ { "output_type": "display_data", @@ -1090,24 +1088,23 @@ "height": 248 }, "id": "rrT2Z3HiVDPt", - "outputId": "4e405033-a92b-43e5-b2cf-209185d3537e" + "outputId": "0c014f4f-bdd4-4c9a-e665-7ccbece256d8" }, "source": [ "reducer = optimviz.reducer.ChannelReducer(3, \"NMF\")\r\n", "\r\n", - "W_3a_3b_posneg = optimviz.reducer.posneg(W_3a_3b, dim=2)\r\n", + "W_3a_3b_posneg = optimviz.reducer.posneg(W_3a_3b, dim=1)\r\n", "\r\n", "W_nmf = reducer.fit_transform(W_3a_3b_posneg[320, ...])\r\n", "W_nmf = W_nmf / W_nmf.max()\r\n", - "W_nmf = W_nmf[:, 11:16, 11:16] # crop away border\r\n", "show(W_nmf)" ], - "execution_count": null, + "execution_count": 26, "outputs": [ { "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADm0lEQVR4nO3YMWoUYRyH4RmNqEiqRS0tbCxEUnkEj+INPJQH8ARCCisRtAjYKhKijSIi7HiB3ZDBkO8NPE85/+bHwssHOy/LMgE9N0YPAHYTJ0SJE6LECVHihKiD844P55fX5q/cs7u3R09Y5dHvo9ETVjndHI+ecGH3v5+MnrDK5+3bedd3LydEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUfOyLHuPb+bD/ceYr9PP0RNWeT5tRk9Y5f30Y/SEC/s2bUdPWOXVssy7vns5IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBA1L8uy9/js6bz/GPPlyegF62z+jF6wzubd6AUrbEcPWOf4dJl3ffdyQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBB1cN7x44urmnEJbo8esM7Zdfptp2maXt8bveDiTh6MXnApvJwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiDo477h9fFUz/t/ND6MXrHPr0+gF6/w9/DV6wsUd3Rm94FJ4OSFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6ImpdlGb0B2MHLCVHihChxQpQ4IUqcECVOiPoH1DEyxL8sENoAAAAASUVORK5CYII=\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAOcAAADnCAYAAADl9EEgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAADp0lEQVR4nO3YMWoVYRiG0TsmCAZUxNhoJ24gRGystbKzchUuw84luAVrGxtBRMwGtLCwsBJBRQNBxw3chDsY8j/COeV8zds8/DDTPM8roOfc6AHAeuKEKHFClDghSpwQtX3S8fale//Nr9yDw8ejJyxy8ejB6AmLfL/6fPSEje3/eDp6wiLvDl9N6757OSFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6ImuZ5PvZ4NE3HH2MOVjdGT1hkb3Vn9IRFXq6ujJ6wsa3Vs9ETFrk/z9O6715OiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0RN8zwfe7y7Px1/jPm4N3rBMpd/bo2esMjum/OjJ2xs5+jX6AmLvPg0T+u+ezkhSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiNo+6fj60ZWz2vHvrn0dvWCRzw9/j56wzJOd0Qs29+Hm6AWnwssJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihKjtE6+3vp3RjH83vR+9YJnp7egFy/zZ/TJ6wuauXxi94FR4OSFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6IEidEiROixAlR4oQocUKUOCFKnBAlTogSJ0SJE6LECVHihChxQpQ4IUqcECVOiBInRIkTosQJUeKEKHFClDghSpwQJU6ImuZ5Hr0BWMPLCVHihChxQpQ4IUqcECVOiPoLNE0znAiOBdAAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -1208,7 +1205,7 @@ "height": 479 }, "id": "SeM38ex_dcgv", - "outputId": "a6a269e1-2b05-4798-82ad-120bc6c03275" + "outputId": "28ef4f8f-bda5-4604-cad1-ea3ff228b777" }, "source": [ "units = list(range(320, 340))\r\n", @@ -1225,18 +1222,17 @@ "for i in range(320, 340):\r\n", " W_nmf = reducer.fit_transform(W_3a_3b_posneg[i, ...])\r\n", " W_nmf = W_nmf / W_nmf.max()\r\n", - " W_nmf = W_nmf[:, 11:16, 11:16] # crop away border\r\n", " A.append(W_nmf)\r\n", "\r\n", "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", "show(grid_img)" ], - "execution_count": null, + "execution_count": 27, "outputs": [ { "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1249,7 +1245,7 @@ { "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1276,8 +1272,7 @@ "id": "GQJufN1DrYYK" }, "source": [ - "W_p_3a = optimviz.circuits.get_expanded_weights(model, model.pool1, model.mixed3a)\r\n", - "W_p_3a = W_p_3a.permute(3, 0, 1, 2)" + "W_p2_3a = optimviz.circuits.get_expanded_weights(model, model.pool2, model.mixed3a, 5)" ], "execution_count": null, "outputs": [] @@ -1288,17 +1283,19 @@ "id": "3u0pjw04rgY6", "colab": { "base_uri": "https://localhost:8080/", - "height": 453 + "height": 455 }, - "outputId": "5ba59d03-2fbd-46d7-eee8-f30b93787815" + "outputId": "0dcbfd12-50de-425f-f32c-35aa6955ece0" }, "source": [ "highlow_units = [110, 180, 153, 106, 112, 186, 132, 136, 117, 113, 108, 70, 86, 88, 160]\r\n", - "W_hl = W_p_3a[highlow_units, ...]\r\n", + "\r\n", + "W_hl = W_p2_3a[highlow_units, ...]\r\n", "W_posneg = optimviz.reducer.posneg(W_hl, dim=0)\r\n", "\r\n", - "reducer = optimviz.reducer.ChannelReducer(2, \"PCA\")\r\n", + "reducer = optimviz.reducer.ChannelReducer(2, \"NMF\")\r\n", "W_nmf = reducer.fit_transform(W_posneg, reshape=True)\r\n", + "\r\n", "W_nmf = W_nmf / W_nmf.max()\r\n", "W_nmf = W_nmf[:len(highlow_units)] - W_nmf[len(highlow_units):]\r\n", "\r\n", @@ -1310,22 +1307,20 @@ "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", "show(grid_img)\r\n", "\r\n", - "\r\n", "A = []\r\n", "for i in range(len(highlow_units)):\r\n", - " W_x = tensor_heatmap(0.9 * W_nmf[i, 0, ...] / W_nmf[i, 0, ...].max())\r\n", - " W_x = W_x[:, 23:30, 23:30] # crop away border\r\n", + " W_x = tensor_heatmap(W_nmf[i, 0, ...] / W_nmf[i, 0, ...].max())\r\n", " A.append(W_x)\r\n", "\r\n", "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", "show(grid_img)" ], - "execution_count": null, + "execution_count": 77, "outputs": [ { "output_type": "display_data", "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADYCAYAAABIgjBoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy8z64lWbLm9TOztZa7731ORGRl1e17b6sZIabMesIDMEZCQkIMGCAhZq2ewRAhRjwBEgOEkPoRQOIhmgdAQi36dt+qysz4c/Z29/XHjMHyjMxJt26rS8WAsEmk4kQe7e2+zOyz7/tsSUTwLb7Ft/gW3+LPE/r/9Qf4Ft/iW3yL/z/Ft6L7Lb7Ft/gWf8b4VnS/xbf4Ft/izxjfiu63+Bbf4lv8GeNb0f0W3+JbfIs/Y3wrut/iW3yLb/FnjPSv+6GIfPOTfYtv8S2+xb9hRIT8q372Del+i2/xLb7FnzH+tUj35/iv/tE/oiwruRTcA4lEKSt5ySDOcR7EviPeCDPO55PXFwUKRRO9nZy1Y8kwNcQF3AkJwGjHiUYjYuBdcBKtw7oYjE5aCmXbwINRGyKC5IKUwtvnT6y5sLedPsAsMTzQZCzLQhJFRAgTcjbWstB64OK0dvDluWMSjPOEpCy3QojgLsQIIuD//Kf/lP/jf//f+Pt//Zf8l//Ffw6aSCqM3jj2A4ZTSqHWSq+NnBPujo9OiBAYGUVEETHSsrKYgjutQ3gl54RQGQFhiTE6bd9RVcIKSOL9+xukQkfnd9RMdaGrojlRkpIkIZIQlOHzOxqKGQQDbwdvRyAIotDbifdKRMcJwEnqpLwQzTEVhg9EjPtt4b/97/57juPgP/1P/mP+wV/9JUEQEVhKpGUjxDjrSUqZLsKolQhovZMEkihIEChqCVFDVLEEWYSyFJYlcdsWHs8DQpGAsx2kkogBZ+204YQmtBSCoA5YUyKiY2Mw2oEZJHfu799jKogaZoaE0TrUXkEED6efB18+vTF6ZbuteD9pp7OsZf68dzwGhgCJf/bP/4b/9Z/8E9Z15R//1/+YflYUSDmTRPAhjCFgheEgGMUyyQzTTFYjmnIvGSGz184YBzECkUR4IBIkA1sSlguC4iNwPzET2qgc+86zd1wqGo0WgxBHo+P1xPuJSGAa+NlwXdDRKaUQ3hkxOIaCJJbbK5gQBKKCSBBALgsiIAaBcy9GWQqfn53H+eB//h//F/72X/6e//A/+s/49//hfwA+GPUkYub4Ysbj8YRUWFIGIMQ560AcXu8bORnhjo9BeEcl0+uBpkQ9KmdteO+MfoB3NCXyemNJidsyz0/rg+5BePA46vzellgzDHc0F0Y7OY9OXldGCD4gpwSWOVrDPRieMDU0J8IdKdt8LgH7cyd85jUIKoAoaorXnf/pf/hv/jRFd9leWdYCKIslUl7IqWBJcB9IOI6jstHrib7c2JaEqZJVOWKwLQt5WWh1UI9G6PygIiDhZDFEgQ773ikpUdaMj46IobqwbBm9Qx/CCKEUY/3OaK2y3W48e2eMTqCknMg5X583YTlhSTEEj+A4n+S8MDwQB8kLWhQ3xyTTh3DuJwio/fKYVIXlfiO6E8N52TbQjAqIGtu2oQruzhhO92D0IKEs620mokBEsCbDBNLtOxTHY6H3gaOU1Xh5/YASjBEMIKXCGI5oYt3eYSpwOimBlkxOGRMjqaECY3R8uzF6o5gwCJ4PYV2EnEDVabFy1spoO2pBNkjRkbwSHbwPtmKctdJH+/ocXl9eub17RURIpogpwyFcWNbMXgfaK8uWeO6dly0jmlBLjN6IADWjlBUpGTRYLaGM67M72/3Gum7EUEZ/IiJ0F/RobJpZlhsIHO0kxMgpE73i+wO9raQURBjrUvDjSVFlWTYilJacmyy4Q2s7T+9s20aydyQLnJWWDkRhoKSScQcBsikvr7f5IETY7jdayiRVlpQgAkYwhhBaEEmYZkwyhOLdWVIiLYU1FUwT5QzG2GjPJ6oZM2WEE+qsLxvLUjiPk5wycOdZK2usJFso46TFAeEog/184MMZprQwckqsKoyoSDIUJWtmROJ0x/vArJAyYMbACAEVRyQQE7ZlIeiklMhZ5zOlgSqqBoDpBFXzc4OiCPNsbPd3dAbremddVnx0Rh+AsK0FMxDmZ+m1o2rUmrktK+fWeB6Bt5PanyiBqlLKQjJjLUq2oPVKd2Gg5DuM+sZSElxnTVWppyHSyMtGc6jNQRIlJVLOPPfK/eUddX+SsxJhlG2lRRDz29BHw2WChaQAs3EP8b9LOf27Fd2ZxIlkhoiiEeCd6PN8mRguhofj3rm/3LEANPHY3+gD7ltihFNbpQ8HNXp3xDveKtu2gAqP58nZT8piqCndjdaFbcAY4Mw/j1YRhBQdUCQVzAOxnw+1oSKkZJgJKkESEARwJDpEIxGoGH51d/uZiomYiPVKrPnHLDAxnNEaZ++kAM3MQtErakao4Qp1BLV3xJ2UC80bEYF3CAEikxQ0HNeEqqH9iXvHwwmBXBLby52QjEWnVscl8zwG4U5KKybGGMGzdSzNZmTeqWfDkiGWCBFaa7RuIMFRDwBKUowATaiCqE/kqoaY0lyIZHAcRPxyqESZvxuZqEgNEPpwog+KOiPNs/HhXaH3Qe9C753ujoqgBBigSkRAMmobs9FJ5p6N0U5E8yzUeSMtKzdrQEJTofsgdaPjKCCm9G3hviRElPr4EQJQ5r/xgSqE9Ilq2uD59gVHCYQRDcWugz0biZqAJDQZpooxrmSbRVjUMO1oDAxHMEiJQZBUMBVyziRdaWfnHM6QhHEhMHOyCnE4W9oQTfQRmAplEZacURFCIGIwQllLoj8Oog/u94WzBarBeRxoJLyf9NbwcEQFLJFzoDImMlsz7VkJBBMhgO6BW+AMvDuCk4uSVXBVWhdKTpxjEG0CgbyU+fuB7oOjVcZo4I5FzPPkmeGOayAyaL1yPB+oCorhRTG9JiAJnE4yIS9GLsJ+NFJOuCTUClYyXmfeq85JFiCZ0mMiXb3QfpHgqE644BheK6P3OX250EeAdboWVHVOhTLISRm9IyS8DzyC/rUeJlx1/r4IhAF0vP8CSv6ti26MjkVGhjMc0rrOsdcdgflhU5oPeimsy0o9Bt46EUFOhkTgEUQMkEAl4xGYJjQLKa/0cM76aRa/XDjbwH0WWhdhRNC74yGYGaZyPRBBHLZSaAjH+Ya2jpZZEFLOCEEMx0wIucanGqypMFzZz0pRx5Ki1wjcJYDALj1RREipIEAfHQnBCTRi0gzhM+XUJsods3imCw1EzCQdgGniue8sRXCZo09OxvBg9DY/R8pEBMdxohbo8srykvGzkarTRKlj4MdAkiKWUFdGhxFCI11I3okmEEFJhbfng96DkoXaHI/AJZCZgqglooNIsCwL+IlaQeovumpE0GolmCOcjMAlkcqCRp8jok+UZZr4UneSCa12VOcUkkyIcMa54wGmgqpgyVjWRO+diEnduDqBM6JPJUICSUKWgo+Oh4Ia4JgWUsocx4mEMZqTUiHlxHa7IWocx06rjeGD2gY5wboU9uOB+EAlUJTAJ0rNy6S1cMYYtNq/Vt1cFvw8EVGSzYlwtEFJeZ5zF2I4Hh0fgYSizIlEHEYflJJIeUWGg2aSzrOak0yqqE/UjoMRSAhhC4l5VnNaUA2a9AvFCsSkA1qvaEBR5rsOo6ig4vR6MiRPqq83xK4vFQFXMZ5gadJPIYolZUSQS0Eivha92YEmqrSkxOh4BCklenRyMWo7SDLf67iKY6tAGIowfDZ9fIB3epeJqkPItxutJ0YMgkDLSimJJc0JqdedQUe6I2rEsqBpgsQ+KohSB4wxUfGICRZUFaUjUi58NRAJHCFGw2LQRyU0zdpkCQ9hhILO7msETf+V2tm/edFlNJRyJUxGmR3XwyciUkU8YRqgMGJ+sX4+KdkQH/TaQI1ACHEQRxBMFE2JHkrrcxy/3TaSJZ5nn2iIoI95yN3niy958nd9DFQy9Xhyv22od7I4WYSUjVwME5kjugdEx9Uvjq8gWqgusH+GSChgEgTjahD2y6FCUJuF0YGUE2MMaq1Eb8y/NXwMeh8TLScjWyFCGWNygipCB1pvlG2h9RMLGM0YfeA+CJk8aQ9DMbQLDogrWCEvnX5W3IWhCwxICCQjSPP7dmcIpCXjo6IIOIjPBHaH5n1SQyaIyNXAlFE7JsFtKxO9Xij/65HwgfeZVPWsBMqybpSUZiNKid6dEXMoW9YNFb8Qzyy6lnROR71hGiidklfKUgj3C23OcV3UEAH3PjlrTSCQVJB1wcQAxbuwZaO1Ru8BPpGmhyKSiWvWUTFGPznPk1zypEhE6ef1mUQRINQYoYj7bL5Xc3L5JcEs2ZxkzoaHEaORUp60lM9Chw+8N3yApURJNhPelN46lhLhinvHREgiCEK4IGOiOYkgEaRFOUen3O54fdK8oi5EP69mHwxXPAyn0b1P2smM4UJZViImd4saIlezHzPfxAxkZt5oDbmmQQT6cFSgZCMivqLcn4uuqGKayEnwMfn8dV2Q00CFaJ3QASkYw1mSIMkRm7VAPHB1VIWz1tnI0gIdtCSSLVArLEpeC2C0cMQHY8yGGIDKhe6vieOsFROfwEkVD4EQ1NKkDHpHxySuI4LWGkcfU8NKmdorqUzQ0XqbdUETgeLy8zRhf7qim9MsLgNYSkFtjuOTQE6IGOGC4nQCHwIijNEZSfGrAKWS5lwqPguvT8TktgDKGEFOZSKMEEKU3iuqmdFjJp/oL8R1n3ynZcHdqaODD9aSKMuC5smz9e60Nov3YBbdNSfcHJFErR3T+TLwACZPnczmWCmz2ATz0LUxQAVF6eGM8KtDzpcZ10RAyOS1zYgxm1EIWDSOfSfEae7QT1IPgoR7n2KQpImQQskl009Hx0HvTt5Whgu1B6RMSAYfTJeKEqIESoTOJqIJY4ph4qA6aQ1kzFy5EJEHRPw8ZjORxwiGC4Gj6ZdDNW+ni9lAPIjo6CVIhQqyZEaAXdRBzonWGylnmk/GZqJ/RdIUejQZqoZZInyQizJEsbSwhNPHLIKihl8NAlEsFwZGzgX1BXwKbWUpeJxXsWY+r6OTkxARDJ9oq5Q0aZJwtjVznJ0QRcQRV/oYeIxJFQiICprL12fh/ZzIKjqtd2T0SzAe4AONKcKMMZ9bSopZTJSkCY0gLCP0Sd8hE61eY54Ovf5eKVnIqzLOndYGIkzOuw1i1AkCWlxNJuFudO+oBRbQHJaU6L0xAsSMZIVobaLZCDTxdZoIdZJOUdmZlFZozGRAkfhVIx4TBH1tGqoku6gnmY2VnBBOjFlY1y2zLEYyxfQS09olUnWj9YZaojnQK8YEepMKCIb3iY5HpfdGH2OezTFQC2Q4SZRolRBFr/cYkkiauI4xKjNvcsrEcFo7Z065MEbFfcBo+HBan+/OUgazqU9lnU3sT1V0xSZnOEe0Mrtg+OQgrUwklpTWT4br5H7VcUmTJ3IhYhapmWh+KZUT7aKDkgr44LasjOFECIZwtMkrMWYhmJP/HEEmFphJXcqCqJFkIhtZV0KUWp16Oq0PUgKxwLuTlkKlEwJ9tIsC8QuVACokS3DRGLPQOGdrk4cLR8InP81sBCKzZof7HP+wOSWJkyzhOimW0U68HmheZjcfTkhDxGnDGT4oYpQskBSPROsnpQw8Tt6eUwBozcmbosrVICYCFZfplLAyKYMAtQyakACys6TAR0PGQDA85sgXoXOE0o7qz8VpovOfRylgIiSziU4kfUUXrVVyzowx6QnRTIyGa9BGxyxRR52UwJWQKeXZtFKec40okhQrgo9Ac2ZNcJxTwJhJKPQImiuYMDxRLJOT0c9BWRYsJVw6PqD2MVGJgw8HJreblwJXAfABZZlugz58crs47oMe4D6FYUUm8mMmbD0rDCWl6ToxBO+NIcx3oYpKEAomU/Ee7qQ03QjJZoPVSWZjYZgkQjqIYBgRxmJKTvMzFR3s7Y02BqMzETYFFb+SxEANj4xj9AiOK4G6zzPRHJxgyYU+JtBgBKG/IqxVCRJ44DEQwEyvCVNmYbuORGud4zyx0fGh5CQMD/oQ+jhJaTZv8TaLZy4sBZY8v5eaIGSkLNQ+QIN6dJbFwJwxTooZyYSkXDUABkHvQfhk5vvohJ8Q15RhCzHa5GTDCQRHUUnXBAGWMs2DCKfXhsRgTZP3TdNoNGm6CILAr8mbiDkFpsJo9U9XdI/zYLvdyTareeudAMwyqml2Ow26zw83X1oQaToGNAyC698JMpzeDkafApMyX6j3xpozSJr8XHQIJTwY4cDkuSwJowaJ+TvVB2VZScuKeefs/ULJg1GDdnbcG6KJZVuRLldRVGqriAyWZNSrGw7xSbyKofYLvRBxiQ3DcXckgloHiUTWRO1tCnLBxQkKMaB5YEsgMSbi9phISSZdImSGGkbgIXQ34hRQp9yU1iCs4CaED/Zjpw+lNiFksG5ljqcyZqcXIWlBTBjeaWNSJvigDUcsUYowquDjxExJMumPEBgemEA2w9QZBO6D8qvxSS8XCyGzEEQQXqcC7U6M+f1rm4p6Rue7EyWpAHEVHiGlyZFNIcwIW/CohOULvXSWpaAkuOxOGoafE9WYLZgaZ+uEN+7rwtn7dEq0lZQz9M5il3hHJ2KQkpED/GcEzuRBLRkxOmj5yu2OPnAJhugcV7z/XHMvd8Xgtm5EnYKtXjULmZpHSpkihTGE0RWPiVyjVdK6YYOLXxQS6UKSUwSVnNGLijMVWu+oZ5Jt1DpQnFxe6JLx01Eq1YM2hCBf+ktjhFGWTPdALTMkMaIzrglVVLnsRCCDEANLSEqIQkbw4UQu9CF4r9xu29czMeICHb0TzpwiWyOlTk7QxkDaTsQsmBGDek7aKiW5pk2BLOiY4tpt2cjLQm+Vt32i7nLpJCEZr4MxZjNIOikhiQkSvFXcoV9ujN761Tx8otOQCRxVIQZjdM6jEUz6BBGwTLbpvCECN2XImLy/Tdl0IuFM6+NPV3TPs/Ly+g7NeXaC4RevVrC8MFpjiOOWkWGc54nkeei6w6LKUjJtTI4kaWZwTD7RVjQm2e3uNA+GznEqwkk6ObTmHe+DtRilFHpr03c3gnVRtqIMmckSI+i90faDGIYSmA5svpGv3roxBudxIDq5LUuF2qeIMq1ZU7Dwn6cGEVQzPq6fuxOjIylPf+pZL4Bx8V29g/tE102uQqYMWXADQ6jn/tUpoZrJOvDqjGEchzPGk2En2MqjryzLCnFS0rTZaJqukOYO1yEIjGwXrWNK7Z1oHU2KMxi9U0VnYlvCspDs4qLHwGLMqSYZtXb84iP1V0g3q00kH0ExJalO+81llUvWaR2sCKQFwsk2XS7rsjAESFORr61f6CNDyXgYlheQxDGcvG5oADYpH7GEhHG7LWxlBU08a6d6sJWNbHCeHcuKW2bNhdt9g3bivTPLh4EY3Q80BGcmfOtT6LU0+XEfSvQ6LU1qU9Qa4MwG9HOye0xevNxWDKXuxyUiT3dAMsMs00LwS7WXriRNFCvogDqcBBhGH46ljKXpagmf3mZLGRAee8Oi8O7lN5y1E3mQw6j7G8d+cBznpNIkkAQhxn1bWNaV/Xxjy4aVQn06b18+Tu48J7i4ZA//6k8uJeMxXRQRzr4/L4HwavJXfqjYBD82+VxE57lO0w2DxyWODnIu1FZJybjJbAzIdED03qfNU5zWOtu2cPRGWjJ9P0gx6GlFRWd9SMGlaAKDWiFqo54n1fNE12LTldHqdE2V6cUdPhAzclIsG4U+hdWSGGIslnEVFi20Wue7QOhjcrg/61micnl3/0RFt2x3StmmXcvH7HY4rTs2Jpc6+iBZoTF4nF8ooqhltM1lhimGXn623giBVBItOuJAzM6x15OybJzP51SEUULjEr6YrdQFdPr2tL+x6ndk7Xz59AOjwv3dned+YO44c/RNAoTTaiNLRmxh0Fm2hS+PB8uSWEuedhfR2V2diZb9FyEtNCMMhneMPBcSrNDPJxE6BRIuNCtgOhE5o7O3BlkRM7a10OtB2TIlr0Rz9n2OhlYypglHaaHktPDcn5zHG+3Db8EDs86SE8/eIKCjaJpqqlziSMpQayMI8u3Ofhzo6IQHrU/jvapMpHBxW+FOjz6fQ9j0IKeMx6D1/vVMtBGc/fqf+gALTKEzBYxpb2pXQho5r9MehlOPSySLKdhoMtA0C43DYDAwSsosm/L+vuGj87zQSr8K5m1deX33ijdBtBF7JavPMT2U47Gz5sJSClHf4PJWx8W+DQ+yBlGUUSvuAaNd4tyNs1XaOSZ7RKL3QaiQl9ulQ1zFJgk58pyuGAwf04kRU7CNgPABMvAh5LSyWJ5OBFtQV2gN7SCjXROjoZrwqvO5pTwFzXOeq1Qy53Ngllm3xulPzr1znHBWYd8HHp0hlRHOst64rc5QZ+ikAlIM8nqjv1XOo7Os+aJIAiXNhQUmFRg4zsJqwvncKTZIJfHrOlNKZllXzASJTC6JJSkDp6TAe+PNn1jKc4kk3XlZEusyKQORuTShySFOkg36cEb/Qjuf0x0jQj8bm2XCg5IUMaGFU/cn7dxxB5OThUoPx9x51s7djENBtHOeD2pvhAg5JbIZdTCpD0201tjWZZoFvOIxdZLpI3f0sihaEkYYwmD5UwppKWVcje4Dd52JJFP4Omtl+ExQHUJvg73NkcXCyaRr22qixn52amvTd4gwjs6jVoox1ci9MhD6Ebzf7ngEb/W4bCRBuCG+Idsdf/sbPhTjXhKfH5Xz8eBshqSMW6O1geX5IE4P/HRkNNZtpdXBXk+WRbhtG8TcBqu1oTlhTD5KZHp8gWup4kB6A+9UXRHmiy/dqVZRCiVlYuhlz4FnG0AjpZVlKeztoH75gpTLP+uTnx2XsioqxKWwjquIPZojWvj88RNuC6+b0MuNqsbLurDkxOgyN6188AzYtoV+vrEsefKO4Zzj5xwuHG3nbCfJjCyB+oF4v+xqdiGdSvSBXHaer0U39EIKnR6gwaSNBlP4q5U6BksUvFVGBrqSt8JwQXqfNj4GZobnzFmDpWyw3kFgvd/47Xvl808/kbcXMsLQuWGVl8yyLnODC/judWUtE60HSvGgyuBlW/G+U2ullAWzjPdOREMC1iVzHAeDgHGwlUzKK1+eD55fHpR1myKYMymhpASD0f3nPkxOOv3bTN9n1BNpgyzj4rUFj0pt0D1RMJRM9IApTyHHoJ1OV52beXkKimgiRHEXLIKSE0cXNAseOyhEdERgZ7B3p8UyKTLNUzwdB1ima6a3jMqN8EqPhFnm9vKO1Cd9l3MBGowxXTeaSdlAHC2FnAopdcqaZh790ochBtFOps4ckIPuNqe97UY933BRltuKaeLdfcGikTMk7dPRpEBMrUa70PpJXje2ZpyjkvWGRqednzAxgoVzf1LfPtFrpdXGsi4c42DVYKXzVju9NdCN0ydgkryQTah9UGsnK4SkuVQSjuVEGztGsG53qj/nQocmMEXSBUBrEGpkpof5T1Z0/ezU3rGywqj0VslLQgz2/Qmj8vr+dzy/PDn8YL3dqV9+T769UpY72h5EV0SCMRq1zVXZROL5eGNR6CNYt4UYncfnBy/vf0fKmT++7ZzV0ZR4ffdCtsK+Q3o6q8O2LHx5HLx9+pHhG49+UH94gML9/o5SVs7R2S9bzq0spJw5/SRZcFbn3eudL58e5KyoCmDXyu6YHFCfRVeZa6yP09kscY7A646Kki0hdo3ifnFANu2Gpj4LizfqDjUCFyjuDOm4FFwXentOtCmX/zdlXl/fYeXOthg//PET40vl9ZbxUN6+fCHKd6jBQEgyPdWjNU65tr90IRXD+yCh7DWhq9Bi8u9rMrJNwao3YEw6J6XCUQ9UjRGVs1byryxjZpNa0Gu1VmX+98uSOVvnbAOS0NqBjIasvyEvGfHBqoHdV7pkaps88pLm+u+nMciiFBnsZ2e4sbx8h+aFVSHlV04PjrOxnwNZF17XTDYBgbcdPn38SMnG6+3G2B/sIbiujG6M3vA+ueDojcMb+3mQvOPMCbvun8lauN82nsc+rY1pJWy+G9HEtl7uhYCzNRZb0DSXGGQI0Z6UVKZo105CLpEWJ28FHSfhy5ySDhhNMNIUIOloUUymCTFQkqW5MbgYZOWswQE8f9zZFuFjfeNvPh2cl/NCtdD6pJK6O90cewr3BAvBKYlFE/V8TKrEFMW/rlgvOSMqdB/kS+gTnXbASSHB0Wez/TkkHHwuXJASI37eIoPKF9ZckGQctXLLlbMqS3Ke505JcqFmIduGepA0sWWFcXBLjSSD+5ZgdegZH9ADkiRe1veID/afPnK0qynKyYngLOyReBHj++/eUWunxwQ2m0D47Kqt7ZgVeu20s5KWla7BUQs1KinNBSI1RTUxgjnRml2T3Z/QvXCeT+76HdF3xlHnHQi9InVyVaqZaCekRAk43h5ILgwP2vnGaDtLKuzHSasHxRRx5Xg8iVoZoqQs/PTDR47jjfqovH/9C8427zK4by/cVkU1OI5Ke3Q0B+9++4HnqDx++sLj42e4vRC8cexv/OY3v+W3v/kLSAvH558IhCSZODuf/As1Ku6OWaKUG+/fvfLTpyedudpX64GVBTT/yggiqCZebjfUG6NDSxl3xVOidyNFcPQ6fZ8RU5zqgyFMsSh3GhnNndqUx9uB6TGbmCQsrXhKnKxEM56//8Twn1i292zbK99/d0c8OHXj3ZL48TlhZirTq+pxYhiW4DwObvcXegw+/vSJ++tGeSlofyOlhdYqQ4QMpDxFhagnIs65n5w92IrQjoPmQfnVaVERrMy1Wxl1LqBYZj8Ohgev33/P548/zOWU9U5l3sNwf7mx2qCLI3Gy2twYOZvQxkrtgr+ebMV4fV3JaYN+sixBzjce+4mK8eH9u4sXPZBwzp7ItvDpxz+ACvn1lf7pJ/LLd8jHH/HHTg2nj0F3n+b8duIIBaWN6c20CDQbOUFkZbTgeQxqfSJ5QVJBs/7KnzrtSZYTxOBZG6vAUOOnt53bslIs4QMIZ10gM4Xb0XeUDUlwvE33gFqem5N+LSvoZLtpA9aEeCBsd00AACAASURBVCKq8Pap4Z9gWRf+9m9/4nYX0gl+DDieHG9vtHDytrAuCyHBsX/kfv/A57GzLBuDQS53AHrb8Zgcaq11brPdVpYtzyUGy7Rjn3ZAnaLsIn1aI68MKVm5bYVUJkd7eiPnhVtOHN3pXikp0/3k2Q/a588sJbFmmyJfyiQxWntgItTuWFba/kdQ5ePv/wX/zj+4M/pnINNbRTw4Hk/Yv7BKx6uwqDLGxzm1LXduCB+2wnfff6A+H0hWZATkQu1OGwfbtlC2hbcvXygmvB2Xh1kF4YmJoTLF4JLmf4+ApsG41p0X+xNyuq/vXik27yJINhXmaQQO1H2uBl4HttfpHWzHk+0V/KhkNdq5E9GATt077Qz60bAy0VCkO/vjSXt84XZ/B2Xhn//xwbpUii3cXl/5+KXy8dOD12Lcs9Casj/bfHnrK5adx7ORJfH9uw9sKfHT80Grx9yFj45ZoDkhw9kKWFmox5PhwdmO2eXX5UKmioaTrp3qucI7puARUwiTvABzJFmWQtEF8UptlbNXxujIkMumBCLKYO7AWzHW2wu9vvHT5we3+zusFEwzr2UKL/0wej14/PgHns/O5w9/zb/77/01f/+3v2PvkD+ejD4vfHk7B2Eb6z0R2el7o3piiSlmnc8HRGO5GaMfnPtnLBViWegenLVB66xZiaGkmMrwYsJwZTT5KprkBKtNFCYecN2R8e5lpbZOPb7w7vU9y3bneH4haqOs81Kg1htmBUSoEQwrLNudW95Y9oPbGDgbPiYCczI/PAevm7JtryzrOt/FOT3cORUiJz69PcjlTs7T5dBFyNGozzdaVDyc/Tzm/Q0pT9HRwSMjDoZTayNpop37XPJxwAxN21chUW1uzf3ciNOlbIOTRqXWMS93SnOTSi1d4mzMe0QI2r7Tz0T3j/hIWAyOZry0YFw+XVzwDqkI60tmnMYAmiovawEJ1k3Z3v89Pv3hB75fBsem/L6fNNmnqn6euBa2NUFaUAs2UcbYOetcYb1d7oguifVmWL6WMixxDkCCxds1iR746GjK1MqvFoemHS7LhXiZF/ZYNoYIhw++WzdC6mRGPdgIbsuG5UT0ec+JrRk/n2x5Nnv1zvdr5qcf33i/FP74L/9vvvuw4c8Hv//hM+v9xksSlpuRVRFrnPsbi2Y+ff6BtRS8zWsBno8/cL+/onWwSKEHZIPb7T694YBinLWzSJ0WUge1BdPEajL3A8IZ145AMNfuSwnOv9vVC3+3oms5cR4HR20saSPlPL1qQCgcdec8nVYHMToqlRDYj0pBUIezVR7PndFOonfElXVZUYXHXuk/fOKnjz/w4WXl5fXO8/lgfP4Dtw8rKXbEX6AOZD/m4sBiPB4n7W2nLC/cvv8rjv2BnYPf/dVf87re6bUi3i9PsbBdO+xpKaRVp2BXJ/f15fFGF+e2FiwXcknUszP6XOWdBXP6X4s5PtLcWkN5fb3ReuV8vgFzY0rN0DB63znHtFv59W+2+53XcIpkfpSGN8WrIUV5Pg/SfnLbFnS749V4++kLy3JDt8RtE758eeN4dMbrb0FX1gVKCKqd1p12NurpbFm5bQlvg/vrjaNl8AdT/4rpPRXhGB2NhjKRVes+76OIMe+isI3FBB+Nn02ZIpNznOk17V9t+DR/Aq8vG486qOOcl6RY4pYbtT9Y1gwp8dZ03iOwrZRs9LGzLE4L5S/uCVuFvG5zM9ErgZPKdLWEGun1FY15aZCq8rtUWFEe+4MuRtZGySuvH97x448/zLOcMnU/cYGUl3kpUNtJOeOtotem1V4rt2VBlgVlTiEwFWoRGL9eA87z7g/6SRYjskIEQ2ZhUhfWUig5s2omWabZQBelDCFItE8ViT59sLIiY5BzkBeZd0Qcg+V9xraF4/NOjsIHVUKMlDtflsznP7xxMHi8VdrxxtEfNAlW2dhePxAxeDy/sIyOs9AM/PmJkaH7gi4JmxwKlhMe0I/Ku+9fEe/0UafYfA72PviwFUb/xZv686U10XzaMtVpjy/zchgHFuHl3Z0+GkMLSRqajCJ5inpFKduK3jc4P1IoIJXXD+84Vfj0x5P328ZoTh2V+7vMh3c3NnOyCwVI/SMdqOONv/rLDySBj9vK0Re29ZVWn1TXaVWVRPIgXdcYHKPSRqDLnTxm03DvJCBnmSvFeV7s0zuQhLUs5KRIdPxX9Nu/ddE9zgPLy0zQ3q6LLjIlZzSgngdF5pVyDSenBY7GaBVNC22cvD0evD0e87pCjG17x8B47m90n+gnqfJ+W3gtN37/wydKMtLte/YhjM+D8Qyyrqzrnddb8M9+/yN3T5T7ynZXSsB4/cBvXt9R98q4FXoMis7VWdJCsUtJtTvuc73x7e3Bsix0XinLjbIuPJ8P6lkpJZOXXynVzDsnrB90WXCU/Tg4z/rVlSEx1ydrrXOjzgQt63R9dKd/3hm/eYHhpFO55YVuyvPzTmjlvhghfglOwm/WlTfZMHkgVelvnf5y40PO/HgWnq4IMTenWp83mr2saNk4VDn3L6S8kqXTNfF531m3ectUe+xoydcmXOOW5lLKeXZGf5LTfZrgfaBL+WqEL6WQyzJ90KPP29RGILaRl8yzdWoIuVZqGEWCHgspKdWNUZ0kQbaA1qgueDK+PDp/7zuBc2dfXnhfhIzxODOalWHLxeNdd+WIEqaXrQe6nMRiFIK8/gXHsXPUz+x1NqLWTsbYMQy/GmHfv5DXD2zbytE7/ukjry/btX1mE/mOecdHSmVuzv0MdAOOs3NLQRtBrzvJMqaZUuZyDWMiphDoDDJzgUN7IGUBFlQaOSVS7RSpLF0pIXhPSNpY399Ji9CendseiBtshcenk0d8oX05+PKYVzXmyGS90dVxrXiMadwPePnwO/74x/+H716Fzz/8ACj39y+0vdHGvDtEbG6GIXPT8nw+WZfCiOA4JqWgEjyeXy7h7eo/EciYPxdLyOi4wTDmUkIIb4+DclvJ4oCwMXc5nMHZd/p+sJWE24qMj4xx8oe//b8gv2L15Gyderyx2LRp9f1Jj06iQ85YCpJ8RtuD5+eTZfkebh9IJKJ1Pv70mSGZ5Z7JWUlqeO+0Y+ZEt+uagNX4/HiiOUNO1LPiYmQVzNtcL0fQHowuczFj/Ak5XTO9rtWzaxtnzl0hg/Uas+p50LtgSXmcHcfYLHBR9hbUEM6hDFa2vJDLRuh0I+xnx/9f1t4z6NL0rPP73elJ55w3d+7Jo9FIGklIIBRBBAlWIpUIomCXYJtgyq611wWUvWaxd+3drSIs61pC4WVhhRF4CUIiSkIgEBpQDoxmNEGa6enpnu5++00nPOmO/nCfmZG/UYXOt67qrj7nfZ9z3dd9Xf//728tm7OG1aqj5Ih+cMhmi9QNrGyiaLKW0UiNKUv6NLJateyevYOqSHT9Ci0ku9NzJOsJsadoZjQ6lwkXTXa/KYFPBUSB9QP1ZIN+fsLOxg4eMKbMYI8kUMqgVKZyrR8rEmtHj9ZZiB0Tgx3puxYjDS5lgX7wDuez39UoibeWSMwb/ULjUoUeRlIbKBQUw5ymzHrfwSas08wKyaLrSXqKaQruOFXTp7OkKBlWA51PyHqHVTKMLqF1RVHX9N6yPLHs7JSYqmQUNd0QIea5WaEs4xAQKazlVRDXW12/Fo1775FCM/Qtk0mVHW9kklguNokYQsbzCZlnujLhA+ACUWiMBDeOVJOKpAQ2uGy8qPJSSMYxazdF3tpLKagqTVNALzSVKXFG0vuIqCtMUeGURgmRZ4FaoSIUMpsVLJ5mUtL4TAZ2vaWoNzGbkf7gUYQIBCkJQVCqiFKeznoCEukGOnJ3L1UGxjzDJE5uxK+NMwmRbdXPONIArVVW8HjHYB1aJYQCLVQ28KypYTJ4Cq1I0aFEBCkoioZCGoalRvSBNIb8/0SJiwGjEqYAdRJQShKFRtkCkiZKj1SS9ghM0JzaPkXbr7B43NjR9svMckiGlejzmG/DI0PC+8D2qW16mxCqyBt/PxC8Q4ZI0gVCZVcgUmNdpCzy8jREMOv3GNZQK3JdJZF5EspkeZXzlsIYgoxMS4MdAjI6dFHTd8cMQqz/noPYo2Vg7AOFH+itRQyHTLem2HTIqd1tQrTYoaSUmbuxNZtgkkXajklVofSE/aIjbNZce/wp9k5pLl3f58y5u+i6gaaKdO0J2kaknOFSmU1Thcas6XrJ23wzrmt8Spl8FyUqpNwMpYBcL6ozRCvP+Fd9/8UrujF5tDBUZbl2HmURvGI950yBYeipqlk+DZ2lLDRCV/RdR28dzkaiFxhVUJQNIWna5UDfjqQAKikmk4bD5Zwj2TM7dZpFF5m3S/pQYXHsVhN2NiqkTrTOcn7zHJumRMYDJpsV03KP/mZEmZHe9ygJmpSpQ0RMkdZC70SILrvcUspaPlVgdHaZeRuQUoMReEJmLTzzWZ+xOJYmWz5FoLcO3zvKWYkWCevAxoiNPtsooyBZhx86tKjzqW8dgxtAlZlDi4bUoYRgq5kxnTUkUxBNng+mCPttxZndDaZ1zdPHLRt3nEEUNU9cHylqiSw1KQV83xIS+KiwQ2DZJyQDhkirS2TsCUkgRYVQDmRCxjyTzOeLWEv6MqEqxCpTwAg8szTxa7BKEpmTELzPQCEV8S7zAVKSmFJkPKQQyJC7ITfkxaGXgtFDCJaykTT1lM56xtazBGbtimh7draneC9YdpZmo2Q2qSmUxghBSSD6ERs9k7LAUuKUpZaCeddRmpIkJZPasFx0xBAyvN1HnF1gg6KsZqShz0uwpsKlEpcysCGg8yBN5Y4urDfdGT+0Pn+kyY415ymrKkO8WVtQybhCZP4XgbzMEzGCyItIGyNCOOqmYLQjIgi0SagoUDFlzKHMxLjVaiQWgZQU/bzDbqq83HKKOPYIF4keXNcz9i1WRqSuaPQErRN2cYAxDcvVQF07hKwhSWIcMEow2sDoAyoqimrNxC4qnB1w1mcEI+CCY9LUeNfzzKA/uxQLkhRZqikURSFopg1jyMaC3P1nel0/ZHtzpStUCgShkDKRwgpVaJJIWJnlWQWBlI6YzmpU6inqGu8dW1OodUVYDMg4oCa7bJ+7JXMaSk+MgmjAe0c90URVov2YnahFgugIvifWDScOOqcwRTZ1mUqxWPQUZZ3tAUmsLfHq2Ztl5kvotd7cfPGKrkCiJBSFwvlssxUpd6kugvOWpHJ6QfCRGBMRzRCg955xzCJzF7NrpA+SMDrCGHA+Yq1nu644Pp7jZcU8jGwUNePNQ/ruBLFxK7PZBjvTKRrFftvhYmJTGjYrg26mqLqmKhpaNycWkJTMVk0/IFOgLCcUdU0Ufu1CERhTrsXymfSUPehjlk0JQUiR6DN/89kvWMjXaBNyYoL3NrtSUIQQ0EblFIUYiGuIDEKiyoLROUyKmLTmgSaoq4gfI1EUHLQrau043TSUpUPUlgtNQ+odK6E4Pa3Zm0kwmlrvMjm3Rx8NM+9QKaJ14ri3HHeOZBQUDUM3sHIRo1WWlJmS1WGPKg0yRaS3qJSLIai1DTk70JDZSDFfLjFoyko/u0gTyT+7MPE+ZC5CSkgVc2qEz2ByLbOjzyOR1mL0mj1AhnznBaPHecdi1eJTTnbYKEu2JlMaKTDk7bcNI1M5oykNlc6ayjFkELYpS5KHpplhsQyLFSiQgyUsl/hkiB6UiPgY6AdLKQVam2yBLmuK1CEkyJiBTkFmzoMI2ZSRTQLrW0F4zvLprKM0RWaAaEVUmhQywyOKhJZk4lvKsKEwWkxKCF2Soid2luT6/PP2PVrMwEXGocfUBqkTCIeoFG60DD6wtVtQq4IbI0x3GxZLTRWW+BAYxgEbJDHVjGMLqaMvBNVGQRw83dhSzRra1UBVlcRqrVwhd23WOvzY5068qvJBldZ0LWPQWjLYQGHc2in3TKHIUipU5k0IGQkus6uj9wzOIYxCO4cdFSEFxiDY1AqiQgpD0dRZYTKu8CGyXK2ITcWwWjFRUMkFWo8YFUEkauMpigZXaUS0mM0sH5NJEMMJ6Jpz40DdNNxYdJza3aZSNSEViHLC4ANd1xLDiJQF2ki6oUWpkmq2hRIWqfMCOQpFtt6sP3PKQKqIykiB9EWc6ZIyaSzl+3QmykuRYdshAx9M0xBFwrmA0RpnHVHCYD3tKkfpoAwkgRtGonWomNF/ox2hUCzbkelOQ2VKQt8ztEuUH6jkwKmdhhLNzes9cyuoisTGTuDc2QkuCVpv6ceAtStSpRD1lKEbsg88qez8KUqWfZaZ1EUWhg/WgzTZGqhkhm6ENeEiBoJ9ruimlJdMKQTs6ImStWzJ5/idlHA+kGJApkSjNUlpPJIULKYomCrNRM1YtB1CeHQV2N4TmLqkv1niYmTVt5SryGYxw9RnqDZ32E3b7BU1UljmVOw0mmklWAyaeruC0Wc3jQVl8jwuVA2lEtiFIemCwkQ6nzW3TalJ0eGDxaZEIWW2OMs1kitFUgKtCoaxRegIX8DTFYDWmSOQSHmWDQTvMzwkCZJzJKVRKiBCwCZBoWuE8AiZ3UwpgQseKwIqeiKOAcmOjkwmVUaEBgUyrJefEk/ExpBjcRD0SWCQbJvEtFAsu47RKMYxkJZLvA+s5gPWJlJwGVeYErFSzLQmBovSBlEUz/KHY4IkzPq5T/kZEGtnpEjE+BywOsaQsZvrMVxKmS+RnWWBkHJ6iEBCkZfPMYCREiMMSXeMnUUqSWU0xguSG0nJEkVFEIHgB5IQqIlELhzd6Njd0zRCkrxn4S39SjAMkZPFimU3MoyZnasKlQtpm2jqCc4PpN6iqwKpDNblKCUfYsZYSkW0gXHoKWu9hgH59S3XMVpBcJCqzPF4ZuSUtdMObRQiOqTKlDXvHN4ORBfRk5ogPLbriCngg8M7icQ9m1yCLLFuZGt7kxhahEhMdmt06qjLJRNdIUSLtx4dCwpTo2ca3x0hussoN2F+0GHKiPcDk9RSpmOaEJhqg5iVUM4QaLphQAuDsx6XMtI0qMwGF1EyrSbIokIVYINcG4lYYwrEGpGpEEJna/AXq+gmMg3Kek8KHi3JMHAyNUuaAmLEDmMuXlIw9B1CGdpFy6rrQBVUpsyzNmsJdkSlhB07ol2xWPWIqGlE4nQ14+rBIaP1OX+sO2ajhNgljo9bqGZMdcWFsw3KCLoFtO0h1w6P2S5KOt+j5RahW+YsKGVwKRFsYNk5Zk1FIGdZ9T4gdElUBUPwmLVTTqxpUM8U22dKTXyGE1iYtbdeEwZLWWqCFAyjhWiRMaBNgTAlEfB+oDKKaT1FiBphHUZqUJ5qAlvGEUJB1zvGsef4+gK/WGK2Ks5eOM9pLanMjFhXSFWhB4c/cRwdR5xssFGihMKF4jmaWqFQuiQhSKakrODkeIEqmyzZkpKkdMadrN1wSgqEVqRCE6KnMgaZxoxU/IJnKoYssBEyrbXOGQRkfXZph5RQInMKtIrZ4YfOkBsRkSFgU8LFDPNRSmOKEmtXSBWwMeZtMoYNJdkomwxgEWSgkcrXWaSmTY6x7Tl3agbWYkSPLsCmfMgMjETfE6OnX6xQMVJPJ7iQ+xZTpGdhRypl+IsUmSUgQoaMp+TXtm6AmFnL65fRcj3HzLKj5AJaVdkcEHL2X/J5tptiTlcxItPVdExEJRj7gagLStMQOocIEVEWeB+hj+gkiGNAFgUyKsYgWbRQVor+RBKPPftHI0PoOVl29KNlsD2RETHZwidJchIpLFIZ2n7MhpQQEeOQExdEyokWxiBE5iyHmOWQkmzzJbns2oz5M2dmSH4wrPUMg6UIAiEDqsgjKh0TNka0Kog+krQgWktZKqTPLjZdAEqsEYqJoqzZ2JoS7YSmkciqx4/ZbNHMNK5tUTpSVZvUVSSVhn4IjDc+T7FxO93hARu3neXkxtM4oWlPLqN9TVwumTS7pHqT4EXOZCwEMiVkiozBk5oZwg2EsUfrIo9EFSj/DIBQrgluWekS19TBmL6INmCUxvqEdQNCRoj5tJcqR8oIpQijzREfWuCdYwwe5WG1nDOOPaaSRDfkDkclkgiMtse1R4hhzs0ucmpzh6n10A5cvb5PKKZ0Xct2YQid5XAVmI89ZyYb7Ew3KeuKBx6+TBIGv7jJI5eO+Jqv+ioWh5cZuwitResJwhQMLlsEBxeYzgps1KTkMttVF4iyYuzb3OmwpuOtUwyU1s/U3BwIKKCuGrx3pDAiZJ65iZiLiUgBsdbuEsKzkjOpNFEoBh8xG1PC6OhYcTyUlGnk1Iak1dAiWB1arj+9pNqq4bBm9+IFzPZtNLfsEfvAwTXH4obnqSeXiBr6uqasBXjJOCrqaX4QTtqAbT26KbExMtpEU00QKa5dc7mYigxmRYSYkXxarFMMBEVREpLK2MD1y7kR5zL/Vck1+Dl5kspCOqJHlhPwNmthdYVglbF5Mi9OegupmFBvzijKElMW+FET4siqd3gfKOpZzlejoPQK7yK1ESAlyzWgWGmNayM+CUbnqQrNlZMj+iFwEGC+OESaQGh7pB+pjMLgCUHigMIY4uDyYSXVGnafnr3ZOOdJIS+yRMo3mfQFI6dCZeaGlEWG91iXe7+UWQ9CZASmFhmGbseRqsgYSuE83uUUDmsD0iXkOECsiTGDVSotqCqDcwnXBWhmbO5V9G2HCYHl4IhK0uqBLg70jHjlsbJnHFfoTlFSUZmablxijKCeNviQaPuR7VnNOPRkGEceuRhtiIR1l5vB5Ubn8VItJCnmpA+jZV5Qk7s/QiDgSRq8V/gIRSOwaMqyIQVHqQ1e9MyaCuk0pVH51iTJIw5hEcJB7MDOkbt7DOMJOhgO5pbdqcSNLZMi0swUxTSRUkGyZ3BHJ1RbM7a2RpLTrJY9y2qHbn+fWg4URJTQFJNT2a6MRsuK3g3oIjIp82zWhJzFuEoCo/J4qJSa3nm8iHmsktYcD+/XJqgv9ET/A4tuTILBWqz3FIUm+kgMNucjGZOXJEBZl6yGAWUixgj6xQrve1K0RG8YbcekLtloamyynJzsE7oFOjhGb5ntnUXZllW35HB5RL3hSP6EDVNx7eo+nz/wGBc4M72AinMe//wBn3noKrKcsec6litLKAza9xzPW9JKU9QJ2Qhs29KPDjnZoHWBmVa44AkeylISEAy9pxQBXYi16Fusr8FrolRKiOgIKTMmtMgxPTHCGBKB7CgiRIQKJAXedplbKw0ezTAGhCiRZeTa0TEptuj6DmbTCtvtY4Nk0zQ02nN1ecJ48gT7T6/Y27iNOnVMxYKF7UnTW5gvHSth2JpmnvGAoOsiYw8bladbBRad4qRX6JjohhFn19g9mTsyEVrKSiNEwTAEVHL5EI0WJTzWjfm0EVm3+MwrhCyJ01KvJzECokSEQBSCgoBLgkIKfNIwjtlwIiSrcSC5FqHKLJPSJbquqYvEQmtOllehnLLT3E3vO+pyjxurgDGayaRmUhW0IbFyHpMEe0XF1o5iOTi61rJVJvYPj7i5P3Lt4JDV8UClPMP8iFqXlFWJjiNlWWNkpO0iUkOpBW0qSGmkC4Zp8CSRid6CtQEiZi16dF8wXgiR5HPatSSuXUwJQQZsC5FB4aU2SAIxSTqfaAIYofItaLPB6IrQj0gV88hHSCops0075eeTiWHjti0mk4ARmuXKshiXuElBXUdk03BzIfOSWgSCzOogG09QOmE2a5RKnDm7R/CK+fyQrck2xzEy+AFizLcIrTMoXIpsl7YjRjc5DFaXKF1kFGkMz0w4kSKScLgY8rwzJBAaKUuIigSYqmE2y+EA2miKqlirhDQieZQcKWTk8HjJmdMT7OY2J2NLNd2htyuOjwJnOs/utkIcHSLcAaaUCD1DskEaTiFNwKQl9qSHlaUnkhYDxazAJMXxjRO24iFJFiQqjGqoTE2MCWNgZ0MzWElRTLg5BMqypp13SCEpMXkk4u2zjIhgHd6P8MXk6eJ6rFC4dZKtWPMBjJRUZf7ShXXoXPADZVGwTJahn2NEQNYl+BYhIkpDIQPJz3Hdgq7vqWRkUwsa73jy+j5nmgpTByZxyUIW7B8vEP4KU7XNS+69i9N37fGnf/g+2tXAq+/5ev72oU8g08hmDctrlwkn11GFQcQJQow4HxnaA0YXmGxtYnTmmC7aOUW1iVKStmtpuw49LTEm/2Dz5jp3U8+8pEgZOTcOGXYm8/XK9gO6UARZZSi3zJlSyghgRvQxu7ikok6Kzgdm2+dw7U1iXCLqsyyvnTB/SuCCxnaKq8cjTy9a6knBlU/O+Y6zj3CljTw0LTl/cZuP70+4MdlDb0naEY4PE95pygrGITKxI1VVkpTAY/ApMfZz7GTGZGJwQaOiRkdPEKxD/SQhGZKKCBHBeoSsGLoOr55TL8goiaPFqzyfzYasgBaS3kKUkboEo4ocB2R7nCyZ9wuMdWxMJ4xC55kjgsPFEX932DGd7HBq+3Ze9dJ72Z3s8NlP/wGpfQ1n7rnIHbMpRuXfyf4IUmSFwCoFnj8rsaOHo8TN9grj4lGWNyP2MKGYINRI1FNu9i2jVJyazSilRcZjJmJKEJGuC6RC5OikODA6iREOrYo8w4s+KzZCLqn5lbDOI+kJY+YjV0WJUgVSFrQ+J/MKmWNwrI/4KJjOJow+MrYt8/mC7anBjRZcz6KVGALTW/YomLJ8suX4pKXe2WDjJdvUE0NSEnN+C/c5QXW4w+L6Medmr0Ge8ezrA8b6LNAz+GtoLWG8jOsa9JkLbE0sZVGyHFcUWnHSd5iyQhZpjUqtqac1CMfQt/joSAra1QKztYV1uVsNKRLGvGCE3PkqJXPahIYgPVEoOudQQFNWJPyzaSZd16PrKVLVqGJCvncsKJRgshUIOnLX3S/lsStPUcXHOPAa60+49Ljl7CvO0ExqCnGAcDdJHnRxmtmtO9iYiHubrK7Nmc7gRV/9ev74l9/J7gaUQtMYRRhvEuodpAr4sEQaCGfXZwAAIABJREFUjXeRWDS49gSlSvxgkTZSNZJVGrIEUAlc9FiRcoR7zAUxiUTSfz9L2t+v6ELWrcoc1SfXCwVSlg0VxuQl2uoQvMIFy9gumJSCMpScLOc5+2xaU2iL9EsKOVJpGMVIFRK3z3Y56Pco/RXk9nnuPLvD/ic/yu3Pu4Ph4Bpv+trHOF9+F/f/1Wt514c/hXc133rL7fzO+/+UWbXLI/4aL7/7PmK1iWwusHz6GqdP1QzDyOAdvXWMUbBVahI9Nw+XNJVBJs9qyF/eSZmDAGXKEAu0wcfwrE5XkLJGtDI457DBoHyiKCVKxcwJDgECWKEyjFkkuq4jDJG9M6doNjYoxg5hd6napzna3aMyV7n+xIOcmpxh8+JpDrpdHrnc8nerfVI8ZOaW3Hr051z/1H/LleK9/OD/9hYe/dxnePf7HQd3fS2TyZTVUnB8yTPZkGzcUqCdR5kSu3TYRcRPWkY10Gg47FpSktSFwFMgU6Ig0BRZk620J7mEoMS6FUp2KJkQ/rlOVwuBjA4fJMIIpDEIldMX/JA3vt04ZIRnpTEGjo8PUdGiy0TrEkoOaOmZH3QcD9BsnmVj1nDxgmZn9zyhfZJ3fmiLN79pyba7AdQ00tAmwZ9+fuT3Hne88NaCH3xRwZYWeCWJt834wEcUf/34b/LVX/lTPPm797PdrEDt0cld5oNjjAPIyNkaJlunCUGhYgKR6MeeIebDoO09tQl422Wjj4xZmyn0mmubnwpjFNYHnHUoUzARmqIw9K5HCp+jvr1HSEt0EesVehCYItKIyMQYJvUEUWpcUuhB0y06Ln1mn9niGuYExPR22D3N4X5FfdRw8qHA9ExLc9+Us3cHDp9wXH/iOgt9ic9e+yBu5wXcefrLuPfiCxlly6OXlwzzJe7qVcZNRSdheXCVQs0oDJimwo+aslR4P3JyMqBLnW9pAgpdYccOoQ2FytJCFzwm433zM6ECdREJACJhjGEMjtXqhLIQjBZkHFm4gqpRxNSwWLZE0aLVnKgdpu6gdHTLOavlFab3vILgI09P7mTv9hfxTl3xY3dvU7SXqc7fSr3zjUhxmXjyLqItUbvfj5J3Uuy/h4+9+5eZbF7EfeoqBwFO3XMr+njOIAI2SpxygEMhMFFz0I5snD5FOFlwdHiNjekm3RBQKhBHm009PjDGnMqhhMgGHQ1RfoGc/4tRdEcPus7gFyOzfzymkKNryG/EDZZSFogJxCioG00pKm4MS4pCUOgSJR3Jd7TO0i0dvbeQEucv3sHzv/r7ufTpd/LKN/wQL/3STX73Iyf84Fe8gJ/5fy/zvPtewsu+/q1MnriLz+trTKvTLE7u5dKlv+NKv+AFk9fydZsdy0nilpng8EgyLTfYO7XJzX6FE1PqyQ7GWnCJ5dgS+iWeDbywePIMtmzKrFgIeeNKEgTr8WvLp5CSsjIM8yVlPUGRWJxknKMNCSNVXpIUEu9H+t4itKDEEQtN37c8dukK953ZpdmuGG52bN12jvbwEoW7wUtf8UoWjz3Oo+/9GE89XpI4jxWRUmh2+qs8dv/b+X13Gz/yT97J//4fvwwe+FV2xItRix55Y4miQaYt5G6DumMTu4qs+mMuvvgCGxuC40c/y/bpAn3jGBMVZVIsvYc4UpcaDYx+JFUl0Y401YSuzZHoRVNTqefirkcRaX2WSKl1oohYGxfqOkfRL5ZLVKGxY+LEdxR6xjIUpCDYqBsWJwuevn6CbhLTjXPYMKVMko2dizz06Hs4Oe4YLn2YB594Pm+4761sG41c+/vve2HF/sWS7QHu1RkQL1XiTNXy6vu2+O3P3spnn36SMXX4WHNwc4U3mo2988juiGF5wlxtUbuS2WRKtHNGa9F6A+vypr0sa8AR4rAuJDorEETA88x4Id/wCqNZth11OWFMAjVYxm5Yqy8SEkch5Tp5QZO0ztzgYYlQmtaOrOYtokvI2KG3PdevnlCJHe68516Ki7cgT0XCZ1vSlZpyU3Pn82fcnILfh+lXzLgwH/jQH/wnri8/TdXscDA+hkpg1jAg1A5Df52x3ia1HU1ZwLjk5MjRLhVC5fFhIuMKYywQMlIUCqKnmTY55y8lkh0otcxxTc8cP9KTpH8W5p1ipCkkKniIliJZFral0hExCrp+wCaPidnk4aTFaIvaLJCF49EnrzDsJl562yv5wNUFu8U1tp9/B9PZ7Tz8797LPV/XUr3qHtz1p2j/4EGWD34K9zVPM3njr/C4uovk38it0+tce/R+qqPrbN7yZtz8L4nHc5hlznItNVYUBFWjyind/IDZ1hbVRHNw0rPXlMyHnqaWqLJm7LOTUK6bzpgSEUU/5JHdF63omqqiMjlpIESfA/aEISWB78c10tDRbE3ohyW+65k1E9r5AWPbszHVLBZLrHQUVWCIjlFENvYahtmUN3/3d/K23/sU9+2+iBe//LU8dPgBzm9c4M9+88M88eQj/Df/7P/kBS9+Of/hvb/E5+dX+a4v+Wr+7Qf/lm/4+f/I1X/yU3zvm+7lVT/4rVzZf5r9D3+Sy6vT1Ntb1OduQx8HGi3R45zl0Qk+gAuaZrLFSIEB3DAymzVMS8NxazHkqHcS66wus/56JUYC1aSkiA6fJNOJJhpF1UukIC/TTInWkcmYY38GD00tmM5Kpl7iF0sOuhWzTRiC56hveP5LvptLh4J7X/ZifvQNr+KhTzzOb/3Ge7j/oQ5vNWL7lfzhwe9jyn/J+df/Y578zjv4ym97Iw+5FU83DnmmYrghGY8izXZEbwfOaMltd+zxxNMtpVigNre5ef2A599zlsX1pwhuYMdAWm9lh+RphwG8YKZLfHQgsvOsMAXVF2DGCl1RmAx5ts4itULLfBOoqzIH/60WqGARKbu2djYTtZc0uuGmldywAYoZZXOObtS0y4798hYeeOfHuXr/L3HutT/Kt//ED/CG8zuEcczLCm34bZf4/TbhFom9ReJftJKfvjsvdITY4tEHrvHWT57jtRdu4W3Hl7h6tKCLK6Z7d7A4OSIMJ2zvnmZME45u7uOTpGTEo6jLErM6YYg5Jqr1awWHkOsMrJxIEZ69SQqMKulGSz2pMbIgucDKdfTWU5BjaGwIxGGEqPLYynl2d2uEnTJJPVevDUg/sikEcWIYT+aEMEVtWaq79ukxfPp9A/u64EKzy/GOZHrRIwmc+kHBl1nJe/4Cbjn1Oq7efIrltT/jBI+69Usw1WM4f4hgghyXLI9Gilgxne1y8dw55v0BnsRgA855JkZSGA+jR1UVxLzgsj4Q+hGVBBKPbCpULJ4dteQkYp/dbEJgx26N4pAEO7AQh/i6YQwdReuY1BMqmZeLjZFEkxiUI00UpaiweorqFCLsM24YXlC9ggfswwS5zZlv1jz+6zfA/xF7r1P4iyUHfzLw2K8+xPyp7+aBrYaXf8XdfOJ9n+TNLxj469+6Srl1kc/85RF3vkbS90dEUVJtTXMRjR31rKCMLdeXEh9anAs0sUO4gtaDiYpCg9EifyafcF6gtGFSgx3+fjPdv1dtbgqFVgmSzwkQSiEliGgRcWQdDYdPnqHtScCN/Ru0yxO88CxXA5gcY9N1kvk8cu144Kpr2HrJq/nZd7yHC298Bf/jL/8YzStusPv6H+L65xf8iX+C3/yTX+WFr/9qTqwi+cTBXmT2/a/nF//zO/naV+zxa+/+p3zF91WkBCcfGpCrLWTrOXPn7bRpA2EMhQFZTgnTLVrbYa1F1TNIFhN6plrkFAtVMgw9i+UCHyxS5XSFZ4htz1DGlFCIwhCSI8mCYdkymzV56x8GfN+RbEDICqoZgyo4Wowc7e/TusRJWuLEDfqjy+hrn+LgyhXaYp8rnONv7j/Lxx66g9ve8G38wjt+jv/y9l/j7hd9C3+w/BgXX/dDLOpf4P6P/yKj7/jI776blzxvTnzkwwT9GXxcUmwI9NnA8ZGj3Cm4ur/iRcpydgzsbBZsT87SjVPauMlR2sSbLaQuGYYBa3tqAyWWKBKLZYfSkqap6caO45PDZ+VzMVqSFiRZ4FLJ6EVe0oWIkYaZimxPJTFAUgqhE0O7wM3nHNy4Qd8uEeVmfh/zJWXdc+FCTfW5T7J38AR3XHg+3zR7ilft3c4g7uJ73/1BPvXUZzg52ucbvOVtm5IfUbDZR771DKxGy89+5OMsg+Blmxf4k+tv4vRLv4Tq5GO8Zqfk7rpAHV5nt6k4vbmNGedUekHoA/3xFY6Ojjg52Mf6OcF1tDFweJzHMD5kOlnnPH2S+Wpqv8Ac4eKzf5ZGIJUiCEMMkXk70lmPdxbvBnSRqEqIY4ef9wztnJurHq0jY+8ZheT6ydPMQ+DsmYvcdu42NmcTbsbP8Vc3/oyb+gw/d+Uy3/w1Nzh+8oiH//TdPDIYnvxPT/DQb/wK973+Nezcegv3bb+Ye2KHufZRzOo8N/Y3GbuRL7n7Ilv1DnfecQ+bGzt0QjNrtpE0iJidmmPwBKEo6iZnlKmaqpqBLDLDIqyJdEgGazOPlvVyloT3Iz72eOGw3jF4i5eC1q3oT65i3HWwCyaccH4Cu43h9Ibh9q0Zt22f5czeRe65+4V801d9F6+855XcevotfP2ps+yZs7zg+u+zLSfc/soLfJiax/t7Cctbaa3A3lLit+E//M4RH++/mfjBP+fLJzM+VkfedeIJ3f3MyYyY8/ecYXLhAk7tksxp5NYFip1bsRs7XLzzNBsX96i3auTOhNZ2UE4yHc4NWNcyup4hZFt5FBrnBhBfRPWCxGcBsHwG1i3XPnaBt89EcEtC14NzBBMJXcvmzgVC2RFXN9nc3cSully/cp2TfoBJw8aZbU4/705e8XX/lC9/ceCpJ/+KW3deTf9vfpW3P/gXfNdP/iuefGDkhRzinrjO8Sc/TzhlOPW8ivOfe5if+Zr/jh/8ubdy/KcPc0Of4b1/cZFX35t47Zc9n0fDQH8SOVkMiCoglceEll6sTylhSVLmDKg6z/COFx39mGfNWmt0obO7bn1vkEJQFblLiaYhOkddFCglcdYyxEizu4P0ebkShcTogtObklF0zFvLjeMVO+d28W3k8Noh9bLls5+7xs2nDjl354M88ug1Lv/fVxBINpsNnndxxu237yGuvYDzR5e4LF9M+cFLxJg4CgPf+fWWR9/3EFdufz3qnkO6MtKxzcbykIcfPs22TFwykrvPzFAHxzzv4jbX3JJmu8Z1GqmLHByperRS6BDw1pFSQjYNJSMpRKSKjF9wkg9eEFGoqqCQEIPKoYspoUXKyzTnEapAFxVCBw76Fpkizc4WRm1SjJKykLTBc7Racn7b8IpXvpad6chMbXBH+mu+5qvfh/N/zub2j1B8+T1s3FrzrocTDz90mYsbPS9L27z3fw3c++/Pwe0v5slLf8ytk4tcWPwLPnHzd7jrG36Mvv9z1JWamQ00OxXeVXRHA30/z4kZrmajmlGISGwdqagpvCc2AqEjpigRShO7jugCUWqUfA70koRCqKxM6LsBoswZemUNrs+6dBJICFbRGI0LlsE7hCzwzhP7kS4NTDHsmW3UdEYlt1i0e7z/L5/inY/+KR/tHuAbXvg6/uj/egX7H3D83aOR7/j1b+EzC8mZu27hZ/7ZT/J7b/sbXnjXm/m8up8biwVjv8ON4ysos4/oPTK+jnJr4PjoJhf37kSJBXqnAWNppqdyJiUBbQRlWaGEZnC5wOZcPFi7ZggiZ8Y9mw2WcrWAkDMJy4ax6ykLiy6mKCwbpUHTZw1sP1DPEtpGpvWESV0z1TVNPaGRis0NgRCnKYold5rTdEc/zIsf/TSJ70Pd+kPsn1zh+mf/CPvSl3Hzwov54LlPc62acPnPb1D+3C8ifuRbMC98mPmHd/jKyU3iyaOcuu+bEHufJBQKRYvAs5gL2n3J5um7uGk3mfgjlvU2S7GiLiZUmwHKklJVLJZdBrmTM+2CkJSlwinJ8PdDL/w9bcApZN0iApkcyYUMqyERUiBYhwoR7xP9uGTsYLK1g6okaTGg9AarTrJ/rWf/OEBRMFWG7nDkIx98lCg/yUte9wbu2DvNOx69yu/27+K//4l/xbX9lnu+9lYunK349T96OzfuPsPZf/TDfPj4ab7Gf5RHTn8d7QOX+en//Af82M/9MXd+8CNUF17JpflnOfGga49UoNyISQNBJxzFGrtoECQCliGB6lYIBU2ZtYdlUyGEIgwdrOOWQ0y0vaOUgbBaMAZHgcT2K7QyVHUJISB0gapqCIFCxkwtE2dYLa9z11QzDYIHTvbZvfUWHrmxoJwK2nYgbL+As//oywiPSFYPn4BccG3jLuYn74O9WyC8n2951Q/wb375x6nJoJeNye1osYn7y5JTP3IbcXrE8uQm577uAsuPPUk1ndD2jhtSMT2TuHI9IsaW3c2K1lu0tDB6mjKPUJZtR4yKujIomeiXWY0SosuOwvUrJkHygUSXITJJYH1CpRwqKr0jJpNdb94gVcVWpZhbzxA1SgRk9PjDE6yLbFy8iOhHbvqn2dyZ8L6Hf4M3br2SF557BPHWA374DXv87Ubir0+WfO7aYzS3bPCJruTBjz7GN/5XL+Xd11e8/a8TP/Cmr6V7ZM7pc8c8v/k1Jvf+Y979WzdozSkmm5tEL7FBYJpN5DAn0aEKRzeuELoEDLUciApSVaMQuJTyF01lu6w2Blk8V3RtXJO5IBsuokAog0kKVUfGaHMwqFCMcaBfemSMLNueSRDE/RNuv3gnpo6YyYTlwdNcufE057ZaDpebPHb5cU5Wl7m7nvCyVcv7f/JvCF8xo/uSi7z/Ld/NW97xdn62fIziz+/hsc/ez2PXrzKaPXZOnefMTPCl53e41L2Jyx97B6e2z8BwBarbWC4XJHGCXTh0k5eDShTUZQMKBh+RwWdWdCNBRFKq10wKifOBUj8307VRYMnJ3aONlNJR1wl0YlLD2HekVKGCpR16JsZhvGJsl7SxAhp0XdOJFTev3UBUltM7mkceeoz3fPDj3PrACfe8NvCO9wm+93t+nm8vWlRr+Ogf/h3pmuMt5yc88KI93vcXN3n8qX1+9/95L7/5mxN+4n9+gp3Xnuenf+WA+153QOkl4onHORYNQ3EW7yYMEfqDp1jYhjg9xZOXD0lOsnAZwDNh5BCPG0dAI4TBR01UCuWzTDLK51RO/+Ci23ZdjoEWJpsitMKFgLU5Rn20nugTbd8Tk6CZTVlZzWrVo5JCaMlRa1kJidhsmDWKjarm4Djhb1znZa99AQ+7JZfsigf/5tfZefAy0x+/ldXlz9Ee/zY3F+f42IM3md71Yi7sjPzV37yPs+Z93FXdxVt+/m/YuPhS5qdLPiQScz/nOFakxT79/iFNLdk6NWEQiVU7QlkgYmQcLT44lAKVcpKuxlI3FT4l3LjWLEafpVMAJKL3WOGxNlAUmqOjOXbs2KgVVV2xOj5CF806OVnglGEVJGOfqLfPUg0Tol9w/pSmKwNmtWBxeIJodkjyiD3O88ZveQHpe2b87YeepP67j/Kgt7zijsQnP6v4yP3/nvZE8wtvhP/h/Z7T2nDmzCkee/ox3lDdxthYPnFwxOb2XazKmn7xOW45XaBWAyFamtkOqdGsTm4QrUVuTHDeYEnICErXVAq0jBgDUSW0EWgqnHzuSh2DIyGIMQNvnB8JIVLqAikrtFTYkKNfimGFrCf4ztGzwZYuGUbPolO4OIHhmMMnnqQ8t8ETY+ATn34EEZ/ks5uC7/z22ynPvYV3fCJyff9BnhcMT+x7bPgAYd9z5eT5/HH9Xzh6xxH/9kffyve+/QP8L9/4HfzAW7+bf/3P7+cbv+0+ntiX1PIpTs3uZSw0x8c38YMjTaYUbo7rBVVVYe2SUhu0VvTWkvC5Ow2OlGI2lKR8xRzHfv1EgIs5vFEVBlQgxaz0IQa0gj7lZRpCILwkREGharQf0bpiMC3Hbs4kWo73W+bjCbHyfPj6JcRyhzrOMWbOQjvqjQdZfen38Z4PfB738ke48vWv4q4//nfsXns5l68+xaMf/yR3v+Q+5sVlhlZzspyw+OQfo4s72aw8Dzz2Ae59/su4enCZQW+iRaRuEquVY3u7pjAyw9plVqeMfsxkuA6igrKZQJK5mTEqg3ue686QKq5NNgEjBWWRwTeJSOEDQo+ZXRAkQ0wsuxYns42aLqBtRyEEUQbwN9BhxfF4jTd82YTwsoELd1t+6ldHvv4rtrhxTnH/Z1pe/ubEa75K8tQHJXJo+D/+5Zfzvf/13/L04T7VmX/O807+JT/0assvvfMSr77rPJceHdjYqDhzdpd5bzi5eUyVIkTD/uE1ZPE8bHvEQMFmKpm7RDnNQChlFEYYUBUKBRKMFAyD/P/p2P/BRRepkKw1qnrNvhwGun4ABG4cGNqBjc0CKyt0PcN2K+wYGGLE9T3zRUfRFJhGg1e0YYteOWx3yGO25U2TQ953uWX5rt/lzI//GN2VxGu+/HmsLv0t51/ypahqkzmBe85pXnB1yrX3Ct72oXexuud7uP2lH+R/etuvEu7+SoZ+Trh+gx3dge2Ybp7Ca81qiIRo2K1LPIF+WDK0S8rtGa5fUjYFymQZSEwRoifFkCOhn6EoScGkkWumg0NWMxAwmTSM/SoLynWB0YbgLVF4dFkjhaaIjuPWcdQesHHrRVIaOXp0TjoeUdGhi5Z46VNcOv4Uj/8l1P8fa28erNmZ1/d9nvWc8253v70varVGS0szQtIsmmFmwCwmEGoMDGAoFscZHDtFTExcjhPHqVRcGCdUqqBSEAyOMWXM4hjCIBgPg5l9l2Y0GqnVklrqvfv23e+7ne3Z8se5kuZPqjK3qv/o6q7uqvc95znn+T3f7+ezPiAcv4feg/dQfPYUX73+GhPOsLb4Oe6PT/J/v/ApvrX/nSyxRHD3IMUtnpcl8tScYz3HmXKHy9e+zNl3voVZO8fME7vXbnPqpGOOp60mZMIyOdgmdZIycp0wRdesMzpDa4HOIAiQ3lHIN9OpmT5UcktDjI4Yu+qqlgHd+Q2QwqOjJ+V9REi0IjFQczLXIINB9geMsx6N1vhqj2vbFXubV7hy+Qaxus3k1D75555nKiT7q8dZXIp85tUv0WiPzQsou+/q8p8/gl56F7/x2etc/MSrvLR+jVuXd7nZP4MdwCOnR4RKkcp9UlXRQ1IJSVvOWBkMEUpwMJ1xZNRjMh5T9DNGCwvUpSPSQdVT7MoPnbYldrQs6GDlTYUwBQnZVaCjQ6LxISCTQJoMKRQhiQ7yLqB2Hk3CBcFwZZUjx4+zeeUasapw2RL7+3sUaYBLFbFtOGYfIuaWP9xomI5+lY3Jy5x9JfDUlxqef8c6e3/5J0TW2d59hlc/8ywxVRTDNUa9VYpmyprfYmG4RhOnuP0tok8IVWFHA4ZDjasrGh+wSpNcp+RSMh6S9Q6bpxKU6ISpWZbR+jmu6rRXAEoZrDSdcUF2+EcZFTE4bCFweAbGUMgeba3JU4UgR+oBtW+p4xylQKcKO1Dcunads0+e455j9zLIPk2x8NOM7LP80q+/h635Uxz74Xt48nOS+d0dnt2/Toq3qRan3Fp7iB/84AJf+LOK67OnuXb6GMEJbm7UjC9dZGe2SjWvWen10f0Rw4GlbiQVgoISlbckbRCiR0vADHoobZAxQmE7Cpy15LqDAZESo75irr6JM910aDSVomNpBhI+eLzr2liuDR38RhYIleE8VPMWoxKla/BSg+mhTdb1+lUfZ9aRumJVHfCyK/lgWuapf/E7vPuxMX/7uz7A//Urv8JP/tA7ueeR9/Dbv/tn3JA7nHrbk9itMfaLF/ntj7zIjf2MFeu5+OW7TLO3sXZe80qVWGznpDhlfW0JObBUwXUM1cMWTetbmnndUUdigxFtx4CNOSHTtE2FxKGs6YwIr7ePUsJ7j5CKzHpUrFAyMuwNGLsMoTK8TuTZENoGEWtypbAq0VpJNXPYtaOkQY7fzzl+yrIzDZxdOsKVq9cpH6oYz8ZsvLiJfsVhl59nNDrKA/MZadTjie0tdhdXeXX2MmVl+P1f+4f85f+r2b78Kg9/+2n0vXO2CsOJ9QucMYrB0SUunF/j6oaj39NUu5JaaXRUSJN3EJMI0nXfnzceLTudkUvdabRUiizXNLMOlPPGs/ywQoyQpNCFxKNUHRLRN0hBl35QCmNzaEvwXbrDa4EdFITUwtzhoqcsPckJGrfIdL5GmK1y+eZNjjz0AVwF47v/gWbn7TTze6jGHyPUlzBRIeQa5c0N1NopvjB7klH/NH/w25/l7ffmvH95m8tf/vfsHGgCJ7A6gA1IrRE+kpykiT1cu40WAnyJzg0yNrhqRvKdHcW36VBI2N0DSslDvvDhjwhIBSk6rFB4Iwi+pnUJWt9hHzsVHMYYFArnG3RWoKMhhIbZPDCPmoODfXxvCWcmtLM55/WIk0dPoHsrxELw0ZufJ792wI0bX2K8Jdmcwc5Wj7Cxg1IFMVWE1iFIZLOKabZNHmEqS/rVBqdOnGB2sIXKczKdsGpE7SMqxM6WLBTeNYTWd0QwIZFWoa0mJN+BYFLAuUTbNm9UgOGwBowmxZYUHG0IiMzS+kThY4dE1eB9jlWewi6gpWZee8q2AdHg24p2eoDutWxNZ3zty9dYPjXh5KPvYWP+HCeW/2vOvhWKyVGO9p5nefU+6oM1ZDtmOrvNTnaLb7v3e/nuf/Qk3//dT6HnH+Bn/8l3cuLYc/yD06usjQRDfZuNnS02XQEzhaj7NFGTFvvMdw8YxZqQ5+RZjmocNkiQFu9qellGUBBEQARHDBIpNJlVlPU3kTKWREfTEUrSet8tuqmDYUgUNstxMdEEgRGiO5mtSmQ/wwmJMkNM3iLzAb1Bn4hinixnzg64Rx/ls888z0fn5zg+WGI8X+CRxSWO2xfQ7fsYHD3JM88+w8Lj38LR42/h2YtXuHj1OS5u7pKd/gDtax+n7T8COgpnAAAgAElEQVTMhVPLXL1VEnqB3E/wA4VdyFGmC70bJMa3JN/dTIqEyg2ZjEghDoHj0LQ13js0HmVMp78+vLBiitRtQwyBTKrDiyvR1DVSa0LweO/xsetnR7ptpQqBEBK9ocWuLtFEKNQaYqBZP5excswyH5zj/GM3WOuNeez0Gba3Wz7zmZeZ3rwFOVSjReT+LlvzFW7XE375l3+Jj46P89IXG5rxF3jogYpd+63I5hRmsEQ0De94/D5G/YJBrhmIGenMGiFbhdmMmBzGNRhZ4GrXSRpTfKOeiRBoFL6doQRkhWbumjeuiZAiAY8Soqu9CgnBkwj45BAYfJJElTCFxc3mxCRoG0lMYGRARYcNjkxWzNsS2VhiMCS3TfC7zMJ3ILZfRen30swvMZ18nBT7hNCgqprU3sKlmzh5kzQZ0my9SFwMvFYssZqvslp9kmnvAtkxxXQKug70LaAVOusjM8XMN1A5dJGzN69QhUAJAa4huNA5sFSGVPrQJNHltUN4U9cjlECKgHMOKy2ZlbR1S0qBpqnxLnaaJ2u6w9um4w9jHbU0MK+Yzq4TY8OBbAhuStIRyZRVqzh37By7ZoWLN77Ehv861asV1WyK6y2R4oT2xphsfQTzElF7lLGkFPFNRWpbEIbCCqBkY3+ALySj1UWGxQBiBRgKATo2qOBxzuESWGnQSiGsRgiBRkJosFp29fAQMCZ/05OWIuJQ4xUBowRBBFxMJKGoomVWRvAtWYpELMF1hmgthyRGEKaI0GAQrA2X8XVgvrVN0h9gZ/83+Xcvf44Hqh2aUwtUvduo8gAlMsxKRuh54p3LzO98mc9ePcKHvn+br3ztE6ycOUtY2+bx9SlitoYPnq254GA2pWwFxg1RKiclQ5Wv0LSQtCKGBpEEQRpcFNSNR+Dwh0g9pVXnUEN0qFH/TRwvCCE7wn/owL1J0jFilcEog9CGhi7NkBFw9RzvGrJsiaynAIMgMlhcQtmCaTlHiZKFBUvsL3P3Tz/Hh5/5Gj/z0+/i138+4KsDjp1SzAb3cPPKJ5m5Td526l6MV3z5mad58eVXEaJApSn5ZJPllXdztOd55dqEQbbB8EifpSXLaJDRU4JIRFkJbSL5upvbLRQgPbn2OG+AjqoU27qLxtFVOuWhP6n7HECrRO0cUXantlIJfPL4BKH2yBSIoSImjwstVelJSuAiyDzRtmOUGDFYGDIuHadW7iMNSt73zjWOHl8mT/cwOmg5OHvA2smjfOnVCVefu44OGePl+zn18Ar/5X2Pkz/xt3jqH1/je6afYGe0zXZIrDcj3rY6YKVfstOMuef4gM3pHJ0XyHaPfGCoQ6R0E6SMFFZ1RlXdbZFiFKA65KLSUChN1WQIFFJKMvsmaSzF0MkoERipQKvuII0OEZhwSG2JsSUmaJIhCY/zCd/W5FqTgqdwM5aUY64d01mNjwXL+RV2swnSTtl++SOo4QLGT3H1Pq56GmEWUEKR0Pg0JYYpVIoUtpjMM+y5c1x+9STbw+MEHzl9NEeYRNM0pLlFH/b9pdE00wlaGFqvsMqQo/AxdDSxw8p79rp2h05fE0LEuze3klKqQwhOgKyzicQYIXk6qvJh7FBKklb4usNmGiXZr2fE1jHe3cBkCrFoqaYtbeOZ1Xs8E3bYzNepzVFe3J1wPZ+SzJClgWZmbcdWDwqRoL+6TKwcImi8bIltQleCAZFlJIIRrqzR/Q6qr1wkxgYvI1ZJpCtJSELoAv/QQZqkEgTvOwZEbJEiI/oO9G+seWPRFQQk3RmIkJ2wMSmJcE1H7VM503lLXzi0VIQGRG7o60X6wuAC1Mailg39oSe1uyysSgIln/jKbcbzU7z00qe5cLbixWcKWB+S9l9GVRNUP6duFXrfcfr+D/Ov/uUaP/Jk4rd+7/d47K89wVf+4jqhP+f8mWNce1Hj8hGzXFDFFhsTVkScyEmioKoChUq0szlOD4hRkZQnREfrBM5LIuGQa68RSaBM3gUOvlmLroyJmGJnC4idFtkaje4XCLoDkyxTHVOUSOMTSWoGowUcDuemJJsxGPQ5mDtm5YxMebY3plxfHjD92gtc7yXe9ovfx7UrB/j5HfKldeJyn4/8wZ8zO3eG7Oxptm68wJ1nvgTXfceLnT3H8tGzmPkd2vhW3vv+NUL8Igsnv51TuafvFDo4gg+EqPDa4KtEP5N4VRDaMZLUbQMFKBzQvfGKw5iYkhJzKJwTCDLTRaPioUSwN8i7f2NaYrXoBIevc3adwDeOYCRV25JJR1kJ8oFGWUEIicVihTIaTqZrTG+t0KseJisnHM23+Na3n6d3oWB65gbF0aP0Ros8+PYjvGP4Pn7i125zf1zj6MH/w/Dtb+fy/rdwZG+Lb783cqS3wvOxRDiJcjNsoahrS3I1vh5Tljskn5HlOfOmRIlIDJ4UElF3LFHcIdLTZCAUvp53hPzDH0WnCE9JYKwEJXGiW5RTiCATxmp8Ba72VJVDR4cPEH1D7Sw6tORtjSCQ6ZaD5GiaQK9wHLCAqP4cYR8lVM8i3EW0eQciG+Hr6zSHBH8pJDF1s2YpWyJ7zCZTZnoTuXABV73I0uwJ1hf7lCFR1hGRHFneXfyh9USRoYShnxus7szWHX3NkOLrmhzxRmLD+0B43e7c3XY4H4ihGyMkH4lJdFVRYw7Rh91rshAdOtML0FlOu3eHKggm9QTpFMtrK9ieZTp3bEfLywcbMPkyywNJriG0Fl2MKEaWyf4USSSmLi1ieyexSx67VzJPCWs1I2mRbU0vtvSRtCJxYjgkCEW5X7GwtkQ9myKHAwjdG25IujNlCNElFkLEp0RmbCfJTBBjxGQZ2ug3Fl0lQItAEl26SR3eP0F6knMMraaeB6QMBKGhdcg8oFMPmcCkGqkCQhnyqEnJ4oOnHQee+fR/4lq1wH1ZyeWVktuf87SnBsjhEuGGoseQdjBkd2vOe969TvXiV2jch3j66f+dx9/1MNeenfLS+lE4Kvjk1YKz53tYVRKRmFwzm1eE+RwVoWo8/WFO9BVtMUS7GpkSmQ5YnUihKwRBRGpLil1GnW9gLP//XnS9CwgpCCh89CgBRltQnabEH+pXXNvQxkjSBcVI0y8ss3nZyeJ0vwNZz3aI0x1cPedgNsWfeAtabUFxGh/v7ZxO7SUe7a+QqPiV67DygZ+iOHuCi0/9KdPLr6GXVmjHL8PykDjsoZoZw2OrfOjnH+HzH/4I7XLGOTNgvD3GlTW57tQ10yRQhWKQKeahY9x6rTpiEBKrBa00aAFaS6QxnUL7cLyQEjgviEIjYkARyG33FtDLBSObg7XMfUJGATEhDg+U6vIAq5Yw2YjcNdTTRC0L8myKUZ6vfv1VlL3EtvGsH7ufZr7E1qcnXHj0HO/90QtIOWJ+dIC+E/jEbzSc+cJNjr8TnorHGTz0w6xu3uXy7Ve4dOFh3rF6H+tmwMX9CSeWB7xcz9kyimJ5gUxWhIlkd+xopMX0e2Qp0YQZbVsfEtK6IsjrcJbuTaclim+4XGQ6/NwUIcXDub86BJqkjtSdIklIRHS4etoR1vKMJkXaqsSq2J3y+4iVkVwH2skdxrMpYXqGwA6i/17C5F+RaYFrbpDnBs8Crp2jEAgxgFAjUsS6faIX6GbAsDfjzt5zLK4uM1g+Sj8b0rSG2FYkAviOpCYCJJ0xHBUEP2NSefKsR5TycJYggI6L6114E+n3ZiUNLRKRSO0dTeOxUnWVaKUxURL9IRM/QXCB4FPnsQstvo1dQiAzZNowmzQsrCwyd0NOxNMs9dbZGL/A3eb3yXo5em6Ybr2EGCmELyFCCJ7B2hJGdgbevNCwL1lIDScKjRcDyuoua+xyKx1jxfbAaO7MtsntOjFAJiI1dD4waciyDK0NMXVVfXXox5NJkJIC/CEZDF6HIL2BeoySGDtTiYweGz3Ktyi6XWEbDEoJDBVtOycQOm+c9BTCI+o5tJKkBHvXtphcus3b9hx/8vltZsuBF//C8pZpYrZacewdZ5hc68YcJx87zdO3PsHtnf+cvrrJ5v6DPPZ9x0njd/FtP55orybe9oBhz61i5RbTrasIPSJbWUfKGX46R9hIqD31XCCCRkdJZlrastsZatmJaQ0dR1lo2b20efcNKadvwqIbk0KmQ9ymhNwItOhyerULtK4ltxnRNfioKYock2XkOEys8Qb6hYHmAOabyHpGRmQ22WV692OsnOiRX1jh2S9dYjVfZu/Kn3KyPuDi7U/zyPsF33JmRHz2q7QXv4qYXqOdXO3YtDdvszmTHH/yMY4/0NCOnyM6z3G7hfY9mukOSkSkyRHIruwgIiEGFI4QA2VjCB6k9DReHm6XIsbYjtPatojgv+GzSAQX0DEirKKqK5AWITOEkiTRdjbTFpQWSKOxRjKUIwpbEEzOIBOMigVmG1vEVDKuai7fPOCJ953goftv8OmP/TuG+lE++IMf4OMffok/+/prHLxyi/+4fD+PHJxnf+uH+affvcB/+8X/wA/91E+z+9ItQv9FXhs+wvXyrbwyt5zWmjUVmavEqs0wfUeZHHbgYf0oqdei2xrlEz2dd+kUpdAy0oQWpRQ6RETb4lMDdQ1av35/4R2kmPAxkBqHVoKisIRW4HyncRHOY013FmCswASH0xbhW5JPuBSphSBmiwxGS1y5/XVMIRDjEdaeQGRQ7v0LTPEIJxcVNzcvkdwMrZdQaolMBrRQzEqPTC3rWuGtAj/nxt2apfPfynDvLs3eTTbNKk3jUbozheACygQGi4ai6LEwUoxvBwQKrSSNa1D5AjJ2Y6eOHxyQHM5205s3WIygVScqdHWFKvqEQ5ynMgVKCUIIh7+gigGkpvQBVWQIX5NlSwyXl9jZ2ydzniT6LPRnfMuZFbZmD/CZVy4RB32Gqz387UicbuCGusuIJtCbU46+Z43J5QqxeJ6zsmS8cZWtas4DBrajYUUoqr7h2JLi7nRMT01pprcYLI66eJtUoCzS9DCZAQJN243SslzhWtcZ47wjhnTIKHlDkYYSiVxJpM0I0RNDB5ORZBjRHUorCTIZBpnA5Ia6rtBGEpxARfDJM59MWBgtoUvPamvo5zn946s8ODxg0y/yC4/0+MRLO9yqrlB+/DZtE7hdPYf5ssCdzPnFf/6PuVXDz/9XP4x5VPHUr/w3/Mj//D4+8mufYXXvPFdfsiw+eD/KrNDOHWY2YXUkaENFPhwwa2v8fIzKFojlFNNTGCUQunMHSmEQWqFEx5lGJWymOkvwN2vRlSlgtUbJLihtpCGEzqUUnD8kMBW4w238yrCHr6dU4wlGaBCacn+CNRk4S64yFkaCcl8gC8va0YwnfuyH+PJ/fJbH7v0Jfv9Df8zPfe7nufSHr/BT3/53WbWn+c0v/BEb119ibaTYmEZE1CS5QP9En7NHE+9YXOSFTz7FsMnQraeZHpCFhB0toHoSmhl64nAx4pOnIdGojKaqMQLyIqP1gYgg11kXAG9qmqamabsmlpBgjaBtD00IrUNnXaj8oPJIkejLgEwOpQqkkbRNTRCChZUFtA+kIkMZzXD5CKfDHsWyZVYd5a2nr7I5/F5O9S6Tpz32P/1Zvjh+lT+zJ7j9xW0e/a4f46FLZ5kffyd7yzk/8Re/TvvQOzhb/B7mB/bYdu/CfGXG01sXkX/tfn7qVEHVzNmfzNnam1L0FVWcM/YFPk5YGmTkUXYqpXqOUVCM+iiRmM8meO9RmSUmSXQJhyf7Bhmwiq6bZabUMSqURumEFJK5N1CXOBEwQlFWDWQZPR0pZcI2M+alIJoh/Uzh2gmhjqz1MoK0NK1j87XPoeUZFkfHUf3Aq3deYWFwlkLsMG3GRFEjUoP3gryXI9SI3dIxUhYG93JuvaQo9rm9s8X65PuZp7usrXUqnap2FJliqPoYGZG07I4lRa+gZ8UhaFsRtSU4cOWk4+JK2ZmwUwLxuqwUWhexxtDr9ZnO5t0fSwUkbGHBQ11GnDsUeorEQr9Pct3fy0YFsskRusdgMOFgskM7DVyb13zh8otkjMmXFJPpJrONMf3FNfadJMZIO/UYJE0K6Crx5OIilzZusbSQsXikh56UPGr7vCqX8HYT57aZ3LnJTHYMYRMCNC1t0yIywWA4IhsMQGmqet4lfFQkJIO2BpEO6/FJ4poaV3dsju7pI0hBgjAgMnyad8UiYXFO0DpBri250tSzGV7mTCYN1ibctEQ1s84ZqBSOmsGggPYIa8cq7vvb/5ALN/4+/+hHPsSlT36Yp90mF96d8/ylxH2ZpW8UT70QOemWePriHZQZ8NzFlnCxZagiv/tP/4IoBL/1G5dIRcbJ/QmPvvdxBkfP4qtAIWA4VPTomNO9pQwhJNNZgxIjMinwcYDNeohMdPLPuvvuEQKVJO1fbc39K+Z0g0eiSUnQ1J6QPG2bqMoKbRJFkdO2iZgsg/4ABbTljCoZ8sGA0Hr2J7ss9woGmabVI6KfIaXknrMn6d+4invuiyxMdhjuvMzN6gLh5V/mZ3/svaRinU/9+3+LfeFLLNRwufaEpqulivomYt4nFW/n5gt/wNbzV3n4Bz7I8198gYfve4KTx3o0pu5ALvPEdFbhqwprNXOlKQ/jX9IKvDC0rjyEmSTqpiGGtpsXytejIAIhLDYHHVvaakYWA/XsABW7CEwMgtm0Ie/3MUUPKUGFigxPsIKq3OUtj72dzc3E8fVHObqWs1Yp/PAHuHz3JFsv3uZO3ecaIzamx8jf+iBwiat/8r8x3w2MdY7KjyJPneB7/t79/LPXIiuL/wvvzpY5N9om33sBuXODm8tPsCQGtDrj9sZFTq7ltG1OObnDZDbHikR0CWszrOrmvXU9wQhBkWmcBGU1LnVZWGMD1rx5Otsmx6ycY3ROZhOOznUVo8N7hxIJX9Y0ynTRO5nhshyrBbNqjg8zmnaT2bjBuciw32d17QhXnv4Kaclz/IET3H3pWWZHnkRvXUL37uOo3mXazJAyw1oohEN6KLOEkH1G/Yo6nmJ5IbA1n7MoDSuP3E+ePYMPQw7mFkGknxXYzDDxgqxqWeonXEi4AsoKRqMhwgXm0z1UVmD6CyjXufJiCODfzKYKAcoIfOoiiVlOd2DmU8foiOASOEFnZUgWZSNFz3bzQTdg82BMISVzN8bHIf3egMnkNYZymdW1h5mNL7O3eZls4SEa+zHu3r3OaKDwHpRV3CdhawTKCV72ktIqSDmP5pqybvjK+C7n+xnT0PD24+doyzvMGXFkNWc47EF/gHNjBoMFdN+SpGNeVpR1gy4MyEBwHmE0Ukmi6A4CO3awRRw2sWI0hNADJYmpIQWNLAbIWNMqRXItVTVDF1BVYChp5g6bJLGtILVoJVG+RFcClbWsnDnC7iuC/vyP+JEnPQ++bZczCzm7lxTf8ze+gz88cZxqb4KYv8ZDjeb7v+/9fO0X/k9GK4/wDtvjozc+yr5PHDEa0e+xNynJTMINH8GM7kdmDUEH8pOrtLt7yOkBw6UVNna2OHVyhc0bV0gxZ5QNOBhXLI5yEBIXEiFqfNBIEkFbgv8m2oCTkkhlug9XdSmGGBoEjoim9ZBLidU9dIwUKXFl8wC1sEohPXU1ZzytEEmg7QJt7TmYNMQkEdMDXp5ZqudHNC/c4bX9yOPFAm19HuzPMb32Cscvfo5hdgdWPMVYEAoJUXDs+Co/8KH3cfUTf4w4NiHvBe68epPTiwOWFhLBNrR1y9QJpg00TUvb1ES1gDGGwhjsIKOta1oviKrXaWTqmhTS4VxXH8r3OnOETB11qpyXDBdXaGY7WOFJRuKbOTE4CitQqkEkg1IZtUuEtmZhSVIf1KhQsrA8Yra/jeivcc/aceaTVcT6Ete/fg/r4ijTwasU8YDvecuc39VDfvRnH+S3fvMFjqxLYn/Me96f8zs/+c84+3M/zo+PZmS9MVfUDluf/zqbl1/j5H+2x8m1+0jlnNZtQ3uaya0XWV09QsprJvOWQguU9yAEka4yLbXB+UTTtGjA+URsGgaZRqVviIx5eUgV67aaQuagDD54pHAErYlVhTQ9Zo1mlCa0tt8Va9QRQlQ09T4dss5xd7tEiJscP5Zx6eY+dZOzfP6dHLz8SU6vn6HNNVfujAnmGAva0WeMlAaXOUIoKfyY0eIQ2ps05ZDiwrfwRJ7IZi/ix0NuCINdXcbIRBISLww2z1nuJ1xdQe3IBisErRDdbIgiM0RtiEqRoie1gbauiK5+I7udElRVhVFQxojW3RuuzAzOBXxTIlVGprv5Z0oJ2ohWirIas1R0iZ7gpyxozYGMzNuKI6vr3L5ykf3dzxFjhm+h2X2BpaXT0N9iWu6SfEIEeLmJnLhHca4ONLsnefcZwcb+HQ4Oxtyfax61OUOtuNUO+GrZcsxL7GBI0c8ZLK8ymU3AdUYM3waSsd3u5ZAfprOM1HQFmP4go3UelWsm05bSd7ZngNYlJjOP0hFtIyFq5pOEayVSBUZ5zjz2EGX3lihTN64otKYYLSBTzkIPJDlN2ZK7iK3HnL9HwqZi9W5g+nu/xbCFD5ae3T/9JPVrDQ+/dYW8r/AvS+6rLtGL+5w4+ByfcJaH8iEXqykzocjiEsd6kiPvfoT7z9WsiDHRrDBVJS/e2Ec4WCszdm0gzBTX725jFlaZ74zxi+tUc4ePkigN8TDRk2LnjQx4XPtNdKTZrNc94ejiMUQHvkXESK4gzzV1XSGDQpiM2xtbRJFIkxkh1F10yHvKVrLYyxHlHu1kQt8axhOHlIb0yldopvs0omK9+CRl8zMssc4Lv/D3kVsv4USfZgrJV/QkZNZQZD2e+b0vcOPGVeQ9qzzxgx+E8RSzuIQqckonGQfPfuWpmkgrNI3uoUynZM3yPh4IqXsbQXbCQ5VUF/RRCmUtyrz+BEsI4SE5jOqG/7o3gtCgCN22qpVo1aDkvBNUBkUyGT7rM4sV3gyYb44ZHtXs7m3Q1ktszHa5996TnM89i3df4O7TV1kPkvecuZdT/e+gFZv84fW/RXr83/Jv/vkaH/uTS3xhs+XomQs8/qlbrDzyAhee/A6+a+UBfuy/uJ+LrzzP1ctXKIctXipWV08zKgRHjh9Beljp5RwfDSirlt2dKVoFFvo5Qmqi6yhM2fIStAEtW6TMu/rzN9iAjRJkEkIKXVzON0QfD4WlmhgU0kZCashFoh0uIlpPW1ZY1dDWVWerRYFrSNSQJJvbU5biIhM9Ru/WnDr1ONM2cHBzyvHlx+lzmXzY0oQ1ZjPNINOcWhwiwrNsb7csrdyHWXuYc82M5fYLfOyFhvMPnOf4qSXWlhIHU8e8yTAxQjthGlv6KtFf0sg4wTeWRgxoEgih0UJjQneQlLQmWkUSBmWyN28io0F16Za86FH5wGQyJbrQxelil3jAg46dOr6sp0QpmbeepaFls/KMJwfUZY1Igp2dDcpyitc5gQytJ3h3i407gcwa2mnXDk1ALgXlNcX54T532efOFQ3ZIovakup9gkz41nHRTbn/Hrh7M3BqeY2VQUYv75FCi3ARkynGraOpKoSyZL0+ed/iU0PTtvRVxDUKlKFtocgyUBJ5mF4IKJqoEK3AYhAy0dQeLwu098xmkNqcKjS0ZbeAmZix7yrwNblJ5EhsaGj3dtipWkI1QN13jO27PdZ/5n+ld3KBj/7EP+HZO7e5cWWX5TMZxZUx1QHcd2Sd49+a+KnnCv7Nf2p57yBhipaDpLlw4f38D//jHq+81OfUW3+Mj188ILmaYVXSTHZQ2jOVixzojEE8YF9oRK0Jo0XIDVWwVEEyG7fd/FZ3qRSBJHhFnxzPX41481dadMu6Ioicfl4gYk01m3eHUXmGsRmx7bTsKiWkzvAhdAAYoVEStrZm9O2QfmbpyxprPWaUk+U5dTNFHxyw1J/xalpiWe1w/KEf4vO/+inWf+l3eO3ODt/y189xtpzznoM9Hm4V4xJuaUtblrj5LkeA1aUB0yvPcuHeh9C9gr29GVVmqOqGyd4BzglUPoI0o/WOcKh6qUOkdQ4lFco1BJEjhEXo7gDFR3h9kBkRlBFS29Av+sxmFaORZjrzZJmkN8jwdOFvqwxJ5XgEQwEegc4WGK4qpgr6MhFTTdZMWFlZZveVv0QdP8eJ0yc5dewMRit2+oY//o2nWBwuc27B8Nf/zs/yK0/9Kr/4d36Xt17+M/Tf/DZu/etf4MT2HzEcr9PXR7GU3LtgOBhqXtzc4MTQsCIju/uGO7szrGrpFXkHrQ50Jlqh8bVDi5ZcSFIIpDZgYiAESXBdyiB8QwvLKokXFpciAoVV3QGUD4IUO8Bz3eZoXYONTLZuYjNDGwOuliRlqN0BisiwP2Q2a2mkZXnRso8j9yNcc5exHjPbrVnqDRE8Ry0kuzuJ1t0mHyqSsVy/sc2JtYIyewxmLzGqrnJrFKjOv4tHH38PZ+4NlNVV9sclCVgfSUxWMWsFRlss0DQNfZPoDwqgJSRLJgJSWqJvu+9PKfLckqxmf3+/+yAESJOT9zLa0hNToC0rlFRgJa5qIHaKeiMtg14fTWL/4ICSwN7sAFlVtEYRD0s6WimOHj1KT/dox1vsz/bYC4rV4QO49ibjcsJgZGjqzud3zEVaLVl9YIX9XcFwXvDgWoOLnp2DFZwwmLDLd5w+wf68YTww9KxB9zSTyS6hLhlkQ2qVIYTtxonSYLOCgMD5BqEEwuQEHyE5nANjLVmWvREZk8YgjMX7LuWhkiDThlxKyskELAytZFYZbNanZzT15ICkFc4lRILSK8aThiULS4MRB/t7LGzmTPY+g1Jb7D+9waM/cZyXru+xeW3O+kbL5W3P4ltW+Bvf/SDOvY325ldZVbe5KZf4Xu34uz/z0/xPnx7w9/7Bv+Tdb30HH//0XzIbGI6ua46vC3oFzFtHX0WOn7oPVy7T+FknPRXLtFrS1C0mM6iQyE2XYEhedbE5FCFIsiz/5i26LgaGWdblw0XEWMfSeN0AACAASURBVIWVBpXnaKWpmxm9IqO1iWo+YWlhlb61+MYRbY+e22D91DHG5ZgFG/G9HjubAoFHp4wjoyXuTmaM7Ai5uMbB5se5VDuOicSP/syPUpz0nL52hTsH8OLBHju5ZLR+jOnBJslkFNES5hXXL085e2YJ5gGHx5heF/QWOdhE0orQSGJo6PWX8PWMJDT9fo96XoKMKAOubUhKkdkCmQTRvwm8IbZIEk3VkJmMuiwxOkGIVOMJSimCT0jnIdaENmC0Ic/6aAELy4vMQkIXfZKArBBoNcH0M8aTKZld4PyFJwhfG7G7ZXj4wUXOrA24vl/x9G8/z/f95H/P1RvPcmaoadSc9vvfxzNffJW7H3+Wcw8/SLF6nCAWWD95nFy05G1ONW85cJqeAj00tJMxu1tjhqNed7PEblbZSEVQINqIVRltcLh2jg4eow3Cv3lSkBUDrOkOIp0PoDL6RX5oP1Zon2hTpHaCLNTkttdlXmPE5DlBG8qhoq6m7FYlTeyxYBN2ZYkijRmMzjDzJ7l2+zUefN/3skLNdOvL2CWY1qvkpaKwgqmuESuCnXSSI4NljnCK4bH3EqYvsHD6MSZPf5gvTFruOX+BhdEIYiK4iJs5+rrL385jYpQbssKSFz2mKaFLjwsepdyhZThgJWibIZInN28+gF4/XNMC6rrCHco8RYKYPG3TIoXC5IYYPEFGTG7x+2NWF0a4Xo5Ukv2tPYr1Eds7eyghqZSktOuEvEeobrO3u809y28hX19iY/oiRx/RbN3Y5fsePM5nXryD7p/jYPcOk6M9mqKgKDXJNrQhUvdPkEVJ5aEQPepJy+IcimVLEgGvLEZpVAhoo5FaIQgYa/FRYUz3e+cjWTEg1x3mVRn1xqLbRcl0p6rXGqMVs1lJoRJCF5TVPqowaJkwdoEQuop0MorcFl30LhhkvoLIV+kvDeivTumfPIXtLePvXifre258/Ba3as+5geamjxwxgjVXcet2zT2Pv5OHv/Msn9r67zC9go/NJnz+T36Xlgd54r7HeeeJfZ762lV2JouEsMa0GTBYMgwGkCrY2dggiCHlrGIwyIjlFBUkqnEMFwbEOpCQJC2QqjMkoxQ+OObtN5G9YE1nKq3qGqEMKu+9UYd0ziG1IuvlxFmFUop52WCFpcg102nLQr/PUHXMg1z0aEXEhJb+ICMPgWnjWBwt03qPqz1fP5gydJKVlYxbL11FbSX00jLD45q37CdG44bb4wkLNu+Ytr3A3dJw8sQaN6+9yuK5B1FJM9ufcTBzGNsn05KmbRnkI4QvEcKh8gwrYD7Z6XTTSnU3l7ZIrVF0XFT/+qEJiVyl7i2ubsgyRZ00xlhiSFS+ppAS5yJKNmjrD0cXEhsis8kYbSRtE9nZSASZsXFrlxNnLNeu3OXY2jF88Axzw8rpI+xuHLA6MOQLZ3jvgwtcvnsvwyiZ7yey4QL9YUZvcJ5H3rVKcDMmSTDe3WN3f4ft2RYi69FYic1zes6w6Tfp1QW93oiwLBGpQTiBFJokBZJIJuh4sqbANxW5iJ2I04PQb/J0YwocAg9RCVLwzKsKkQLeJbQUaCJt9DQ+klSFCx23WNI1uFB0sG+nELGmdWDTCLu6wKSp2dudsWQGTK98CrHW49SJNcq9OVXZUstEnSJlqairYwzXcqza4+44cCK7AUqzf/XL2JP38cTpo2gRaduWpqkQQmOKApEiRioGRhCiYDaZo0yGbsEisf2cmWs6nF+IIBUxCkSKhNe14wiyQ3egzSST8RxSIMv6ICRadtQu7xzBl3gJXnRb08HiYvcA8NBOx0ydY7G3gJR7pNh56Qb9Pov9AaOioJ6PcfWcO+WMJHvMb41RxTKf3fJMvOVjW7fICk1sK2YmA1OgBn1UGnKjnDMk4FtJUIHhgqFqA70m0XqJUi2Z0Tip6GlLUpomepJrUCIhhCW4LjblXCLXnY5HvUnjIIVIih32M4SAEF1Ms65LEom67swzRWrBWkLlyMwiSnUiUPBA54vrL2om0wN61jK/26DFCmF+lbvXStpa8b4HR7SzRMolvZ5kUWi4dosv/Ov/g6Y1/M3H3sLXXrvFwpmz7M5mrNltNg8UH3kpIyw8hKqmJCyFHpIHRfKSGBt27x6Qm+7/mCpNPT0gt32sMFA3dJu4iBQGkiG4qkv3xI7B8E1bdLM8p/G+u2AJnZrFGFKMtMkhrCUmTRtlB4pJjl6/jytrBr2cmi5Er3SPet4ig2epPyQEidYFfZOhhyP0wQ2Whn1u7exxetBn5fyDxNVTjI4PkTaRH9wm749J9ZQUIsujHpv7e7RkKK+BhlZnTGuHlaIzRBhJ3u8g1FoZTOap69j53dqKcMg5FQTCoWo+H/ZRumsjdcvKYU5KSJKwiOTR2mAseN/FV4VULAwKhJTsxxxpFdYIlHQYa0BLfKmYjR0rwwHbt14Fpbl9qyHVgYO9HVRdMRgNibM5RTvn5HKBWuqzULRI3/Lo/fdSOCiKZaQVaJGzOBxxd75FCvs0s4Aqhgx7gnnbZ2vW8Uib+YyydBhr6SuNig19rSDmzNsGqURXA65r2kYgdexGMMGhfUsIAZP1aHnz7S76GklLrhMReeiH6vCFSXSYO6EVqm0J2hBd2y3CsodNJdOyoZ1XiAjaJFKbwCdsIbDDZab1HraIiHLGan+J/fmEzbbEHe5cBjoDYUgKBqsL9Id9ooBMrbJxewNbDLnw0NuYHigy3+JTja8Tgl7HTnAeKxKZUszKGiczer0+VVVDtOieZt4EaFs0qeP7iAgpIQXIN4RY/x9r77IkSZJcWR5meamqmblHRlZlVwMNQnfTEPUGv9D/v5/lLIcGMyhUZUaEu5uZqrx4FqwRiT3Sl/n0MFMV4ce95xpYY7ZJG45/TDkRUvRDSU5tpwZUIxI8vufjvhPXC3V/0NugzszLayHb5LouPPZAnR8kHogUqk0++oOyRtb2ZKfzES+U1SPtYy6IrCwX5UXhp0tBiNibEh+By5pQIisHQ+D1cuOpxrMPTAIzKHVMQghIMKa4EXiMjmqg5MhsOxoTZUlMlBAcjoP93gmOOX39JuoKoOauxdEneVsYbYe80iVSrhd0DgY73YShnbpEYgw8hpGSEMaD/+v//H/4b7/ceN3+xLscvIfKmwze5sE1JaIqvx2TXivv9oW3feHv3wb/+1/+hbf5xvK3wed/+gfamuh74PqX/8FXAo/Hk3IaOnrbmb0RbFKr8aftwq9fP0jrjddb4fm1YlMRrY62nIbNyTH8z1rrZJ9/4Ex3zE5WIQbD1BGIqi4PUhGECaMTs/K8d37+/GfEdrooW0ocD8MsknSlPr6gNgh5ZT4Hry+v/GuAY7+jq/B8NNaofP7TjfRPf+FvjwfhXtBvTx5vdzRFtjWzjkaOxlY2Hk349NOKXiKjLO4fb41hA5jMtlNkY8mZURtNXEt71Mr+fHC5rZS4+EEcfC7Xa/XMs5Mu9f39YuDthRohBnQ6/u6yfI9nHizrRk6ZqJMYKttaSGWlLBvWHAajTciqPD7u/Hp85d4GwaCEQbInOe3c2sLRjKiRq3bmuDPqBy0s7F8Oyp/+zJBGXjZy+gsjrMwQqVUZdjDt4Ng/6G1nNViHIe2B2GBVYR/qelQGs1dsDGdqWON4uoJDZDD6Tgig/8GFtZZMSc7UaCa0MYFGXDa2CMf+QK838nPw5b2R1Q0oVj+wZUVLYmUyeuPxqNSh/PmXn1jWF6Ys/PLpF37b/0bcYIwn/fnBSFfSlpE62fcP9mFYyqTwwpTJ378d6P7GP/7zP/PTz1eiNPb9C5tNLBYnhcUIyJlllzExyrIR4sYcHxxDmTqQjycWEjEkxAajHkw1QjyZG/H3V8cwzAatHqQYiDEhGqjT0JRxpV1lTmMfgzSVy+3FWRVp9eircaIe++CYwt4HEoQogaSJP3/+ic8vhX9/+8ZSIGN8e7yxScKK8ujKkMgHC0uCSmBLhfUlEaUz74MhgWVbuR9PJE5iSXx9e0NyJl1e6M01t2LQxcFNmj3ZWIYnZuRtIcSMSPT3S3+vdHvvjOM4+RyJMDpqYDHzvL/zei3cj52phYlLM2HSWkfNCBMedRJjpIdB1I2ZI03+yocqz93Il0/kXxpbEfb4cF6KTOIlEPOFvQvaHvz0Kvzz//yv/PU98N/+1/9gzxckRb58TMLLJ0bfMPnmSddpMvdOsURcNta8EC3x6TVDzIQslAwqYHpmwqk4/GsYuRRSHhz7HzheYDZ6FxfAp0II4qLnOfxBxuEe0QYxGJe10O9PKIV6PMk50QeMYbTuAGwhcC0btQX66ITFnUstwL/88z/yl3/6ibkYcU50VMbYyUvk9fXGPgVbJjMKe8/YY+d6LZgJy3ojiWD9IMVBaxUTJaSCWueoT8QMa53nftDm5CbAmNjw0UHvjd4rMQoppR+QF8yw0dFpKO7EG91jWI7jgJIwFXJ2EFCSToiZJS/ksrBIYBx3hjXy5Sfm2ClBGAr1OLjPr4zbikngMQIhZm4p0p531mWyPxW2SG+DnI2ukyfKTC+MOvny/kGViaowVblcFtqstDbIRG7B1Re9N2x0Z8PG6AT8jCfdTggixCAeQoqQTi3maJ3fu8nvHYBvcF21MLHjQKMnA6uYV090/+w6iIl3B2mlSKQ+H8QwYFlgWZGs/HxdqPsgjU98/bev9DB4uax8/vmGxsDXf/+Nx/7OCNFRSn0nSublVjhC4DEy87evXCNsL0aSlaGRgNuSXcuvaBBSUHdbSufb4QeOhkrJGcR+j6cR8UNiQJTgKp7vPwpzeELINEFUMfHnnTkJYoygNDvnnqJYn4w+eTwe5JIQy3wcTxKG2nQZ0vR5Jwxq84p0WV9cQ1zvpOR4xW3dmHZwr52XNfFuSjoG4ZjInIRhPFlYgicmX/MCo9G7MklOERzOBpPon8u0zqSTJBEjjNbpc5JiRFSop2TOGRSnDRhI4lCgiJ1pCsqSE0eIJM2s5UpM+XRvGTa7q4Q0ksSHFc/aWHPAJrSR+djh2jrvv33jl2skx4WZBrIV3u+VPgS2zHpbucyFy5wMGTz3D6pufNwnSSaxd573Tqt/xdJn6vOOhoqhfHw4H6IUo+XGWm7sKMIdo9BGY1syKWVqd52yBiEYiPhzJO0PPHTHaesMKRLPVnS0xhgdUfNFQq/omCxZ0XmQBJoNWnuylJVjr2irtNpoY3BbMte08P6cTOlsa+Soyp9vv/DnlwW5RY5+J3Tj4/3O1IGFQlmE681QE74dndtLIMV3ypJYloVLVEL0nCZHD06Xc/XKFEfPqflcZs5GDO7smc0RjzJ9KTJ7w8QH5vOkB4kKKRdvhedgtoqiDkGZQkoFE8AmynCuwOlYQjsSnE8gkmimlKDkl8K+N5YgJOsce/Pgz7KxXl8p64ppIC/K3ne+/L0xcubzT4X91/8PZEP1xt0Gb/cv7O0LoURa2NzrXxt1TEr0jLtZK6NP5vB4eLNECoWp4tbO6e1gjolhTpXTEJ27EMKPScujGj+BA94FcgyMAbMeDBPEAtMaNgZZPEG6dyGEwOzDlygDNC5crsl3A0HZrpGQjKsI87rxax9cfnr1h5pOkYlYdeCQej5dkElvxlZWRqw8398pW2UfP7PlxJQNkcbsnXkmXEwVoiTSsmKte6aZedJrVCVHBQ0c0/z7F3WTjDpLq9bfq34VMOH8vn05Bw7Cd26JYwAdAhgoZWF/PLHuSE3JkWVL7DYYzw+iRtblyhjm9DKpGD4SSzES8opQySGzhEROryzxDcFpYzaMYwye091SKomWlFUNDZ0siTqEo4FIwE4WMCqIRJDgB+HJAMYEG46j7N3TVvqcqHmF/90GrOLfrzExm34xmX9ul83ToxUB685sOGlksRRfVqmQYkCptGGoBh57JS03jiY8HvBlNLaYqJroS0TilbgV5JoJlwu37SfGTx98PDoSAy/XG//6169IUyQoMbnxp1unzeFI7RDpFI7aeBwHv9mdTxeoJIZVXmZhVEFjJwmuzkAxSaBK75Oo4syRP+rQ3feDGCYpQBgDay4IFjH3oJsxWyeIElJkHJWkyuwPVIWSC7bvtFFPLadXf8EM0cnltnK7JkIWPsefGdJpuKd/Phvt6KTrBckLISsxN7JFyhzk5UYrsGyFbV2dgysTkeFAFI2YTEbf0RApKdL3g9YqQY0cxDWUGKLxpIu5C2tOc6LYyV4QEacq6UKroNJ9wcJkLYUYlTrNN7IhMk056sCOzpUTm4gbCup+kFKjLAvP+xs5Clv27b8KbCVSsqHhIJdCTZH6NB7fvlJfPnHYILVvvN7+gXB5penCDIXno3HUB0MNYUXapPfKvgpjrq7Dnc4LYDjrdNEA3ZDp7axhRL5zJjoSChIjsfyeC9amMuzcXIvT5VSMKcBUZn1gYqSYoO/QJ2hEItTesN6BSMwLMS+UXkkpsG1Xz4WZjZwSt5eN7bKQYuDx/hsx+qw8poCFQM6RbSmOzlRlfzy4bZnXl1fajByW2IIifTpsprnVW1MhpoKGwuzKoHNJGU1K0Ahyxs4YHrMTIyE4JWyciNPvP34wnS+jCJoCjHkCuyfDfK6bo5JCoiwL1l0dkWMkqf9Xbrcr91oJSyAk80OtHqQQKYsQjwcoqBZu8oJ0uKSVYCtsk0sMyKjE6HF26iUBIOTkC8yQFnof1BBAEnM4QVCNs21WJ6wFQ84YIuvnO94Ho1dscqJPx6le8M9hngG102D0TgyBafDcOylnj+SxyagPgsSzYBNKXjxXUCAlRS0zqUgBGY3L9UKnMzXz9tw5FqVLpC0XbpeN15eNFCKpFNbXz/xUEvq1cdlWXl9ufOwDSxdyjlwvg8u68eyZqUJtg5QXQsjMqTz2Sm0P9NEI60adg82g9c79qMRxdnsSMfEFrMzTQBb/QHNErQNbovMG+mT0/uNWGkeljon1wWWJxLRSnwanpGJLKzFkDjnohs82c6LkiFTYCvz88kK+3bgysA+hjztjwn5MggkheFuStkKbhnzcSSlzDRGLK0PdXRRUMQZ23DEJpGVhAm12D9WMTglqvTN6JWhARDEzRDz3DQn0Lgw7t7EnWYrzEGpjsMXkFaAGplVEAqVkiOouCzGmBfo0am1MM67bAn3y/jzQ9oXRlGd9ojMwTOkGkgtLcQLTNKPf74RZOSxQDRqJhYWsC1++HYSjMfdfCUdjD8quygPngRqdEJXYhdk699a4lHwmG08GySsOkR/SHQVyyr4AssmzD1qdyKokVbr8ftBo9OyrGIQ5vQqaAkPiGeVt7s6KkZA3bDy8CgpO4I8MSspIClgMhPWCzcnjo/P508a9D5aXF375y194ezxIOrlkr6jXdWE9OqbCdcssOTFCoLwk/vXfJiVAlwXrxqfXQtJBrYMUEkGzH9alkDRQ26RPQ1CWsjAFJubw6l7JwU0Rqt5W+2U8iPH3lIA28MijEBhzkkI4//yRECe9TS82NBCTYhNSWYgamfXOmhLPWsklwvWGDS8K4tgY6eIHG57BNvrBfn/nohkpFxCjmMElkUIkth3iJK+RRSLaAKtkzU4IiwXTgaRM0sA+K8MiagkzRYkgiupAT9mb0gGj9crsBQt+lPdhLOv6wyY/zZjm6oU5fIw4Z2c2CNuF2h7E0ZhjkqKRYkHpxJiJegbgYsxpxFyY8wCH0BHXzAjK6I7YbGMyRZCc6Gb02t3M8ninNfPuXDNzQNTEDBNVZczOSypclsVtybUR4spdElIGKpUlLgRRyu0TcRyU6wWzJ6bKDIk5fa+DgY1BQOlzIPIHHroalLhsLCWjErA5gY6Zv1zP4yAMD1++XW/8enzj6J1xtp3MydE6MWWuWU/OZqRcF8p+5/YCNd7Y605Z4Pn1nX//8iRuiTVlLtfPzLiwHwe1d2IuaMhA4P68A0qbma0s5F7ZeyWUjdGeWIiezBrFSfZzYjZYl4XWu89mokvFmJMQEnVMkHBSw36nKGHeVu1HY45BxMg5cVSjTkHbREUdJJIC2CREISHYMNR27m93eusIgaCT+/GFTiOERBB3c5lEDFwFMCK1C/Z88GFGGMZlKELk7Wm05xuhwyNG7oDJRskQiAzx1IqQV/IYxHbQqxGDYHIyUVPxbC/1mayIUHJCZ+cpsKyLBwnWymy/S8aCypmh1c920lUMPuGbHsypMPtENBLzSuu+5QeYvbJmIafEIQORQi6Bb3//KyFEllUJ4cKMN47u8qk5hDiUSy60pdIlcS0FJEMwZEbXVssCGrmsSpx+EJgkYlFiSNRutNo9GUKTu4tKYs5KCsLj2RCbxKhstytjQO2TOR3pGMx+xPUYfiiEIJQUebTBfhyoRNqc6Jmt1ZvzHaQ24kwgwrJtWJsu2ZsgszNFyGEhToEktCCEqAQdiDQ+nh+wD5Ia71bJCZZPgTA7zMR2vSFUBn4JxuwX+JAJs/I+ui+4Y2GEhToGa9pQjS6N7IaYEWMmSMbmQKLzFkTc2aZLQqMvCseUH+9HjMFVG8MvJhtCDD7Ka7U6CEqm74XE37sY1HcQJxA/xEjQgKqrRCSspPWV9Xpj3QaP+ishFNYF3vfOvnvHJBoYzZB9YDZpY/DxcSfpQgiJYzQsrrQG394PKMrHMbg/dkLsVBISItfrSr8f5KKsl0i3wtTAclt8VBIc6zrx3y9lQS14Ssh/IM/9pw9dUmC7LKcw3GNrxlHpsxFicEmN+DJJ00Jrf6PEQFwW6u6i8bStaK+ImW9JLXDbMmkziEZvlU9x5ZiTOhrLtrCWyLpsrC8vzN6RLizLxmGR2pQhSp8Hr9c/o9vquMBmPPbBxk5MF2qfrkAQqO1gr5WpEwmBLE5EutcnMSSmDcfRiUKK5HTODJO31XbeqCEVYozU/Ulekh+u5YX721e2dSOlQCk+z5rdl1NTki8NZHpbfn781QLPdvDzzW2l+7GTq4OhDxS6oe1X9j3x60MIwQ8euSz0mOk5Uevk7XHQZDIMaEKSQdk2pkb688m0iIRAihkJjVk/UCbWqku+TFFxGZDrr3eiOP0/qmd6zT5/LNKsVU+dUFc4CAbDVQGT4Bv/GVmWlfv7B51EoJ56aGG93Eg5oZpYghKiUdbIW0lo8oN7TleT5BLoKK+fE7dkjN3oMnl2EJnERXx+elSWFFlfN/7r50/ka0SPToiFvL0SpdKOJ70+aWMgspKDkkpBkpBtYfQ7c0xKAlTY9+qtpEGtHWanJP3BGxAghkQM4kySacy2I+eCSlWJ4QSuk/yAOMNPBbguCxVhGY0ogT53psI+Dwiwqh/omgo5uz72qwlBBtSDyxaJa+I1r8xnZFHzrLT9ybDm41lTr/TmoNUESZlL4hgGuaDRmch9ToTEnEoYeBq0OB5DBbZtIZQFiQuEgGIOaz9/NAViTow6mK1j1tEQMAl0BteyIKPRu8+arTVCWhgaiJoYrTG7cd0i7ajcXhfG80nOvzDCwvKTMC0SiiJxUi6ZEFfCdiXmSDSwvCB2MN7/bwgXao/8enSWlytRN6iNr19/Y/3sWRrRBDHxQM4QWa4Xft2/MTFSWOm1s79PUphYWkj49ynBF4Zq4u+oCqH/gckRZV3ovaLmFkXrzS1yITmDwSJLDmgI1D6p+53l9kLUgPX9lJn4FrHXhqrrFkUdntNaQFtFRHk8nkiMiHVEb+wz8fXjQMbdOZ4Gx+gcUtwlowKnVu9Zn9RjR8LC6JnRJ5ozOWdCEJ5HpY3OMOM4Gsuy0c2IOXLJK497Z7eGiLIkd9SYCXLqUz0ZdSDpe7uYPbZlDmRA1JWjGrqopwu0wZzqbbT5ZUDwlnN0Y6jQWuW2vhA08fEYFHnCEpFYIGbW1xtFOmlTfjuevD0rQwIyMxQFTYg1tqD02fg4dlqtWBa0HtQjMmpiuSRyiAwT7vsDjRfHE6rL/RjmM3kJjF5prSEJSknEUIjNaM/JSa32wM4xse56Rc72KgQfOYkIgjH2g7JtPH/7jfe9c9si+QQnEWF+1+WlwGHCp9eV3j5I4UpZMjGv/Jc/LzDeWeJOEqVF4abAx04bO9IDrSmEzn//7/+IDOcZ83GwbitzTDg+XGVwNGxAXm4s65XApPcnTIU4+Hgc5JI9dql2iGA6GYQfs90hQjsrdgNGrRAjEhYCE02RZ23YMEZ36HdMmZQio/szHoKR18RQI1ogRyPHwj0nbDS29UpvT+bjARWYGRUjhoU//TlxPH6lHolsRkyF8dy5bpn63tB2EAioBOacZ6KDgkK53IDGowk54BKvbEhaCOrtetk2YhFsNvrYXbernqYSy8I8b5zLkhnz94Omt0at++kjEdDiSTPnzNpMyGVj0JxXIoaEQJ/+72ITYuLrYYTjIO8ZHQn6O4dVLAQeM1FYeXYDDVwvfyIviTkPpgpvdTKOg1Y2VBrHtydf/vZv/NOn/4NWH4RSeCmZoR4fpCXSWvM/05z0MUglcDThy5dv1KPShxFDJJSD19uLc1nGJIaIScDGJAo/dj9/yKGbAlzWleP+YD+ab6tTJjCpsxJyYlkLQRTbdwLK8+i8bpmtrGhyuZHYxKWgme2yoQl+uz+JofCnZeO3tw/6/Y1fft5ovXKYom1yyMGyuNZ1qmJd6K1jInz+9BnTwsvrjfbNeHv7wu31ExZXTAohZMQCtQ6O2pkDxNziO0ScJ9CMx+NwfWXvlK2QY8LGpI3fN5IhBG7blSBQx/BbfSa2RV0mk4tXmuYRNf4gGUMHFjKpXGF/53rNDJscjw+2UtjKwmwHKpOy3ciLO8SGRu77zl8PyNKJAV5f/0QT4Xl/oBaprSFi5DDREsjpwhiRx9GR4SGLYya+fNu5Xdzf34ElZrpVej/oo6FaXNQvyrOqMwdM/TMaB+2+s5aN7/KFNoOD2xl0iefNb3QCaS2M+mSdlWcdJIXtemUGofVKzItnjXWXrYXo6pcSC8REipHRK8875MvPrKExDmPMQJDJ6BBj8LZ16AAAIABJREFU5vUlUUl0CpcQkXzh6/OOsrKmQp/Ct7/9v+TrT/z06ZPrS9dGOA7a0Xg8vxHse+x4Y9rKp+sLz74zDhf9q7nRI0aPkH/ulefojHkylnHgzWM/CAn/Z8WlRHP6sklkMpqdZiAvYEZtvAFZI6KDNUZUYVWhDkDn6eUPjGMQQmLbVmbvfDzv3G3ll394IcjOMaFk34GMMCklkE1JFoka0QjrKtS9kY4G20/0I1DrTijqbfGATsBmJFrwdOQwoCtmw4laITqJrhSfMUdB5u824DGHf2YSmBqIMTCba/k9VjHy3A+27FjV2mA8nmwlE6PPaqdMjjawYSzNeN4PXksh58jROksufO8WlrIQSyKtyfkWA5Yt82005uM3/vp2p3W4D+PbxyAALW0crWN90nvHaiMpaFl5r0pAuF4+Mfrk2CvLtrLLJPZKjsbz+UYUoYTIzIKJ0c9icM4/MA14XS4sKVP5ICikvKAijPpkAnndSEuhPe80AUmRXhvpYkhWHv0cQ8REiYEgkVZ3/l53Wvf27tuz0Udl3Tx509LN0wsQuhlTMmZwPPYzOG8yj8rl9pn3OfloLhXKZXViWO+MfaITkgmGeeUrSkmFe9/pDKxVSlro4+DvX75RFkUkMpuHUq5L9CUZXuTJtB+SEYCcM6a+pQ0CJQV0HtTWmUOJOaMqJIw657ntV5aQiBelPVw0v15uPB8f7KYEzaTk87P3j4NJpKWMCLz3B+jC5//yiTkdJH0fHg2/SgYJBBLLUogB6uMJ6okQ9XvsEIM+XfI3h6C44Hs/PL5mtgoK9XkwB24IMTie9cd4IeCRTTEpIh5Tfxw70h6MUECUrgvxJgTduEgHm7SunuJhvowa1hhHJW43xIKPCEpmf+wsl4UleFjSPODxMN6nkVGOp+8TXj9txPXmWXQlUA54vSnap0saw4VjetTUlqJLr47AEMMQunqs1Lp+prcB5njDSYCpqE1SEP8QRiUqpLQQz5ETIqzrSsiZ46iIRPajeuwNnAu4COIzQ7NOjJAonjItQorJA1FViOVKXgbdOjahSkdDY1Ghi1BnIyyJT+WFVQ++vHeuL4XHfUXHg5QTVcByxmLykcGzMo5OThsxGh/HHRmJtEYwhSh0BmM05u6OxKAZDZM5Bl2duCYaialQp49/Wn16p3POMqO4Zl81kIIy2k4bRiyZoIFpwna9Uo9KzBdfUEalYTSEOSa97diY6DD+7bcnq05+s0j/9s7l5ZW7rny6Xfn1719ZS4SRwBZyWpjW2Y9Jncb7XNEl8adlYeRKRKlxJS/JHbQTeDYs+aJUgnB78ZDdaaBJsZRYrgv6/oHZSqBSNHnyrw1MlZQSsTm2M+gfaAOmDZ7jQdDkyyX8Qw8xECyDGfXxRHLhOCpDIjEn9jrYXl4pvbtJomRKFGatHL3TJfvSKVx4PP9GWArR/HDatoWP551LvrooORevGGzSWyWT6CQ+jk6bjS/9IN9eCOXicjVNGK4dZHYMg2ns++6tXRJmPzCPhOLj450QAxZX9lq5xHyaPs55Ja7FNIWwZo/oZlKiMNyThGikTyhxJS0R7YOgEZFI7Z1ugcvlhdGfzKOffOIFohstpFwxjXQL6HDQzveJ2WMYH8ekjUbcEq3vxFBAjfncqX3yfOwsa6asrpQYo6PSURp9dKK+khK0BpLcLTUPgd5JBnV0nkcjM0mxICa8vx2sUZmz87tLBNY1o8ErOw2BgJEGfoifvImQPFmizsH1Unh8fLAEoe47FhLzlBjGkM+LAV5/vrIP4fZ6I4dJH8bbtwc5Ji6vn3l8vEMT1ssLMUaW7UpIG/fZ+PrtHSMgsXh8eCkEKjEWD1cckxgSl00J+uTYO+vtSkyJx74jc5J0sMmgBUjrSoiJ1ip9TMacTDOYinxvq83o7UA0kGIAg8Gky/TFi5w4VAnM4fbhbbv6Im7g+wMzZrgwWyelyP39g3yqYcJsxBxZlsI4jH4I+/ODXnBmcS70mVm2K9Qrj76z3lZWBfYnrU7vWmJCUPYJRQNNjaftTKCbL6QHSgnCrMrjvZGLcCnBcaYiVITaOqLKczTW7O/ld6NICIEo6tzpIMzkFWrrnmFm07BprDFxPyY5F0oSAueyLxVCdElqib44vJZP7G0Qlhu7+c7i7dEIufD2tvN4dt7flKgDE2W9bFh+ofOOpMxHrzxaRxZjyYO3v/+V0T2W6Ki7B25eXwlBeX9/Z7l9ZvRBKqdhpBpBIlYfxLKCwNT4w/oe4jmjr4P5H7ri//Shq+IVmkeyBDdDzIGEzCVlaJV6v5OTV1rb5eqxxlGYs7EkYUEZAfbdOGIgp4jamXM9O9YPpGws2wsfb98QCeSyOE5NPRzRVAkWKTZ5PitheeH58UGf7dTYJmwM2hykdQMZ5KRe0QywqQQT1Bq1dq7bzTWsx4MYPWsq6Vm99sbRh0tt5D98mEGZUxj+mzNRWj2Yo1HKhajGsQN4dMkcBsVtoyrKUQ9CvhCyMduT65Jo+0BDIUVOH3+nzYLGjTAffDwrTZUD+Hh8o6BcbyspBTQWllVpH0/MFCzAMG8DVWmaaUejN9A5CZIgCLNOWq+MAUmjt4VzEM0jbRiTkgIh+oJvHhVJ8Yc5Ym87re3MGdHhwBubgRwytR6IRew4qL1iceGuQiobs0MuAQnCDF5ZLMnHBolJTMoqEzTTnh+M6qYVDUopQg5XZn26/jck7kfl+HhH6NAaL5fiwaJb4JJX3h+Jo096H0QEYUCcrLeNuK7Qfb4/J/RW0bIQtgJtp0/juL8TsysccsiejYexle/yIEFDYAgEgpO3MELOtKMzLfrfbx3rLhVbol8091aJ2ZMHVlx58u23b4RYCDEzbbIsKzGoz4dnw8JCfonI3Glz8PNPio8ShbR+Iu8P5jhoc7iLTj29OmDsBK7rwmQyprItib0+qDNgoTElcpgnQ6eYMDNX9eC7iFyyjyJ6owSw3nAJr1e6/XSnqU5guFT06KSotKPx088/cby9QQispVCCjx9QiEGRCYRA2VxKxrmIu6ROexwgg6qJpIrFdJY6gCnBjD46+7NxtINf7xVVYTtdbrPDx9ev1Gb+O4tRv7sDtTDlQg6VmALXy8bb/UnZNmrt5BzZe6S1znMaZRq5uIS2Hg2bnXn0U7vzBx26mHMGtpR8i9s7Y7pdUU4nT8yLqw5SoO3eYoRlg/EgzMg49agWBznCAMbhQX+P/YO8XVlumxPZU8aCsKXFW3pVjj7RaGhQzvKYPoWPY2eJkVRWtm2hdmi1kduTZfPWvg6jPXfGHCwl+1yzVmTsRFFCjKg1cvQHfJ7JniEOZFbmiTQUkROO09Gy+AMWC/bciarnwD17q9YbYfriEXEnzMfbh6sjVuWxP0ji7IYY3AE08DWxnRK7gdIozBQowRALfLr8mdkT9y8f3MsklUybhsZACOqXVAoEJqMPgglTI63v0DqWk/NJuhBJXiGMRm/t3NgqYgLdda2qyhydJkoJC99PXQ3RfSHCqXgYzOkyQkO4FHj2wFZe2FslzEqIgY8WQTpRA0tKbplOTuKSc5GX0sI+zlAJBmtwPnOK2Uci6nl2ozUmmW2LMCpyS6xlYVkKaGJOXxbFJJSSEJuuRQ3BTT2t0qYvSqcG1uKVt8yGIcz9QKNb2FWGy+ss0erO8xjfz1xElX2vHmGfjDEmbeKHyTnPRPCDKy2klIBEKMENASFS94NaD9bLyvGEMRwOnlCiuKQvlMwaO60PXtPK0XemdOpsLCHQ9oM+je+rLeME10SBlJEOzwlZxCvccTAlsO8PDnM7e20HnYHGK0Zh2CDFiOZEzpmjVYgFm42cFqfFnT+9Dx57JadISsLeHvTpmYNtdt7fPrDaEIVjr7zvlZwjKYA0p5J9v0xzWjj2B7U5A2UfkPKK5AshJ6y5OctM2WvnOANEwzjoyFkAwuV2Q+6Vaf6dTMH3UOZH3xSlj0mQRsgLx3NnnwISaPtOTgoSyduFMTqhT4hu9R7mWuUSIqaV92/vf9yh2w0yk2HDt3w2UIbrdDm30dZYSiKHxGzd2yMdbMuKHIOj+i/K7AwghExielR8gnJ9ZeqEEHm5bsSY3B1luNUO85ehT/ZqiKZzwB8ZZpScqb05yzUncsknNBt67dgYTHwRLOdBEUSZNskKQz0dIsVEaw/MOtN8qdF+HLrKUi70ujMY5wwnEMrK6KdfX8FadwG1JAheyTyeB0GCZ2NlwUZxulPzL1ZTpveGis+dXa+Y6HuFw6PiSymEGCEU0hqp0zWJ++6QkZwKOaQfS8A+D5fr6YAtYxLZn25skSm+1ARySm6JbM1ZGqIsubCPgcokxUxYAynFH+OO5+PhI4ucXELYJxPh6N5W53N00CZIyIhG2uznmCK5tTlHtiWicGorO9YCMeEdQ62kHEnh4iOTlOn7B0fd0enV2BqDm1xiJqTsJP+80GsnL6BhgGbiUtw8M3zs0m1g0S+YNqCklTh3h9bY5PFwu/CSV0pUr7Lqzl6HK26+t5IGz2ZYr/iG3kcJVn1WL8Gj13t3O3FrDZviySrnvFM1sy6QkmEGWZ1DqxIR9JRYOSaxnGjBUoQ8KrXfmf3BeB4cwjmyiqj4jNQQLxaCEJdCH8L9aGhanAiYI2l25jB6SARVQnCN5cTdlq1WZu9cgxJiwWQwhjg/+MfwDe8G1pUUvKuL+DM1emW27lZ+M47m40nrgIYf+5EUA1EC+/Og7/55rzqxadyfB9EmhMTeGut2QbsDghgwe2LUSWuVKgJ9Ui5XnnWi5YJM2NYL3z7efOyYPAGjT//9NSohukX7GIO0LowQIShlyZgZz1o5zotCVTCbSDTG8OWwxt/jrP7Th67NziSdYXx6LgY8C0qGy4U0fPfmh9N3D7M2LEZv76Z4SymKiRJjRFujYiynkmFqcW2fCCJKXjeOZ/XcrehVZscF2CEW6uOd62Xxikgyx/HBWtT95jFztEFtjdmFoAnEznjwiVpnaEJwlUGI0X/ntjNmx2z4yILTWA8gYCpMhBQWDLdy2lmNh+hzOyQQo8/yUvTDvWGnnjPQeieY0jWieQF8ThbLRm+HXyZEmFCC0WJkasQIzHFGCAUhdH/rL1mo3V/i2afrkBE0bdg0UsiUUDH8YulHJSjkmBnmyQDTfME3HRvL3nyRM2yCuBzsu+UXPK4nBcF6dYWDCaaRGJRhFTSQRBg2CKE4VMWG7wTm6Q4yaMMoUVCBEgMahOWyIM8nP3+6olmJKBqiL/tioAVlDsEkkpeVFAMpCe/7QW2N9rh7NSte0fp4yp1+fR5+EGlCUXeJAXEMnrWiJFp/UpurMVS8ZTbz50D8nP1xEQOompPt+nBTh/giuY7hDA+brpgJgaxefOhUpgIWqXtFmD+Wc3NA0sDojhsNMRGCP0tRYZhRh4++qlRs+hihx+FOURWiCANnKahCF6Wp+AJJHJs4plLNQBMBvMsMgZwCIUZMgy+JRUjZWRxhdvrpKts52Ac/HJshJdKyoOoGKB3ieNDsoxIwJCfCECQLsw+CKDF4xS/qDIgxBrVXer1j0fGpbQrWHSw0J1jtoIqYm1bqvvO4vxNTZIrSeiMtjakrSYWybgQbcH/3keAZXY84K8LlXgddDTGlHw36IJcFA/ZaCUHZ1nxeYkqMijBox0AtsFy2P+7QFc5Z4alXVRXnC0xz6pB43T7ngOiVpuqkHpW9TkQKqHrufc4kVaKZZ04xWdZCw0k9j7cnMUQUt/oNnNEZyX5wJhfxiwbWnjAie4OjDnod5KLEmNibU5r68EotqjBHgzlJKuS4nkCX6ReGQT92mk3PSQvJX05c4O6Xj3EcO70ezGiepIFv7iUGJ2nhRKppHj8yh2t7zTzm73HfvZIwIWI/ADDuUIsY/YcbDfOLJuVMHVD78C9sNFLKzmQ4fDNrYi7VMWjfLacxYKcWMuC3s9hk7jtMMG2Ia7sZ0y+mGOTHiGPaRKadACHxVvI73CT4AQtGn6cUUOR8ECNGJEZhjRFMaGMw1NvHObtzDDS4ZrpPogbW4gqNMY1tW8nZnVCcfI8+hBgDqSwQMzGmkxWQXDvbD/rwKvKyZGC4mytMZj/o5sjFmB1ao+KsjdEO35qbv0wWEsu6eLEhoGb+rJzuNhEln7l5hnG0w23R5iyS2SvKQGZHY8IkEiSypEJM0fkE012HKWcYg+fziTF+aJsVD0X1BIZEOBfY3qUZ+z6QYQRZnPEqsER/BnR2xOqZ0huRoGgUZu+kGGiWmCqIFsZxMIfDjiQEH7WgPkb7XlidR/I0GM0zD4P4XHQOdyOCK1z6hKhCioIIXLYCIZOCgk0sJqIFaj0gKnMM11EL6FT//M3oBq3/DkPv5ruDNgXaRHXQ5sHoAzmX3TFG0IjGSI6BpWyMuNBmQw3PeCwX1Dqz27n7UHfShcAxXH+rCEc9PAFjTGx2anU4lpjbxGMKCHpa4O0Hh+EPO3S/P5wigXmG7Nk0/2shEpJibcdqdaxfihzHB8fJF1UmfXQGRtTFZ6jDkwNyiJQlOeMAl6hYyAwRjn0/Z6tux53mabWqAmJcLisfz8YMxtGqa/gkngfc6ZaR35d/1ibBYImJlFcex+NMAHBC0JiTOSDnlRCiV/ZyQkC+v2InznKeh3EcHUUYY/qDNI1hZ+vuZjRad61iComjepS5z5FPjzrJxfnqAvIxvE2yE5QSY0KiEkwh+KLCcK3yHJBSgeCVpgS3RIrq2QIN/xwmyMkUEHWc5jjnYmC+KBW8QtSzoh3mf/bo9CxfkPjP7B57Y8rZwprP/lNyngVu3EjBReMigVH7GW7qD+f3/5/iMfc2/dIKQdGcHK5yHubj/2fvbXotybI0rWet/WFm59zr7hEZWVnZDQ1SS6h/AFMmjBgiJHraEiNmqBESI34B6gkfQoj/QPM7mgEgFTQTBFXqquoiIjLc7z3nmNn+WgzWvtcjm6+UKoZ1pFBGerhfP8eO2d5rr/W+z9sbablymXSZ0RpToEQxIUmEELE2iCmRUwAZKP5Q6ZQzvVnXUfP3PHwA4vZOr4q7imMpAZmErTHG+wJhZr9HlHIOgf/Z1jvSh1dc1R9Gv8OYChdFNRCJSDeSCs1cZVPOgzmD8oU9eyqJyDRm4CeH1lyzHSRSqxEsEvFiQ2P2TeQs1FkpiyrDD/RER6n5NZBp8BhePWr01G8NTkSz4UkRPseQ+WwVb09J8NsjyrtO9yyNx14mqjKg5rqepALBK9qGG6OszkUbl+eJvFnubb5XP+0OEb8vVDlbBQsuvZvsA1UhaUKSuk6eACk5zzllJARqM0rrXNZEXq+YnKwSaNVRnzGvnkxubo7QGGGqcmrrqLr2WEVprfgAT/zx6GNQ6/C+u329J/7ai64vuO4wGi5cQCX4YhbVtYGteG+lF4Y5SQoDI/oDPpr7CnX+LFUsjMlBEoLixywRBsFz5VslqLFsix9LTefgxh/WmBOv5/CbRzoaVjcmtEbUBCbeXwJ68yotaSKGTAiJmLIfAbsfx8XUe2fBFw6dC4q9Wx39BmRGlRsugcEZN9QyH0pRd7KN7jrH1jxBIAsmQkOR93gPc5tlwHt9w/tUYy7eghIR0pJYc3JsYAjUDt21X1jMHgsT0mQ4qCP05lG0N98ofMGBLoEyxlShNLfx+rrsHAECYS4T81DoLZvwVb0weqO1xphDwhB810dcRtO6S+hCEF+shiM1FfPKyHyxd5usty66zfZVcFiSF0CR1h0FGcQrw204f7g0Y0hybKI6j1lVua4LUf0DqUZUIhomtKeN2UGcS6F1zKbPlUGvldaq/+/EEw4zRxv2hmCOcHy/I/z4f56nV5PDCW0qwRGI9hWU1K37DFiFIO5oiiKUPkgh0s6TXr0N5dS2N1t2xMkmHol+1sKSFSV4HLooI0xeQRB6F7q5flbw7//EkOFDO8Q3CcX8PRdDFGL0U45rAb3IiTPKSWLwtl/ME+GotGq+Q8xXn44uqa6WUPFrhiZqPWndh8oh+r1Yqw9eF4nePjJooznvYW5mHTfRjPk9ectaKN0TX6IqMXobZWgDApqXmVVXyRKIIdL6QNQ/QwxCTAkNPvSVoG6aUncXup/AN14JMj9vQoJvwM4a8cHhsEHvAxNnuvxii+7/+r/8z6T8hjIzGOIPtioxeW+j7A/6eRICGEqtDgtPeXP7bncZjWs6faLroGZv8geBsh/e74ye/iDzplnW5JpS835g0FkpIrzeds4+GONE8AGUAaJzMhwTMHu5uBA9Ro9Qbua5XmaOaqmlYiGScnRvuPlg45//xZ8D8Nh3/qc/+afeJ4zJGay9+Y0fXZPaW596Vq9wMHM2g3jFNYZgIRLM3wszHjvngAaXlLVepz/fj9oiSsqZy7qARkyVWhtn6wyJWAikEJxqFaJXZ+at6NEarbgUZkxHYKnufw9qWHfJiwRB1KspZ9QKrVbMOksOmPn33CfS8M/+7M94eXlxrW2c0BKzuVkl+vBQwxgCtewcp/fqzYwxCiqRmBIpBUKIvmiaAcJ2WdiWwLEXhMDZii8gwZ1yDP8+azNMIyn6grk/DqR3rterb2atkvMyFwslBhexj4FXUKIwOr24PMy6L7pmXlkY3noSDfTmxCxV7y9//8NnX2h650/+xz+hnX6aCSoE82FinSkjfmr1LLptWaaszIfJURJHcQtsPYsrTqbuNc1YrOB5UIw+0AB7PcgJrBu1dko/qNYRvGiprTkXwxpC9yO4GKBc1g0z50cH9SLmcbjpJeWNrs4RVnXOR4iRIR7RpX5cchNEdCziWSr77jE1P/zVP+N/+6f/AyoQoxLU0yRiyq6O6TY3aKFXc5aFwLokJ66ZrwmMSgiBcp5061hv1NonRXAQglfXSecJZipP+/DRX0yZx/3uve28OpyndbYl+fuwhmjiPQhFAm04Ia6UNu9bH7qm7eoUwhAZ5tJDbJ6Kh1PR+hiIOMfkD3mJ/X+UxCLyh9XLf/P6m9ffvP7m9Tev95d9PR7/315/UKX73a9/7RIUM/7fF2k/Zv/8v/u/vv363FZE3n/9vRIUt3q+65H42vN762WJiA+CRN7/u1dWc6JsU8NrLpi2+V5V3qyvvDXWvAq03x8AvPUZv76+/v/j2LndboQY+Pjx4zweA1MMPcMTvl4H3t6nvX/Wt/9VmY6+MX7/75mRMDZ/rr29YfG/y1ml/n51VijMz/92sVT0q2vs7ZrOa2B4n/v3OJXz75PZ0337s/J27ZH37837tMZPv/sJM+Pjx49Tb/pVMuQ/Yl5vM0T4+jl+1gOV9/fy80sgX399Xr+3NsR4u97vpw+bn/1n10/ev+W3S/b1+sjX7+P9PYhfo/dvzZh9aZn6T+b7t6+X7P3z+Sng8+efEBG+/dWv/D29feD5B97AMD+7Lfwz/j88R6Kzp/52ShJ5v48F+9kl/KogeXsm/Mf//s/T2aO3+T6GvV1X/+Pj7fuan/3t+hnCz7/Qn7eC3t6ymPem357dzz99prfGxw/PXC6uX3/7Gf/iZ32/P94v6O/fHf4j5X29wf6F9/T25ZlzLd5+/hjjZz/za5/Zh+5+TftUzbw9r2+3xPuPNh/ayvvgfPzchPn7/z6v5c8/1xiD73/4Hf9/rz9o0f2H/+F/xLqtnK1SSnHYjHn7R+ZNITj2sNrw/tcQj7SZ0PNeTsCmzXXQeyeqIW8OLZnaOVXUlD6EvDivIYiyXBYul5WcMqI+hT72g7xEsgbOUrl+fKb3wyOta6OVyrbo++DLVOeQarDf77R2MCxSS+X5utLwiJA3S6+bIeC//yf/hP/uH/+3/PrXf8Q/+Pf+Ae30o6a1HcHNF1EEWuUNZ5ez26NrLX687A1rlafLhTaE/XZHx0DTQuveBhDNjNFo9XQKP/reK7ofJy9nR1S4bJmYEsPqlPIoOWfWZXPyW8ho3Egm0AvbtlCHOsqvH8BARkNipvVOFCMv7rrCIKiRoqFhoTxujOCSm1FP/tE/+s85j5O//+/+ff723/k7SEhTUWezT+59ajtPYk7T/aM+Me4uvUrBlSytgUtChSbBzQetOjZQN8rpfIj9PBmtE2OmlM5xHu6amthD5mI1Zn86AKUbWgtpWQjr4tKf4fyHoBCSomlBQqJ2o5bqwykTonpckwbhLJ0+vHenwQ0CKsKf/un/zn/9X/0XLOvCv/8P/wNGcQQktc0BoFvOewOGzALA0Zq1nDyOE0IgSodh5EtmWTKXJXlPfbvQh1HLjlCdBd0GpgkJhmlgXRPPlwWJg1IrHTAJBHXH3JIjtRufHye3o3qqbwwEbRw9sKw+o6i1YTKc+odOlKMP/Eqt1P1EZR6pqxGssV2f6GdF05X/5j/7L/nnf/4X/Dv/9r/Fv/lv/OtgLvsSFcp+Ord4DIao6/dFaMMm1P5tUVRXKxksy8q6eJ+8noVBpjXzuYR4qEFrnfvrK8d+Uo4Hj31nb4akDCGQlgySuW4Xlm3FLPDltvN0faK07vzjGLD2tf1SzwdSdtbLShSjPB6kqdzp1siL5/4pNlUl6iCfoOQYeXl54T/+T/7TX2bRba0yxuJatBA5a3F7J94Xs+FAbzVzSEfrtNpZgjJqI2qE6E4dz8by/kwOkcPjdd0koCsSIo/7wxfYuDCsYSa0YtxHpcRMyiuGUM+TlK7s50mcgZm1BQwHKmjyC+LiRN81W2/UsxDESNtCK0Yvg8fDyfAxZnJOjAm1iYtrJP1lk6TkA6gYXdazDJfkPO7DoSlTVN5tzKm2YrPXrDFw/3zD6iBtK2ggx8SI5uGWYqTFNdG9exigxkS53clBCMvC43Hn46dPbtENAes+Sd1LIUQhh8WHh1NZYTg/QJOS8sbL7YYNQ3thJvWgzTzmJc7MOPW0Vl1WYvCqUn4WR+KbWmfZXM40rDNG4dgPRCJhVhvLEjmOc/bcXFLV1VDrJDFCiI757J74MEZkqFLq8FghE0JKPvRRzzAzEowtLOg8AAAgAElEQVTpMBsFGYNWGrfjwdO2EZaVRQxL3rtP0RfdMcNHY/Tvq2Nod95zMdcMm7iiBswXcRVnN4w2TSB+348ZzIgBraIh0royhhHMFSsyxuRHez9T1ZUIKSdSKV5JanJ2cTtZrlfUVmJWbDSCKhID5Tg52iDllVYrEaGcd8JY+Hy+kp8uzpVYF5Y40DGop7tGO4Fa/XkUg7AYpp0uBsNnJyEox1lJy0JOiUKjl+LGGIRjDAiBrIpuRquR4xz+XPf+Xtnv+86XlxdSdKaEiPelrRWfBxG43w9S1rlBJAir68WbDymjKq1WKuauSgmzzzsYEkBX2nB5Vifw2Hf/szG79l68Qh21c3lesCDcDi9Onp+fiTP9GYFWCqVUynkiMngr3q01yMHnHSZU6x5DJca6xPf+sY65YbRGM1dY/CGvP2jRDebZTtYarY15ZPHqLAWvBhF1VkFaeXy5ITFyPh4c+0mKGd7kLnWKxWNkCOS8sK2J8/Cft24Xbs142RvNDgKVbclo82Njl4HVOkP7CsdduD49oxo4z8JxHKwXJ415+ivYbMCLDTIQlug3414IKbFtxr4XlpRorXEe3qxP2bkP8rPmgTIoNMfaid9cKbrUKdGROKilsZ/t/Whjc7EOMTHMXXYalLM5kCaqoSkRBpj55DqERowRqdXTMgJ0vkqljrMRl0Q7i1dM68aQTGvA2Ulh0PE8pz6M2+NGWhK2bp5M0SuaHGRjeEozp5HXRFqyK1WaOwtr2/3Upl/bKKN1twfXxiC6ymF0RBXBzQiYx2vntDHqwWVN3O8HVsxjmFQmnckTlMO0jr8+TobB5brSj8rtPNGwsO/Oao0xMmiUo9Lf2ACmaJiSwVJcgheEWjuS1YlzGEkDhuuDUZvhibAt8Hq/E3Li5SjkFEjRWcVBjbM7k8KPkX0OUeZDpEIdg3Ye5HmSO4f5QMqEvLjN10ZDbVDrV7u3aPB0hRmdtLeKxYXn9eJpGcEDTOsYNIRFhVJOd6bRqCPTjsb1mvE0lyn500g3t96vy0YKSmmDx3mQciAkOI4bMW7OGbaB9eKBpcNxx2I+SNzWxZOgh4GYO+TGwFQwnQUNYL3Pk2+Y3SBXDvQwKNZcvzvtucLU9A4fRqsGJC1g8zvDlUcjNjTY3EBwT8DUnJsocdvouyuf7E2ttCyEdaO2gc1T3OiVOjz7zrX3rvzoIuR1IdDIKWJLYj8OogWaLqgUzr1go5KeNkiBQQeam7YCbjTpg3rsv9yi20Wn5s+TGUoZ2BAHmuM6um6NUgsvLzff5Xp3OVEIk9LUXbMgNq2m3UX8En2Rs46khHVI1gnJj9prktlqcVuiHaf7/E24bMKyrdTzpJfP2NMH1nVDBozz4UcBUyQE+sSuRRTthrZCWDJna15tXi9EUVJ+i/LzCazMOGzw/lTvgyV7tMm6ZBiNWipttjRiVLbLRqm+6AZV9n1ndI/66btXSmyJCCzmfNv77hliIp6kasMY3Y/Xx3ESdcqABNKawRr9HFMvnGhFfFEMkR4Sj9rRbny4XmnW2S4btQ+Oo6C90tVJcN2Cs2SHG0XCcAuMyCAukdYes1/WaY/y3p+T2TOW7lHanhisWHdZ1OiekBGdT04FxghOL0OJOiHn1jlKRYtPna9LJmonYPQKj9M4j0DoHm55u+/k7Hl4vfiD24e3SC7LBUPYjzsm8BQTYh3tlfPwBTssmXXLZI3kEMmq1Jni8Hy5oDRKcS5sN9eg1+JAnKA6Fyh5m0i8V3P18FQJVQ9EvW5P9IazSUYnGJy1cdadehzEmDm783OfNi88lrCS10gMict1Q+ker6QD7Tq17MK2JEgrZo0chTKMUjpZjZ6AuBJJU40yCBYwNtp5Q4arPFKObEumtsN5HSHSWgPETQbR2xmjVYKp80vO4nCqrrO6DB5WOu+JEITWBrUNtsvqnGIJaEroMJq44VeBIOIqIbwf20yn8sdJbo8WPemiDZYc2D6tlP2kNTAZ1GFAYrl8JOQVwo19PzCD3o1eC0dpLOGJdj543j5QzuYKjQp7OybcXebcQ+nTEPG0rdz33QNU8fvSeIud333TEl/zzib0HlgSXNavwa1/7UU3MSjn7jHsamwxeKXJFP8XL/9zDIQtUSveALcpFpdBTpnb/XTyzyWRg+tKo7iudd+LE//3neO482HzxIe9wiUKnUKz7sGHmhBVNlv48tNPfPzwkWXZPOFiuBY1L35spVXKsdOGeVRNVGrvrJcN2mC9RH56+Uz2jBjO6jt3Cv5gdTP6W4tenIhvDM7SJxUrsmyJ8+XmiQ4hUIdhM+209oJZJ+fVc7lG5fL8zP1+UOuJLM5ZXZbwDuk4S5m6wWVadgcaMq17Eq2Ik6uOY2fbVv97zju6bKzbMhGDhsXA43y4LnRZnePQG60cVAIp+0TB1EMklzWR14DMNAmJcJYTiYEUN0Z5n7iwrvnd3y/qovuYAiGuCMJxVmLKBBkMOiFGzuPEBxqVTJxyPgiSyPni2sfjTm/GUQfn51daG1yuHzgehg1lTQ5Sd6efeDqHQRPzhIPSyDGxXTM6Bh+fPpFy4FUe7i5bsovrB94KStBboRVHl6IGNOrZyZvf/xITOuawBAHtpDSBKQZfXg9ElIARRbl8eEKGch6Nx1GoA+pgZuN5rp4M4defNjeyANv1o1PuaNAb95dBzJmcInE+4FsWR2eufs/c7jf6fsz0hca2ZsxcTtinjBHxKlZFSMkcbB+dkleHeUqLKq0X5w8Mo7fiov/WsSEESTN41CvEqMETjM2w9tWlGDR60rEIyNSStweMQRleSBDUMZOqlLOy5MS6JBKROoQ2BmPKGIcokhJ77Ug7UBIdY0m+mYZt5X5WinXSshFjorROMY+6z8ldbIREHcqwxI+fbzAKMSXXSWMkBjKpfN6rKyxRqHiPvNsgR4c/5Si4tnsQg8vq3mSh7fxqDf9rL7qlVdIEl41aGc3V/DElr1jkpByd8zjpY9Jl22ANEUkKM5XzuiV6L5T9wdDAkoU2vIIWKyzrwo4Q48r5qN7Xa4Pl6Xm6iASNQqCzRk/bPc/Ky+vB9cNHzpfPTpcyRbVhpjytC5fLxnlWWnfKlATXGGL+c6Imanf9oYxOG4MY1pmD9XWhMZwdQes/U3MMt9AGczeeGlHCHDJ2iJFlSbQWZvuvQT+815pWYo4QI9f1SlTBWvVoodI4z4Kp6yR7NS5LpPdK7Qe9u/aw3A6eP3yDCZRasPsLPS1oCCzRtdXFDHk8GNbJMdFHJMypvNkbEMWr216r24bTSm0HxzBWEc5afz7s9wU1rXPS7P1PyrSHT5VJeX1F1owEPy1sy0LpzY/+5mwKjQu9N2otnjhSC3F95ro5s/b1y49Iu5HzytFP1qxIrzN1Qgi60Ebjse9EhW8/fIMEY10z99vBfjRu9wdVAkQhjMqSDIleIed08fw4yd6D9cx1zg7aGiEv3iaKww0uIWD4xs+8M4I1WgukkH342Qdn68QUuJApCqoXUl4Z5aCeBzEo67rSh7sKQ4jkmJFxEsyHj3UYoytKcufWJMqPJkRVntfE2YUcF5oN0MESFdPkxUdvtHowrLMsiyMRk6Ky+HAP50FgbvJprVGHn7S8deaVcm0n67p5dVlPZw3gbcXS+/vpZ3QHGoWYZnCpIZLo5cESFBaPfxfnjlLbOU9UzKw9e1eIhBB5PA4e5eD5m4+oJjcmtcJj7yyrB88GTaTgcJzSBqaZIAHUWIJwvz3QOGjnIOcnNAbGyBzViOa/Z5jSBDIC1dnBcYne/tKEmrmNPHj4ppr5KUIDb6ob8Pf8iy26o3qjWvqYZK6G9cYQtw+2NiYR6USHoaP5QtsGOWQGSjPfwXX4Ef22F47TWHLiaCebDlpuvNx3osHzuhLCYN93bq9zAq5eJURNnHujhcCHy8Kojc8//ki8BLY10a1iw39vSC4RGSJIMFJWSpmecYxmRl4yYcB5nD7BH96zDdHzwt7wdWaDWk+SGCl7BH2aInFN3i5QjJzj/L3NK4WQiTkQonLeGzI8Kj4vmRCVnJR1y8S40FtxqtrYqW2QL8/EljkfhdrN4S26steBWaX1yv24EXJgXdaJovMjXu+D58vK9bLSuvL582deHzspALjC4k121Xz254LyMWa1A1vOjFEZwpwIz5tChHX14WBrDYYvSO5YHMSYSUtAMOrAWw3NnUZqzmfuozHqmJKhMCfaio4TGcoWhKqR3oyonTV4CCoidAmkvHAVnzU8b1f2UhndF7/jVihN+fLywsfnC2nJbkHGlTNmwnLJKB7HEzRgXRxbyptkSGeE97SmjilHRN4DGQ0o3X9uCJEYFkwTUQpqQoyCWnTID4OQV/Yh1FGppROS0MXY7ztPV+/blgpoRWLHyMTF03cpO60al0XpZuRtZZkPv5WpMKgNi4rG1VN3Y6bUkyBeDLUOS87E4BtlOXcPpmx92r9nLqAoMSVkGHQjpoyOjqmnBWN4tt6U8r1dC+ueeydizqCYYajYQJM7Q3uDVkCItKF8/vIgpsi2rcSglGZI71yero5SLI0yGiaJ54+/Yj9navVFsH0njMiyXBEO3wTwz2JyYblkylHopdGOL6SUPQVcfOOX7vAmDQ77GUTOUpG9znlO83xIGte8ocKMmG/U5q64bd3QlKH/gpXu6B5RE8Rtjm8atd4GZ6luuQRSfOsLBQdiJ6X1gA2FcRKs00clqiLLQq2DXg6kVdKWud92hIC0wf3+cNrVUYnaZ6oo3qeJg5CEy6dnzrNwu3/hu9/+lv1+Y4krQYxlXR0nWI3SB2MIKcbZK/XJ+LJe2Wvj3BvXLTPMPG03ZV88mssCpkXdSVhJyDnS26DjYOzei+/gQEp+dGrFVRf61tdCkJgI0Xf7ZVWWNTr8Z7lATD79VMVUkRhJaWDd6f41iLtlYqaGhXL/7Df0dJKBcbbTY7fThmp2kluMjC4cR0XiwqgnIWcgzYWve3DgAPqYYJXB4yjuRMM3o7QJIj8fHul0mA2HCaljMjFhmdIuCw5vb93VCmgChhO05ma9LpElKqV0Ty5YL7THDemZGCI5X8nqJ5Q4Ky+JAfJM5B1GiBvjblgv3F++cNmu0E4sJp7WJyJKDhlNgdoO6ultLtFAqQcWIlmUep4sWwKUnMwHbt15HTr5B2NqaB324y8TlziWs7I9X12lou5Em3AKRq+M83Qb9Oi0MiirsKWFRTtLViLJVREWkeAa42ADaqVMmhY0jrPSTLgdxrrlOVuoGA0NGeL8JyhBhdhPjtKwIORlobcTke58jxAxW0jqmxUhzoGpn1b7tLa20khqNGQGtkIxdXLX3IlzSh5tJc4sHpoBozUndAVNaGjYMKJ6ITQY79dyn4jSGPOMZa+M2hko13XjbEbZTy7rkxPQ0kq3SOlGaNWHtw2O3hjNU6KvywXtkdfjQJeNEQRIRIbfS1MaNxCKwCAiOhzQXiFFnATYjNIGaYYYxORWc9c4+3wjLb9gpWtmhEmc6tWPdm/i+qTu81d1LZtrNQMMx78FVZ8SDp9mapgi62Y+DBrGGJXWhX0/WNIFNeN2P+khMFoliWLmFeCyuU03zBTZ236iyTOmzOAsO5fsOr6cHdKTQsR0OKs2JNbVM7j6EN+s5wIQUiaKYa26XEmZdtCv16GP6prILmyrx3aMqUaIc7esR6G1aRkVdTkJw2O2htAwUggsKaIT8BzfIN4a0bSgQ7Da6a14hHyAMXxAsZ8e3c4YLOviXNsYnC0s/utq1TWG4hrIgbdmLs9PXLJD5UUHS1IEl8vknNDkQ1MJfiNCR3NiWRbec8dx0pJOfaXhem2d1mURQ2j0LqDKmhLWfXAWY3IlCf5+Y/CeZgrOmeilYkSGKUvOpCwE69xedno3FhWPfOqd3jujdm5H5zjuMAYv9wc24LquJDOHrNSCniAsjJlBh0L/2RRbksOCRm9ojiwSJ9CkU22+P1FkTGjQz56PEBO9TvtuUNruydmYR6cjSm5+3I90hjkNq+0PJHrUCwilV8S653YV/97rSIScWZZESj60/ulLpw+XJBIjT5sS06BWmyzdSAiBpn7C0LxhrdFVnZGrgWCVJIMunRiEMnBZ1qhI8PaFmflMZkxGgQSXA0ah1ckrSem90h1mdPN7YVjxZ9uMS84O3ZHJGgaWrHTx69ttJp28U87caIAqEpRehz8rKTPY/LuIgbOBhoUQNkyNEQqajFgHx8BbYl1AJg86R2qx2c50NYsJoJGQA71XpheZWjoWFvby4LqtYIFyNkYUhyVZImmcyi03srRfMg34DV5C94k8w3Fnqs4jxQKYEMOCaPQvuFXacEG4g42CM1cn87UXh8EYnWN/+Jtvlb3uYK6P6ylhbVDV+QmKTyX32+BMEUuJUTvX7eKhijpYLxesdo7SyeviD7d8FdCruptFNNCa0UslyKCV4lBxeaOTTeeO8fsuu8GUgXkVN5qhMRJsDldEGcH7cCIOuBF1kHkbHgkfupHXzUEb6rIyj7b3ya1NZ5mqKxXKUSjnQQjOoDhup8dcR/PUYBPnYUy+7vD8HBSPvIZG7QVGJS7JyVH2dXDQeidpIizZB4XW33GCvZ7EpD4gafV9sWmT1G9vPvTpJJKgU0Uh7zzVFOPkMxhBJkEqJpCEDE+uGLXRm1CI5JCd9lWqV6Nn5X4OGN7309nfL2fhfj8ZIzF6J6WNb57z/JKiM1pRRvdKOgZ/jwNnPYTJSx7tnEAB7zMOhKBjMggiJl5gCNPnP8bvpQGn5HE8R4fcXCc7hg8/mSdxjdElUb0y7AQGwRr18WC0QF+u0Jw7IcK7uUhGQy0io9PPAw2dEDdqDyypsTFQ69yPhqBod4VFsOYgVhn0EMiXZ45+Qnu4EUkSQ8vcMAdJxOVY4oAdDW6yECKjV87W6GP4d+ZPhvd9Q3x3f9XumXZOcWz+/GukjUBKYbqpdG4YUwcfZ2KxRN94hkPlY3Ta2RpcGufs5GeiZFIAzRcog9EGpSyE5nAeUeV+dEA5bju6utY5poyoy0DHURlmxJRA35JwKr0UZFQCHj0FAxOh1sYywxJMhRgAUR8YBj/tdZSz/oKLbh/mR8Thux0SwNz5o6Y+iax+NFdRHqWRJNBp1NIodZAj1F6ptfvRvBZq7zAavU6Bcu/cWyVa8QpxNHQITSEmX+zbefdhVk1oiuTe2I9EyIElRFQCJkJKkZwXeu10jJTyV03xaOSUKc0Xpxz9wmpwvKCTpZzhKni1Ct7gTzk57bD7EMqBG+5sEfM+sORMb92tuwI5OLrO3YuCHYMYlWr+mdY1OUBkitm7VUo5MIHL0zP1/IzhR5r7fs4WgVPeKjA0zM3A5gMPAyWZV3P3s9Cpvmnh/FoNik6R9xCw6Bxa8E1E1SvYN8yfxvQuDfLNx7XHNo+9jtpzPqrMCrO35v8orFcP9bPaHFwzqwOfgI+p7PC+e44LrXnaQpuOId8MPMEBjXNQM4gRkIXWfTFIMXF73KDAx6dMXhOHwNEr0tp0+M2suOELbdQ4NbgD0+Ba9MCMWnL9cR84lc07uoyfEaXUjBjFEYJnYzEnpJkIynBQjghh2ThL8BTqcRJj5CwFHY4WZAzOOgec4tKtGAwZJ+0YDKvIsvD84SN6DGI4keMGTTmbeHJG6Yz+QLt6EaBzaBnUH/Y2U1+InpogrrnVqTiI0VU/Ku5Wy2ugj4WxP9DRJ1NMHAuK57O9FSW1ds5aHavJ9BANLzakB2iNOtvA3SBo8MLFFPDCjTGmIDxBTKxLJG9+SpHorj1FkbSwaEPY0BjpYefx5Qv3Cg1Xp/QurtBo+OmISFoWl5/WmWSj3QNqa30PzhzDiMHo7SBE9ZZKcFCPYx0dvNWaF6MxuIa4tl+QMoZ5RnwwjxmPceL2Wp88zQDW3FJnbrNdlugLQG+U83D0YXMFQauds5z+sDY/JtJdV3c2Y03Ko3XOalxjQKzQTWnmpoVtWzATxnGnB6/0svrx7zgKa1rYtjyjWPyorCH6ojc8EdYX1c5IkRiE3twd1cbgzYw+fPXifXokgibHEAb1hywHpY+GEGiTMum7oJtIRGVaXZWweIqG35DewwxipGDUcTDi6gvX0acjKbrYW4P3qCXxcnuwpEAP7nJDHE49eiXNSrNNjisxUSaAOSzqNLcQ5oLAfNjwjSIofepVYxCX7PR5DFNvkcTpYZ/P3WwNNaetSZjC9oaFQVpWb6mMDuPERqLPa+otZHd7BQJoRlIg2/BKQ3GNsMD94fId1oVahCVGcgpEa0SJLNkoR+dlV/bbF5b1E3WshOZ8hBgCvXdqaww8PicGIZs5/lKcQ9uaVzgSI0p3OWOIwHAXIkxexhvs8mcNhuZ97RCEWk63t9osuIcD1IMGYtpoKRNiJQ5Dk3AcDXtLy87KsSthufjAOA6W6Jbzo5kvqvmDR9VwozWBeCEtCxdd6Rq8cq7Fhz3D232qPvwWTndSWaerL0gp+gbY+2BIJwxnLDvm1KOQQszYJlg7Xa/f/QYIEhhDeUtWGWO4LE5cgqjBN+E+gPZmpxViTs63CHGeAufPeYPki9BMWYInUeSYENkok/nbWkSGc3plyQyJrAPieVLud0YInOWkE9mrV/5xhRQXb9/lWVFPF1xAwaJrbwP0UVBcrWOiSEiMgPdz+5gpKJ7CMYYiafKK7atj86+96OYok4MKqFcTo/nDbKMRzVm3PtmDGNxiV0sjSCRpYPQTGy6Mbr1ylEIErDlvdmR1jd55EuLKUXaqbHwI4vhE685GyAntkSZKbyfreuHpuoJ2j44Zrkiw0XkcJ30YeXIw6xiOa4veK1aBHP0S5GVlSEBlvBsbMB/O8PbQAW24w0VH4DgqPvnvLDG7TOesBHV5nb1JjGalHBRa3acEyWExMo0H5ezk64KVTrLB87pixHdbbQ5+FEoxosvG/VHp6goBSqMUo2oEiXQ1d7/FxNEHg0HvkTwHWy4CdkzdkgQJnhCgYqToPdauShKllYIGo7VKVONdlDnbJbX6xioTPT3GIGmkt+Ytk9G8FVAOJCwzjULcgRX8GKsxkYMfic+7UQp8ugbOw1NnUx/UkVjSQs6bT4m7kTXAKLR6o+w79Xbjun7D8/MHrB2c58F+VnfUBQiyEFJiSZE1RyRGynBbej3udBGSZEcqxkSIikx1g5tk+NkJ6GvVL+YyMR02020zQTyvrbTGKM3dit03/iSDmBdGjHRplPYg3l8IfUG2C+u6sW0LUQ5yFDqL63OXzLZdCR2WHFkCLE8bcslca6GWkxaqZ/elyTGu58z/GrSy+/cFjDhoNkiS/HhcCiP4qY0JVPJ92RAZpLR6S8A8FmpdNuigIb9DpXSe6MbwtSIFB5OX5sOwmFdSnp+9eohmILBsFzdVHOcEB3nPO4TgFuwQuVw/kGt1d5jN/DcblG48zopJ4OM3n7ifOz/+7uS04XOPZoSkiDhHezjThlIHx1nBKkkHUcx9dOIKD6Oz5eUdloN6+yXn6O5Hm1FOBow3BvQvaI64rAtMSc8YePqvJiRBr53jcJ94ipHyTj0KlFrIi1cntRwkTdioLsmai3hthcjg9ThZ8oVYH9xqoJ0PUr5Szob1QlqFJXlyxf2+00LzRZnB7fXG+nzhw2WjlwdFM6X2ySGVGQ1didOWOJpPNzE/iqcUuF439nPnLI0YBZtZZxqzw7vnqtu6oE3m+58MWIGYA4/H6ZxgcQZFCIGclner6TkBLtt2waRj0lxdcYLkxdsc+8EahLQ98VqN1y8PUt6w3rlzkLaFoydO9eq90ciXK0OFEYxq5tbSy4WwJnRdsddKPyrL8woS6HY62DuBJldKmHREfdBouMZ3W/LUPx7QOvtZ3pea0bozB8zmEbLPqX70h6qdDrfvcTq4BlmNs1a6OkuWMe2nGMOUYYFqkdGgHzdGg5XA/XZw3r9w/fAbrJy0JtQmxO6hhK1AbAfkK90GW1y4lcrH509gB/e9M2SQojL5JV41lU63k0c5MHN5XYrq/Vczeu+TaZux0Rnip7n2DmLFf5gkggk26oS5K8tMzj7boDdvHYx6+KS7DeIWOCSw5A9oh3bsvJbGkhrP1ujnSVoDaftICpu3ZWLnEjKLBF4PyE/OeXgt3VNLzgdNlDEVNrROO3YClaTQoyBWuR+dEoQcPX7KWqCcg6fnC9fV75FhgiedeSHSW2E0b7cl9S2n1uaJ2fNKqAZkDkpHnw40dQXFwDjOwmW7ABGNQrTO6K61lxAJ25WAsKmgcWHENzdpZq+NS1o57o2cA7XB59cHRSJdI61XztLQmCGtLE8RjkbXyHV9Zrs+se+ODyj3B+1RaL1iVmj2Bk8CrKLR21qmwrIGqnW6Rc6zc12dWe0bb0fVVSa96S9b6ZahXPNC1sF5FGqtKM5NsAS3vbj54OiUvnvEheDBd3XA45XST/KyMerAqpEE9rPQ+qCOjsjK/WhocAPFBegMvpwPkoCy0kqn1J24bmi8spfG55cdYuc33/09NAx++uEnrr/+ho/hirTiPSI1oi6+4Fon5sSaVx63F56fNlrvnMfD+1QDB4r0NntLwltaKeJSqSBG2ws24Bz++5oZooMgATHvI8eQPUlXAqV5dHaOmRQCP73+RLpGtuBmi/xxQeRgtN17tdvCTZS6VWK5YXFQ7jtp3YgfP/EXf/499dbI2wJtUAo8fcjYKDxePmPaeP74R9ReUClIjixPmfvtQQxw1IPL05Vqhx+NNVLNsNYI6qATP5Iaa8wQhDLbD/6ACaV6+ulb707Vww4fjx16YdRCXDaPdJfgx111S+mSXc3wttCXqm7ZDQHOG2drpMs3cA4WNVROztuOhMqanyg98Xrv0AJHWdhfHjws8Out8Pl3n8nPH7nd78QM69NHOgcavZqv5539MYjLQlrdyhqXlRgDjAZBfHFWP84OG0R1BchoNjeRrxCkMbprUQNEVurj4NEP10HPK+ZNFR86SQeuhHgAACAASURBVFwRaySpXJ4WSvqO8Xpjb5XrevFNvt7R5cK2PREuF+z+oL7cPLE4JP7qL/+K737zkf32I2cc/OXng28+rGwfnylJqL0RohGfFOuNo1dPPNHG6HdUElikmZHCyvUa2XJCCE5GM0OioVYIJpRq9LO4lKtCK24LrrNNCN5usuEG6S6QU2R01xNLSNxvD44KV+1oyj43mBmCIA6FErfmrkvilIXWOkU7Vu88pwtPHz5x1sZig2+en3jtwuez81J2Smvkp0/0B5z7jfTxiU/bM60qjy7cmhL7Tt6eGNbQVmnnC8dxUhXyGLRe+PaasXahN6PVzghGHIAFzjJYklfEbzFTvcFZT0/P+aUWXT9keZ/GFnezyExDqN2Pi1igmSLxynm8YI/PTvgybwWMkMA6x/6Z2+2FNa1c8sIuSkiB7fKB19cH3U42ET5bph43UlTWEBlDOPpBlMElKOd5Q/OVWw38re8+oq8/8cjG9cNHlk348csXfvXdr/zP9oNeD0bZQSMiKyqdbXVdcSluWY1J0TFoA3IOvLFR4yT5qyh5XenlZFk8l+q4u541iUFSkgSESBpGTq7DLbVxnDsmg8c5OGynBQi1cpNMWhQ7btQ98vz8LbqufDkqdhxcg5IvkVcLiP0Rtewk2wlj5/Ltv8z6zR/z0w9/STlvPO7G5cMTn/6V3/Ltp4087tx+/JEcI0VWKrB9nM6o/U4bg222E+rojr8c6kNT7RBWgrqbbJQ6YSW+iLRuPumWyaw1b2M4YQpC9AVHXT2KSqKPQpTIqp0wqkceaaDXk34eiAnHywlcGP3GHy+D51ixXvmpG/+8dJYAK3fKMfiz71+4vR48LRuPuvGr3/6rpEvikwyOZeM8Gp/vB/fvf8f2/MQ3H4wUnS+QoxJFEVNCP9G+YOpmFlcseOUaMZIapXYflJgnSQ9rb2su46zUKetborKP7tEvfbBeFsLThTiHO0dtpIAbWk/jdn9lWb7DLvAolVKvhEcnWmPsg80yH8LKEzu2PRE18ePvdr69fuDjh2/5TId6sHxSXtLmG4IJtR3QKzklclRSvSMzBfvy8SNtVJqurFSyGq0J5+NBlH2eOhIiyYEuDGqb4ZXRQ1zLvmPdaXJvrz4XzyUvCINep+57FHQGiY5e6D3TZPigW4z9GORF2NaFkFZCmu7B6RCNy8p5f+Wfvd74cPnAEjxqR5Lx/U8PztPnOK0rP70++PThidtFQZ7QMoixc7uf7hQcbhU+7j9RHzv1eFDPFzQY16crcVG+vOw8pcRP9y9s31xJPWLSyKvLO6U1XJIrnM0TVXIKPB7HL7foesZQw7rQmhByxnrlOHcPJxxeC97riQfRKUd33euoPhg5HjtxzVwvTwjeK6xn4zkqxIH2g6f4iT1/YdMf2Z+fefn+hQ9BuN1vPOqFy5r4kCLCwt5uXNeN7779DV0y9/3kb//mX+NRG/V40Gr06WU9kXYSbeo6R0ebErRzuWy8vL6y5sgYsD9uLgGKCes+yU5JSenrIG0QKNVYn66UcpK2K0kHfQwuy4XH7YE12JaVrBEbnbMU7i83igmyLn7RJfDyeOU4P/Pp2z/mkq5kbgzd+eHeKAd8CsYpD5ZvLgiFn378K8bHv4XlbwlJuP/ud4goSRvr0xNoo5YTbsLveudpE66//bss/c6f/67wpSXyWcitsYoDZXRZWC8LmuLX6THde5p4m6S34dmUJl9bukFISyYEpZbuJoPpmE4xM2pBMEo1lOotl6C8vt5Zkg8hgjkrwIaxLit0iJdErp0nGbTbj2j6FuuvPNrG5x++8Lxe2V+Mv3o5+eHllXb8yG0c/OaP/i7ar4xmhA1yLVy3hW8+XThL5nHeSOvqgJxysEUh5IReMqMb+/lg2zYPKh0n8XrFanNjSIDevKqXlBnmQZlvr6yrB3LitvXr5dk3ptrcxWVQhxt0xnBTxhozf3F+5kP+wDUs6KUQ5E6/ZEqDsq98yh+gBnqFlJ7Q8crnn75nPIw+I+R/fT74Pgjf/+mfs3xYuUfh8ikRF4gpkrOwhU4QqKdrgccwbBw82g1br9wfxhbNq9+wuDlhePRUr8Y5Ot0UGeLBlkPIIZC2C/1s79X8smS2bWPNixsepHHuO6V55Pt22SjHTkgrDCNyonllhCdMMl2yc2q3lbhE9sfB62lco/Cr58TnY+fp8mvqfvKlCK/F3Z2rRl6AU5S9VV5O5fOrwP0HFj3h+mtsZP44e5vj9ctn8prBMoNMyBHFaWarBFL0Hu3Td98hUlwWNww7C6bCOSv6pFPRIp0yKhp/QbRjKQ+yLkgIWC2e1aRCDonaK4PiyZ7lZFsDuwm2PBHWmYjalE9PF1Q75TTitsHlA30vLOHgw9PG//HDDo//k99muNfB49zZYqZwQt54zhe2CPfj5Dgf/PG/9A3fDuGHh/Grp8jHP/p7LFl57d/znD/QF/X+TDv/L9beNFjT867PvO7tWd71bN3n9OldLbVkyZIcyztgjG22YE9ggIGpwUABYSYkpBiYwVUkmYGQTDEDYUhSYVIFJDFLKEhYzBIzrDbYxrYkW5a1WGvvp7vP/m7Pdm/z4T4teb5RFZ3v58v7Pu//uZff77ogRqTOiTTU7YJS5/Szgmpa0yv7NLZB2uTjMpnEt23SrCMQmSG4VO+LIRI6S1GUzCYzTKmRRUZoFwnW4kIS2N0pKjiBznL6/YKuayiFwEXLvAlUvmO2v8fZuy5QCtDKE8hp1BDfCkR1SFYolk6fZftwhxs7cxYezq+d4rkvXiHqnOWTD+Fqx3x/D4xjfGKT/rCHW9S42uKlJFMlBwfbrG9skCGw8wlLx9cwrmM2W9ApixSKnpBH2uwUjM+LHq7zxEbjScbcL3EQvkIocxaQBpOro22ipOnao8IMr9DIerlhUSVokastmfNgA5kZsDxcoeiX7O3s0NNgmgXCw7V2yFIHfdnDzmo2mDM76Li2XzNrLEF6cu05M1phKYNBqVG9AKUhLgS39jq6cEDMZoxKwZKMmF5BpaCp57TzXdqZoEFSlBLhBDqTCDyiW6QWmlR07QIfHSYrkConoo5afenPdY6iKBAYrE/Pc9t5jMloaofvApqUx5ZKk4t0kTvujcilYWU8Zjp3bKwOmYk+QXiaJlItoD7oMDKnExnLwyVWh0PcbEJ9AIe3a6Zobk9vsFjsUbNE/1jGfG+L4aBHvrSEdS1dXePqA3RdUzfQeIVbVGS9HiDJsh7egzcFmUzmX6GytEuJjlymVazOUu5Y+sTSbVuPcF8yaI6s0zEm1GmMgig8RW+Itw3oPro3Alsn2JAuQQukESCO5I4kqavtLHlvgMwUk3ZylMBZpZ9pnIQqNGyOVrjWHNI0EpMVZKZjNHJMpw1CjhFFwbyO+AmsrxS8cPkSQmeUuYRqQbCATwWhwXBA6BIzOYSAjSlfr4Wis0mCaogUpSKT6f+EVJSlQeJwQZDF17CR5l1E5xBdSKFpkaIwIJAmo17UzGeLpFdXBcK3KUenIbSBrMiPzrQEsV3guzlZtBRRQsxxcpmw2KFvW7og2HGOdtFysJgyKkdkw2WaqmI+n2N0xmh5SJav0symbN6lWS4Npq9x8YCL91ykqwKdnRKDReQDfAjM6xmxtSjdp3aWMG+QQtAv++zPGvrFACHS9k9ImYy9ItI0lqq+c1aTbnIJkOV5qhXHBN8ASTWfH+UdIxGPzjNUnuFj4NjxZQ52Z0ym+5hRTkkfYYcsZxnbB9vIYkBejLGuYn1lnWx5xGKxR5N5GlOQr55mYywJdUPRX+Hw5hWszFk4jetm9Ec9qqpjUc2REvK8RBWSztcIcuy8IR9KBkslKiuo6jmqzBlolUoQwSEEaZUiBSomyaeT83R5WXUpCnW01HVdR3BdkogKjRSOzAiUSKyFI44KxGRvbduOqpqmHrvOCM7jbU1vqWRtmKGMxvaGLKYzFnNPiDl5dZut2YQ3nlpnVJZsdYr9pqNtZqzka5w7+SDD0Yi92T77SKbtKnl1i42llot3n+Glm4dcv3QbIXv4xjLbn2EGBbWIVFEio0KqljIrGQzGZLlG5VDZdM9wVLgjiIh1CUiuiNjgieLVSxMlU+RQqoBzHbMDT1H0qFuHbTqi8wQhUGRoqZBLffrFmNgo+oWmDh5ZZBRyTGMDOrcMUBxERbcAn7f0lg390Qq2DdzYc5w6LsjcnGY6YHN4nLu/7CyXtq8ypaVWJVkecXYfX9cY2+AqjxM50uT0MuitjGjqFp2Pwaj024gtPpTpAvioKShJKQhtDC5mYDuM1Dih0aRi6SuRMR/obIcXgVwYjBZkvRGtS/wCY/SRxTvDGMms6+iVknE/x6ichYPKziE09EfHIRp2u4qbU8vZzXXOrq0wOZwzD4rl8XEyqXjgvjGXbs/YOpwzHpf4NuPYmsEcOq5fvop0knp7i+2DA7riNNrOkaOcEI9h4oKiDJCVLOyCvgzQtQTfUQ5G2LYlKkE7r8h7PawMCO/JlKYo+wn+7juiSyiEEL60p/hfOXQ7F/G5Rto6xayObuSt8/jWUmSKWoILHVEOUcrTU4HYWWIwSfcsJUoEjg37lMMese44mNfMvafb2+Xg4JC7Nk/x7M5lUJqNQZ9lGZk5x+HhSyijGBQFSnqm01s0zS6bx89xbn0NVSQ609L58/Sz4+zYmwxkJM+W2J/NUdIzGPSopcGHSKE9wiat9u72DhlguwUIkbTNKvXm1R2J0tH2SUiJyXK87VAGnGspckPi4KcefYKipK2GD46unhGUxEWBdZb+cExvbcj+3h5n1/rU7R4rKyPWhiu0siRTQ4a9MRFPjcfIkg1TIsScg9ywe7DH9pXrNP6Au8++hYP9AxZdSe0WiFgiMk20QMiIQ82gVGTCcbsVxIXlxHKPW9cvERaHlKsrQE5PZfT6vYRh9BYVI76t6ZzAtk3Ssmvo9/uvtI+iytF5kY5mfKDu6hREz8sjkPkRozQG6s7R2Do1obKUJ/UuXZoGZah9Q0+k1s+8rrhx6WVct2A4HIDKuDnp6J04gejmKLHN0EjqtuPlrW2WJ5aFX2DNiLNrcPd991Aq2CGymH6RoYa2O6AsFURDM29oosfGgCokveGYvlIQbbIvL+YJ1qIMAY12HUaqtGsT6bjqjkopPRQCbQpiZ2lVJAhFYTJal2J2Mibzh9IZREVwgcV8RpkPWV8aYQqo5g0mFkzriokasNx49AKWoyfPGkJtadscsZK232Xd8YVwm9W+5KBtuf90xlOLyE7jONx/Ca9r5oWmyAV5KSiKgvFghfFgDe3mbM00i7qlrzMCFTIYuuhpfUR5hwuORdSoqBnkPbTW1DalbbTKgYSadF0LUr8KQZIk7Y9IaZTORnr9DBU7jC7pbIRmRr6ySlaUqGaOdQumhx0mHzBaWmZpaYmD/X2uXHqScnnE6RP3cNfmBoeHEx599mkunL6L3UPN+siw3TgKCRc2l9hY7fHMTsXuzSlVd8DNZ28z3T+gmewio2Nv/xIiL4nVbfb7nmF/mVwKmizFFkQQ9JdHWD9laaWfjCRKIXykP1rDhRnyKDJZt44QJWWRwPsRTXAd2NeyHGG7dBEVA5lO0OJgLd4GvI9o06PoR5qmoprs0gnFsNenqSYonVGUfco8I1QTMilRHhZ1Q1M7hIdcNagu8tT1PSSW7bahdhPqrsaIeDRIBE01ZVRkZHnO3hzOnzpHX8544qWGb/6qNzHN4bkbB9x//iTGLrO1dY2unqG0ShoVGRiPB8ToqeaWw/0F/d4Q6z3SN4RocDFBMFRmiDa9xUS808OBO5JMozVNt6BpYwrax0Be3KHiK4RwWN+SypiJHaqMZDhapWotvXwIvTH1lZc4NjjNrVuWorQMswotG5bWNzlz6n4O54anD6+jlxqOC8nLlxa041MMs/uZ7rd0cUrnG0JWsHZqhWI4orU9TFGg+45h6TlczBiOV9g0gXpRs3T8BLJZoqlsAquESGwabLDJJ1cYvBRpdSYzvOvQRZ9Xswspg5llqVgS4h2sXcQIkYaNAmc7FlWL1pJo25SxzTLmswVEGI4KCC1tNWU4WmJYSqbKEaQmLnaJuSYLLb21u1gZL3PJ32a2uMqtwx1ylrhYDljLN7jtlzh96jjjoWH30i6DoiMrCk6urHPDeXr+Fkaml5HKJMvjHmSGKrT4rqER4KMF2aN1LUJEsp4AoclMTm4EjXU4G5Js8ohTkN4+gNcUWUY0kapuEnckCCSJIKaUIBOpJKNKiYyatrLM7SEjMcY6gx4ZRCM5LSVlf8Du5ACne+jWUHiJNIb9K/vo4ZCXJoesjhviyoD59Zf5ixs1n3z6FhtvvICUitNrOWsrfZwK2NjRIyJjzX7VMDvcJc47pCzITI9F7RmNBb2eREWBjyR1lRPk0jC3Hf3+ACkj1ga66MELtOlTCEUMr0ogUSky5oPANR0xWjrfURRpEaOzDG9bFotpSoQYRcSQqYy8kMhQ080thcnZOHWRm7eusJfdoEdkNDTc27+AK8acySJTG9GZoV/mDHONMoazumBzfZXHr8ywO4JrL1xhuFSyiBnd9g4y7LCydipB+xU43RF8Qy4Fw2FJIKMcr7Nod+hpTd1W6fJR1WjlIdN4H8BosiCg6xLD6Sj+KrLXMKcrlcS2Ng1AE7hTQtdZjtYxRbMKQ16MOZzO6WUFMaQPvd8bEbsOaQq6oBBtS1d1zOcdPQqC79hdtOzXlpM9y3brqDtPHZOmJsTUXotSMs4kVkZa5xiVhtIs+MTnXuZr3/9tSBNZMpL7z2yivCNIw+qJdUbDjN3JgtY6+lqloLiQyH7CtM1rT9vMGfVzhFAsukTY0kYfDc/w6rBJJS9AJ06CbVGixMfEGJBeEQj0ijwFzts2RdSKdFmVxRxjDIvDmhPnj7G7dZPZTCH2D/AisDiQzPsl+TIY4bFtC6HkZH+JvB+5vHcbxR5ClYjV07S9Hmr5BGHri4jekDDexKwMKIXAtx3V3oypcuR9x9payZACJfdpKkcmGnorS0eNHE8MzVF91ySqWdvStYGiLNExpv77ncYQaReQ6ZTOcCExgIP3NM38FeVLPa+wbUQVKqlysgypBWbQp1tUyMUUNKhBH68MrrOMyx5aOeaNZXBg0b2I3b3CYjFnw0/ZW76HvLiHe9cGnFo6x+3ZcU7onC97z3lWzytm+6scXL3NtYOO+c4tdqsZy6pl3FtlUS/oCIjYgZ/RhICXhkVdkWuPqi02BoqiTz9T2BhSjC6ksoCUSRuTTD9fQhkLga6x9LIBg0EOuLTqCR3DcoT3ErtIx1l5MUJiONjfJWaKMkSqRY/KWvpI2r1dgiyYx4yBF7AzYdE5vB6wu+0YLnua7Rtsbp7CjCyfGA7x4Rz94z2M8qydOcNG7yYFFY1I9y0zm9FaiWkv0ezNIS7R+IgaSbrG05kGVWRYUqVZxUgQOUL3UMoQETghAYeQmq5xeFEn+hqvHrO4zuKsP1rkuGSSiIG6jZSFQmYKZE6ImrLXYzGfJDFAD5zqEEGSZz0Qkt3JFD0YszQccnlyg7vkaY4tLzPpPLnJWeicrUOV3IlFh8w1K72Sqzstk1bTO3mCM+ce5OoLE5r9TzG48ABq/5D5ziG+PSQfBPLM08/7qPEa1ufJK9dXEDLqukajqDqHVAE5GuBcS45COo9WqT5dN44YPRKJC6/hSjdGQZ5naJlyMT4CqNRVdg6dZcSmQ+EplcYUA+pqQpYPEmDG2lTPqysKpYlkzFyLV5JqYZnPF6wXffbbluuLjoNunoh4MSHAkhUMglMctg4bPf3FEP+iwseXeP+3reMHQ44vGQayz/50kuAXtSIrLTFamiYVHqy3ia5ft/RyQ9U5hFK01lIUhjzTiYR0J3sqDPJI9RNDSPJIn6AXRoE2AlzygkUirQ9IbxE+MYbLMkPqjPbIgDCbNawtlyxmFTuH+9BXLA1yrhxssdcKynpBKZ9Dq7cS9DnaWY05ex91V3E+/hc+3XuR3WfPs/Lmh9l8ZImb126x/8SnOPXGuzl/931kKjCbNrh2QmwmdICvAs3kGsMTJ5HdhO6gQpc9RqOEYFQepNdEF/Gdp7UObwN9k3FUwKIoc5xtX9lKSpkuyGI8go/FCNHibZ1APyFZLoJvcbYAPEtSUhpFqwKxFfjW0dSO6axBuh0KEXEhsmpqqnxAN7+EkGt025JrfsL5B95BXQpGixc5NV6ntmuIPYcpTnLrscgz1z1vekOffm+NYus204NbzG9dpljKiNmQsY4c2obKpb69wxENqMKQZQnN11cKd2QA0SGZM1xMwHLCkScs0RfSe1hAz0g6n56vVKdOYKcYwHmF7yIhCNoI3X5DJh3O1Uys5vD2FaxYZnZbsj6EZTzPXb2Cy49xLM9o54620ZzYHLNx8QTznS1Ozp9i/7MfZXX0Ad7zte/jFz78OO1kmcLNOHj+FuZin6Vhx1J2wLgHlYNufpuF7hEHJTSeWM3Y3/EYLZjHguAFEYsWGinTEZGPFuvTEZuMguBTkWZQaDqb2BhfWlL07qgGTCBGR+fTzsIHg44ghEfokjv+97xM2WhVlnTW4toGKST90RKnzSqZyVE6sCwcotdjoDXr4x7CFFypFXUdMAPB5lAwawPzqWWpcWR1x5W7TiDzEflTv81bP/Dfs/UXH0aU61zZeoyVsw9SzXfw1uK0YnZgMVOPKWB6uMVy32ADGO2pW0d/mFHPW5ZySS+LKJlgPt6pdJ+BIIgkEXjNhq7RiiwvjrrqR3VgL4HEXtCZYjAe07Y1Vdsm2HUosIsFuIboHdJXGNcRAnivyIQkWE9cBM71H+B2d4lnb+yyb1ust8gILvj0/QAmk5Qm5QxNgJOi5tLVp9G5IOwHTj6wQRMc0mSsZgJ3VDOEkpHpkHJB13j6/YLpbE5AUFc1mRaEXBNtIlpFl2A73icwTxTyS7bVaZgQA0LqpPUW/qjb3OHb9ATGNgFfTF6gspwoNaUCYyRCpIu62eQQ21WovMf29haHbY0+vuD40pBJ/w3si7dxNpzk3EhzcjBi/693eOy5x+hOQv/m55k+VvMt3/yjfHLlLCb7dso442DngOXlFZbX1pi1U2rVMuqPcLOkvi4zx81Lh0QkqpTJ6BzT+Zw2JslC2xaBojDyKJ/cEYRFxjIdLd15ER8RxkL0KUspBVElPob3geBShEhEUklCgooBFTXRB7QpwTe4ekEVWrJRgeovEVGcWDrFcjOlzt5KhmLWzejl55lvPc0Dx97E8KF3M+vG3HhxzOx4zua5NW6flKyXLdMXbvDUo5fo9p9l5eQpllfm9EY9zLjHZG+bWXNAyCJeB2JmKEcmee2UxGQaGTU9bVL0LpJWfc4SjxgMqZUpE3ksfRBJXRU1TeeJrsGHjhg0MRrahSV0Nqnlo043474iLw31rCV2kjYesHdYky2tsLI6JLiSQZEzbD3ZZI9YG+LKBsPBCKm32fvUp/j8+kW+5b57+WIx5tq1X0Pf8zouTW5xfHCOye0dZFPR2/AIoWlFTTFsMD3N/r5mNuuoWyi8J2RJlupCQCIw0qXPwRiktOkkpYuomCfco0vesiLv46RAWncnuo3znqZpiUGiTIIJBe/xQtL6QIYGlcBMk2qBkDKxVYTG5BlGJ7U5SrFUZAx6GYXR9MYjRsNlSlOghSRUL7DXbvLEVo4/lbPTCJ54bMr+9X1Ony54sisZe8XlP6443YPJS7sc3tilaqeEZo3JrRrTM0RZ0CwUhZqjc5g1FvyMWZeYwEo6hOgQhU6cFqHoZMqwK3UEwooJRqmOGMOv2dCV4tVOdcLlJfg1IqKyJMDTmcSR0xsMyIuMEAz9YR/VTREmR9UNwQdsVxGtptQ5hpYQLFXT0fkerW1xvgWSJNHHBI2RQiQ1jw8UMSJiwSSOCP4Wi9mAP/2j3+eRr72XGLKEgYwOYwKVzanpIXxEOkkMNS566qoiIuh8Q2EyRA5VF44Ym4HcGJrOIsLRQH1FxijITX4E6EkG09ZbhLfoO9vuI7uAQICS+KCIwpCRWjzSaOb1FKMiwke66YT5dIobj9noNTxwbp1J/hAtD/HgoOCk1iy5OfWNluv565jmdxFyxbfef5qdv/o5eo1CHL6O5vhxcn0b5Q4QcY3KzqlngmNjSTEoyPMhBMXaeAVUgAxs26XBGtIAVUKgjMIIibAtPtjULIse55M55JVVjU2xOq1UAk8rnSq9QiVNTOcpi8TEBYn0FrxkNl2gspxCa1olcV1Ft5ixZzMOF4KhNMjiBBdOT9nL+zz1XMNdK6fJs4KX7QOcOH8fL1eWvZ09Buuae99+ihMbBu9rRk9e5tITj9Jev8E999zP6OwqL88v44Njvtjj9uwA/IxhP8dnCic8WaZQCowpKHJFVXconwBPIsrEGfEOF2zisEqBkhJ5Z1ctBKYoCV1qPnqXtputjcioiM4RbI1rW7zLiCiy6Cm0wXZJlBqdRXZzpvtwvVkQbZ9e6BHqGSuDVZaGBdszx/Mvtfyt15c8uXeT6i33U43HPHVzwcOvP8norrvI/Cr39q/h9zqa7C3sN4e8fPMSShywuVTjhaKTS0jXosyYID3O9PBdKjIUpkQqgxQQvcPLgBcB6x3RWzKZIaRFxiMCmR4iszQbAOyRTUHIdJwkjUKhEzPYBaQP+JD4103nsQhq29KPkaIYokyZmMbWkRWSQZYz6PVRImeliDilyEQGDLmYad67WfPSSzvsZAOu1prbhyVn3lay/1JG9dtb6Bcf4/Z8j+mlJ3D53VQHX+CN73o/t2aBUFe46TaumSILRwwzqqYh05oKgwgt/X5idPiuw2hJ13Z0NskZisKgQoIKSSzSe+RrerxA6s4npsBRr9onBJs4atpkOiC0pD8aJ/hdaBksL1EdQmwhdB3KCYzvwAtELCixDIrIU3tXmCE4pmDHJxmkiwGJRMu0keucZ0Ub+pnksao/MAAAIABJREFUloV5ELz3bI8PPy/4yKee5Gt3Frzj7BrPzyx+tmBjbOgPcqZ1hgbKvsJaz2z/kGB5JawvsAxyQ1elB+0OLSoogYiCmEBU6feFSNQlNK5pMSYVDIwQmLxI4PGYGm3O3XE+ObxKNCItBLowHC4ceIFEkvkG5x2zm3ucySpO3XuM162eQMgBm7mGww7ahnZjwIvTM7TiRY6f/nqw2zwzvcy7s32uPPkU+8tnEasz8mOW/Nh56sUK9cxSzS3jQUHuWpo6Y2l1jIw1nQtYXQAC35Hy1/GoQaRIg9OFhK/UabBG/+pDFX2H6xpElurVQkqUysjzXur8HymdBAlaQkixqnqxYCjlqw45qWhbwXxySGYc42Pr1N2Y0d0n+dxztzAb65xau8DNNjBRb+KFWy8Rdy+z2tesnzBk42v0tvdpnvgCNx6/yjPbV3jk/kdYO/sA2/aL7O+/iM5hbnP225rjx4csr4yQmWRe12ngSZEoUzJRxZq2TYhQItYLwhH0SByB6oUA/SUWjYjA6ATxJwqkuAPyF8Tgk/bHSjrviK4GBJ3QKKloQjrqWOv3KYyhWziwLb6N+FYxvLCJU4rp5w/obkWG79Q8vujQukJmGV94bI9vf9cbOBsfI+RD+lsvouycW/vH2dtZo94pEPo20+OO/qk+Ug4p+z0UfTwQvMY2HbnRZConM720yPIxQfcT/h4fPI1tUgrDR4Lz9AzkWfGqIy0GrLOJTUsgyw1FX1MohcTjgscFewT2V9go8K5Bdy0dhiwaxqWBEBC+xXcltUnRNaE7Hn1+m1OHU17/5Q/wcKa4dzDnl78445PP7bMyHvO6+4es3twlPluzfyujZ/+MraV38878JZ4o3sjdZ1c48eBFJi849p79bIqNEmjrlk60eFcTlYGgKXORdFqqO7KZSzo8ujCgFJ0T4BzONWmRpzy9v9k92t9Q10MiEsVgcc4eHRGQzjq9ToqYMgGaURmhqdLSPFN4XdLOOrJOMgoaExSGHAK4xQ4rMnIPC15qD1hSgijLRNb3izTUZdrOm0wxLhI9P5iWkxxy96DHUi7ZawO//cmOixuOhW+p9g5YVn3EkflV4enLpCafkahatq3ogkTJjiLLKYucGCXBW2zXIGRE6cTc1OoOHzTgbIvRBR5BBsggKcqcwihwHqUE87pJAGcfEbbDOYtDYYNn2Ctoo2Q+WZBnqXbbOks2nXCcUxwbvIXjx85jvUEs0pmZLRRPDGAeFRdWZmSm5K9/+Zd4+Jd/ldWbV3nLO36dmzevcm3rMjdrWLMWMV2jzAdUkxmyiiwPPVHnHBxOOb5UMMxzgilpuoCNR7sKn9CbIYAWKqnghcGopKeJRn7JmW4kRkuI+ohDENEI+kUf5T226hAhYm2yjJTK4H1ACxJDo+twpC1bZSXzecOKblBLx3GTlkNreWFyD1/z8Gle3KnpmrOc5YvIm0/w0EmHXbnAM1dv0Tz6UQa72yyuP0dbniJ75BTjB7+KS7sv8cyVz/Dy3hYnN3Kqiafykc1sxHh5KVW3FRw2yTumoiQWI4hH3jwJ3lk61yanm7wzcJP/S8Y73rzI5PCQXlmwaBcEnyBdJjegU5OTrECHDIIjiIhfdMy9JlcBih7dfMLmcJVRf5lO1RwedvQywaDrk9mW/aplUSsuDDNmozkvVJZzs9NsHhtgb2SceccLLDd/xKWnJdXlu1k/8PSntzg/u8hx+zYaM8PGMcMRHFZHdmfRosoBB7uHaFHQyzJKnSGEOdoypx1uMm1IolAk2qOicw1NG/HVHi4fHJVi0lFt07V4Z/EIekREnqGDJiI4aBoklmBFUjdFjTYmITF92lVlMk+sXxs4rKGQHQMlqLTh5VsH2EvX6I/WOXv/KmU55pHX9Xnq6nWy3RlffSLykT+5hV006PWC2Y2Wi299iEfcS3xxe5mN/JAXHv0Ety51TG88QVGM6feHhC4Vkwg1uA4b5vQHJY5A11RI7wikht/SYIiQScfuXYf3DVJ4VBbT3Hqthq4n0MWY0Gu2TQ8eEi0gRE/nobU+aXxEIsyPjp3AzSfQ7SGionaWUko6KxhpxVphuL095cak5ZyvGNg518gQQpGPTlAfPIePDu81qhxSDiLX2w7tBPcsDyg6wYe2JW8cHHJFf5KP//7n+eM3PchXr+c8U03Z2Z0hR2vkOmUj68ahMGRGc7ua4OoKLzXBBFTdAhKRaVzV4myqbgZAHelo7vzAnOvITA9lMqSMDDJPWeSJ3uWbow++AxGxMSBcRGiFxUFX01SO+cEE5wJj7dk5aFChz1e+acg73/1+ztz/VuZmRN1EVkea/Jzi6ZuWP9iqeN9/999irl7gI49d5Qff32dv+xr/9qc/y0/+73+X8B7Hnzz1W8wWW4ibkRvPXuXcm9/C/v4ee/uWtWKJQWxpD2vU0gplrqnaJIDUxCThFBCsRUQSu1UosI4YFd6LZDK+c3AlIsqodGkSkoSRKBAeMpXMrTFAcJbG1gzHy0gh6VxS/dTNApUlMMq8meBDoK1hf3tCu+jzhY/OuHDy7VSPv8wntq7x7mKbe05/Bv/Ql3GwmPL5z0+5cXvBWvwMPlvn3Lvehdz8CjYevotPPH0Fbn+Myy99jJ24QZ6PGY0kI9sy6pvEPeg8Jjhy4ZjXNT4riD7VVqMQeOGxrk4qc6HRMkUlJQKVAMmvPBNN29C6hsWiTpHC6IhxQtYbEAXEqBEhIVFzIalrqLqWxtcsD9doymPkPcXOoaVspuTZKdZ7Y+zMcfDkDfadQqzcT3684YUnn6WQgu99+wN87nnLt7xZc/feh9ld+kZUN+bhux+kqOeIfInmhqF90RNNxmV7jMc+/ixxsM9geYorIoXJWIQBssjQBFRUOJvuU4TIkDKjUEmz40kRLR8ipuxTzZpU8+6aVyHmPtAcHUUgFa3zUDdEoVC5oal3yU1GhycXoEPElUN6pSHPPFo4Gp/Mykr0kCKjB2jRYmWfb/vyAfbd7+HxX7nEwinO32144J4+37h2mqt/UbH98Snb506xpDri73yY6r3fwUNbv8GvfTpyKL/I71z5SaLfRupzqPw4rZAoDUZ01NUUFReUhcEMSqxomDcJ3i5CRznoI/OcLkRsY9OOJbQI6cl0SrhUdfvaDV2lFSYziFhiiXRNm+wmWZIYKhGIQVDjKEPNvGk5dnKT+WRKtZjSFy1KRea1JrQdKwPPUEVmHspuRnA1b6flRamQds7xcxe5NhHkqqB1HeXGOUSzh17s8NDSKhfyAb/a7nD6Kx6h+J2P8hPfuMI/ePx/5PGt3+XsnuXQzSidZi0O6aJg5gMWlYQX0iKMxLeatqvQpmThINKhtYGyRCgL1iFixAWHPerdI0BqhdKQy8QXKHsGqQpiTKFyIw1F1sMHh7WWziXmZxCa1aUltrdv4w726PXGhAWsj05w8e4NBmabwo6xlaGfOZYLKFZztnY7Pv1yzQ+//zTd9ZrP689xfrzD6R/9j/zUN/89vureW2x9ruQjT36We17vedMpw+f2ttkS93B6+Qyruaa7f4lRs6BqCs6c7uNNiVOGXFo6Cz55V8BBcB1CeOrGIpAUGVgfsY1LF6l3HhylMMYknKhLoBgRNW3d4roGSWLMCiUS/tM29EzB3EV6EmxjqRcLgoyJy6wz5HCZWJYMpo6taw33bP0Jy2cnvO8dDzPuvcDvfDLy6OOP04V7+c4H1vju773I9PR7aF/s09z0VOUhv/gTH+by7Z/hdcrziUPH8jnBjBXKPHL+9Ek21tbQ0dI2FdbWCBEZljl1F3CLim6+oBUxnfuGgPUp8ieEJsk8k1ZGyVcjY9ZbnOtobY1rE2fV+UBczFNuWxQYDNoLdDRkMm3X+yZnPp2xfuIix8cRN3uJNlvimBwwn0C2mLE7WeJm22PtYmTtLs/H/88/JhwXiEdq/tHPzvhX3zHjWf8VPHzqK3jd2WW8DSxuF8xudARa4qBkZyvn2UsXePb6DsWKp3Vz7GKHfLVDj8Z4ndO1FtG2aKOQUqCPEJfRQ5kb5i59zzoEVN7HGUdoO1rvCEdDt+tarPcYYwjOU1UtQShMT1IagW8D7bTGGYfQUGbq6KUlaENL8BE/97RzOLV2nFOlwJmcG4vnOXXxLC/PHqcYvJnNrxvyWx8SvGX6PBfu2WRUnEQcF/zlSsPNxQ7Hn3mR973pa/gZtczlP/5xDosfY2/3g4mpbM4g9BsRqkKohmq+j5tfQYmavFhjFgLlah8XSmzdgvWvsI+lzvCuIrgG4TuUvAP0AWfD0X3UazR0jUmurOTsSq0rFUXK0C5adFHgY0wB8QhV7Li5t8980SJ6G0zqPYyqqb1DtnNa2bHTlTzfBXZCYDcu8ZWmpTz1DoobH2fz8FG2pOatFx7gmb0X2b32HCc3Ci4+eA87h4Ffv/4S950uecfH/oqbocfO/g/yzed+nt/9336EZ1bfzvd9z/1UasS8LDG6wBhF5RyLboIzcPbC3Wxdv0J74HBZgfMw7g2p20BRGiIxCfiEwhydTQFHBocS21VkJqeLEIIi05KmTV4lnUt86+m6mChM0ZKLSNnrMdu7TTvZZWWlz/XLUx4+M+a+4QaLG1dZP3Ufh/WDDOIxNlZzslxgHWSd5H1nlumf9fwfv/XnfPDrvpd/8KzjkztTvnt0iW/64C/xr/98Ruye5PXjN7D7whYf/4OPsXkhcGLwNWxPF2THz9LvdjFimaXlnKuXrxNDTYwR20xwUSGEQfjEFY1C4Nokq7QStFbUTUtR5K9QxgKCznuETMWT0KYSSds1dFVNL+vRtA3RelZXV6nrilk1pVCCxXRC1zgQOa1rcMFj+iWVnXBTav78s3/E/cOM/O6MX3h+QXjqC8SlM3zP9/9j/qe3nWJpGJj85r/jP/7zf8Rv3DzkZFZyeXSRa/MnGGeSb31kyO+9ZDm5cY5733UXZTNjnK1yZnnIUr9P6DxNVzNrBSKXBF8RfaCpHDK29HqDo8EqIEstMCWT/sZkGiljcn4BEOlsTV4arDc43wESaTIm8ymhs9h2gvCKUhYYocDWBC8oektMKkXXPEflLcOQsXpqmdnt6/hp5A1ihSsUfLYRfHkTMZMr/L57lJ/+sRN8zx9/GX/4NVPOyMcJp1f48f/7g2QHJbevPkFwgQN5khM+40GzwkF4C5++eZ4zG2c4kFtc23MYLNW12wxP5Qz7MhmKgyPTHsoBQkpk16GRVI0lywd0jUUr6NqGshywCBWhrrlzuyqlJqCpOktwDUqpxEWYHqCCwjWBjpxYz5nHQLa+zkpviA2aav+AqtvD0qefL9M6uL1dszc55NRq4Ob1XX7vs3/B6x78Ah/5rV2+4Ws/yF9uXSA/lSM2IvZU4G33zfC3Jpx96Kv5L384ZfL7P8Dqwx8iu/H9DDYFmB+gPliC+b9nMDqOd4dU85fTTs3kRB1AS9oIfu4RsksMlSiQdUu0t1kaKrTwCKNQKkuLLZ/Oq/+G4YW/2dAdjHrQeYJ1tM5TFEdU/KbFWwtCMY+G4UDgnWNQDmgDbN06oOyvEXvrjOQ+uT0g0xvk+Yi9+S4HIXLf5r383tZ1Vt5+P5c+9iiTbsjPPDLk667d5C+f/zz3/J012s8+wJmzm8zjCzx16ypf+be+gn/yP1zgvf/wF1m6WLBe/Wd+7If+BfKX/xN/pa5x9vh7+ezTH+X1D72Nk2snEE1DE6sjClTEaugNh5wcjKgWDbZZ0AZHdB0iaJRIQ8B7hes67nycMcbUwJM6IQCjp+gNaHxaGSI0devoqhppk8XYR2jqwOF8TlW1nDx5nMOpZGxajpkxbVNz7qHXkx8KhsOrrC0dp+htJDVQgKgFN3uGR28s+MB/87d56qmn+aEfeIhf+Uc/zI//wof5gSd2KT9zlb//fd/Py0//IR957JCzX/2TfPuX9SlGnml2luUiI6sHsNxnZ/uAno50sWVuHY2rEEIQYoZvkz5Jkl6gkLLJ+mjgqC/hDSBUOkJwCXUnRSTKiC4KbOuZVi2jfokWULVdEgbWHePxMr7ZpW5rvJfMm4ZZM6NsPBtrx9i8+yThryZ84L1fx+FbNnnzfd/JO+5aRWNp/ug3eOpHf5cf/dwXuDyMHD/xblZXz2EP/gVXFp9i/RHJv/ymY3z3Pysxapn73/S/ku2+wKr9c9bWl+n5jjCfMq1q9icHdDi0KHG2IROSznlsFxgs5+liUKTvW95hJPsW6SLCvPqzEUIwHvaZ1glMk48MjVcQO5b0GN922MpRLxyLJh3DlAR6esitwykhVMQYOSRSZoZT8w1yveDciRWuvnSZ/VnNmrkXNS+pnnyMa37Azzc/jPj9X+HiR36cK1/1j/kn04733QU/95ijaT0Fgd0w5+Ne8J+R5PrzLC09hBr9EOf8NnsDy95ti5c9XFWzaKf0xmtkwzFagQ1JCpqrdA8QhcQYj+gSmN85Td00NG2HjN0rQ9eFSNc5Aj4JV41C60hbtyA0i8kU8hGj6MkHq/hWs7e7T+s8QuSIIMHtM1l07O9Gzq5tcrKM/OWzW1z73A5/+tcf550/8e8YXNpl8thlzMZvYXkn6tZbWe+PKL7+IW586hof/cTvsrl/hn//B/+J7/q7L1OurXBq+T9w9dH/GabPkg/eCPUBtr2CznJMtomPEKXB5AVermKb2/QLRV5oqsWUcCTirBuFyXJEDPi6ASJZJslykZxAr9XQlVpRFCWubuhsm9i6QhCwdDGA8CkEHwpubG+zuXmCynVsHF+nthlz29D1MhayZlAquiE0QTFYPsmg10crxYcf+wQ/9d738QP/7718++l/zepbP0B46jO8vr6L1n6O55/Z5v3fsMKDD7+BP/uzIf/Pb/4lw4fXMb/0z/jFr/9hPvSB7+BTf/BmVh875Nrss6xcOIc3JQe3XgLbEegfAbkD0c1pDg/ojZaQytMfjBChow4WqUSy80jIzVFa4UvMEcFFohYMh32qQ0dTtXROItHo2BJjhpAFUSuCa4gOnNW0ixknTq6yFmfkRvHGBx9m4DsKWXL2De/i5n/4Wda+5q30V44drSYFrYgcDiJL64bvCitUCD534X4mP3WVn//pn+UH//Q5vkv1eef3v46Xn8zZmnT0Hyk5Pd6lX36CvHiYezfvQkwPuRr6jBQ0VtG0GVU3I/iAj30EFoLEt5ZwhDjMRExtpBBADjGq/v/JGEUEERy2a/AuXb451xGcIAqF1pK6dSRTtEMJiYoNoWvRMmdlmPr53nsODlrq6GgHAz7zwhe5763fwL+99yTxzz/E7ac/RPH5KVufqtmaNdQhEoiwA7z86+Try9z1TV/Oj3znOu/d+Qjf/i93+fv/5u9wMb6PX/2nv857vuOD1DuGhbxBORoTVaSfK1Q5ZOv2Hn42gwBiVBCiIe97onfEGJESiiy50pxN4sUQ07m9fcX8KujnJS4eCR2VwniP7TTjIrIwAZ8JStMxm9Q0TQchqerzYsze9iXIxlw6uEyUIz5z45dZMZK7l+5CtsscFOucXxnw+tV9vjjZZaQ73nCy5p//0+/le9/4IP/qN7+Vn732Dzn2laf5rlzR3Trg8d/8ST7+fM1Hnr7JY1/4K+Z2l3bv06jn/w28+y0sXvgExdIG0AO/R9W09EYa4yNGlOlCOXS00SXLtMyYx5pCl/io6WeSiEnn26J85fcRY4DokkY+JjSkyHICnqrWBA8D0dJlQ5RzNPvbeJlR9pZQMeFRnRdU9Yx+0aeebvPiInLl0pAJkrvOfT0/93/d4gu7V/n0xz7Gj/y9/wXdjsg3/5C19Q1299/MV4ZNeo98Pw/+7R2+5f1vo3zH9/Gm87/Gn/3Su8G/wL0P/ATXtwPz2Z8hRZ/oW9pmh6w8hilPIMs+0R2gyhIVGmK1Q54dAf2zETLXBCnxziJUIDcZxhhMppgtZq/d0G06j5QOIUFnObik6MizmGynwv9/rL1nuGdpWad7v2mFf9q59q6curs6525SE7sVJAuCop5xvBRGHLMMo8fBMGeOET1idgYFBMfAKB4DSRSwaWi6m9CJ7upQXXnn8I8rvGk+rN1Nzzc+sD9V7avquqr+e603PM/zu2+caxpQwhjceExZWGZmejAuUFuW7sweOlmHsj/k4f6Qst1ias9B/uy+e3A3RF7/8+/k//3tFbx/Ny+//R3sfeJP+T17gPk9Q6auabG8vh9rIunwMU53rmTpR3+DD/JTvPnnf5n2919L5+E1vrgyYOHyt3FmZQXZjlBsU5OS0sydat9kOhJXkssmQZLnzQuFaiNJ8VJQ+xrVFOMwWYbJ8+b1koI0MxihqetAQKKQJDpia491CmELghMkpjkt+VDRMSnzCx26tYdJxt49e9hZldT5ZVz5/CUmq9vs+47nY+ZPEav9iPQo3kMYRaYmkqWepfRn+MfhUa5+EG75pSP8h//5N7zzla9iXz/yrg/dzc0vPcztJxLaJyWb44Jy53GqxZcjqwpltnhy+yIvOPZihBowGI2IZBTDFQgOmRiUDCSJwqQdpBAEacjbLWxRoghopRpFz9OZAF8SnSNJ24hM4aqKIlaE2AzZp3mKrz2uruhmMxRlRaoCWqXoRDLXTSn7fTbsmEQ1XNILGysE6Xj7b/0WP/JfXsnxl76GB37lKRjfi3M1zZSi4pdfnrE8cPzB50vs6oC1f3iQ5csNre/9Md5y4kVc8Vfv5LHy9/mP+zfp7vkrlu00h/YtYCcbjeusm7MaHMGW1D6hKIZ0KMl606A0rVxTTUYNW0QYoqtRqlHSV9XuBI//OnluXNZ00m5Db5fgJiOyzGAAg6BG4pyhPd3CekU5HDApInNKouaei5g8RZrOUXlBMTrDE4MBy1vLzMlLuX76MpbcAp978ON8tv+3dOb28MYr3sSbnnczb3nvizj6s6/jV37sd/jVY4f4u+nf5b/80F/wA2/4DV7RG3Ldyr/xqX+9lA988DT+9JfYLC8y+Mf/wWWX34GaCxTbgsnqDvNLs4wGfVQ9Q50I8naPVt6GUNCflOAnKCtRsz0IhtFwG523G860/PpEi1Ky8ZpJ3ZiIxa7RubLY4CBKNIr+YEzqBqQmZTqViP46w6FjvV/jhGLv0hzdfI2zg8jgbMn6+Quc3TxFud5jZ/IorTDND7zslfzt6kHetP+jvLS/Tto+wK23J1x3dkz1nicY7nh+9pNfZebDT/K+P30v17z8J7h87gxf/Mr7cNnbwS8ggsXk8+hMNqLTdB4vJd29e6B/qjnJalDBorpzkEhs8OgoUDpF4og4rIfoQMnAN/L1DS26QoDwAa2agffgJK7yCKlptTvUtlEzF8NNeu0OPgYSYTFiQrsjsf4Ak5iyMN1GtfYwNS2wW2tcmBTc8YM/wf/6xw/xyMmCK9Y/xQc+9ig/+LEXce4rq3zo3b/HL/7OL7Dvih/i9pc9xAP3foRC38Lvfc+L6b3v3/P2hyQ3vvPX+Zr9ZbY/sp/f/NwCL/q2ffS3T7JUlUzHEWPdpawDlKFRSauEHM/sTJtxjOyMRyASbLA4F6lDRBsDQlM7T8Tu1umakEZmUoSQRN+g3IyUWFs2aD8PMmgSJHiNkindTo8syfAxQdYliS6ILuHw7Ax6PsesVpSTiq89cpHjnz7N4ZdfRn7NQXwpSWroHNcIJLk5zptM4NNHzvNXw6P86ptfx7QS/OH7l/m273wOJzpjPvChOR5u5XRv2MvfPdjj1VsZ5wZfxUvHbKfHUw8/yoXl80hRU7iMAGSpAO/RukWSKrQrETRqc+cmRJXinCXRCtOefQZuMhgWzM5FUiWaGV6lUEbjgyPLM2wNhZ3QFhFfB2bbs8hWm+WtITGU9ENodPIiYJRkNHGYlqZ3cJb3/NsHKB8v+a7XbdF7T8E//8fAG1uBOytFSOHiwSXOLRfI7oiphSmua9Xs/VKHzZef551LF/iTxUt45dFDTPU+RXLMM9l6kKnZy1BLOcWwYnN7SD0ekrUkMSaMSsVoPEGnLXSmGWwP0EYDkoBCCg0qQetmjDD4gH+GKCVIkxZSBKRKcQS63TbFpCTYJsGmk+bP2Cri+hVWJiij2K5GJHEdn3S5/thhTq6dQQPDYh0nFAM/ZlUus50u8XhUXH75Yd7xSz/JJ9/8Q+x/4zR/9/mj+MEy7/j2P2L+vi/wxje8h613vZh7/mubH/+en+S5b/lOnv+aW1g8dJJf+633sSfdYU9+FYcuvZJJIbjpiOb+U1NkcYv+xirFxjaZmWGqW1G08sbokgl0mqGkQniBkAHT2YP1JakOhPpZEy2+KTMJAfWkbCSdWhFN1iAsq8hgY0i302FqfpqWbBNqy/bFFQoLJtH0hMWMV9nYSrC5Zm3QZ3vrMYrJ81jvz4P/XfSe/8Cv9+/h/37uYT7zsWU+aSPfe+s5XjIu2f+qF/PWn7ucf/ebQ+b/pOBrF88wfMXrWDr91/zTvd9K+9gMrL4XNbWHducAeZqDbBp/qr3AjLK0TEKd7yGY84yrjNmupjs7jdQRWxRI0YD5pRAYY3a1PeHrA/3fjEXXuppgMiofmyuUhlhZrLMIqVGthMQGRoOCJFp8qPHUONEiywRHpnqcXNshFpGugbmllPahY5QycOT6CfnyD/Dox/+SH/ut23nda17KJx7+Au/4m6v5r1dGzs8d5bbWw5yb3suj02/j9pkpetN93rW8yPd/7I85vPLf+Ilfuoh+3bewtS/l3z7/fq6bOUxrfom10QZufUArQidPybJZ2ibD2pRaRoxqmmCIhp/QakkmkzE+7kb6QsSHgHdP5+xFA/NwlnLiUFFhJyVKaXRimvqckI3jKjiUs0iTI4IiRTO1MIdDkNU1vaQka2esPLJGWk6hz7+B+8+e5n/9zV1c334vw7DGV65/Me/6459CD7cQH7qfUzc8nxe85AhRCsogOX3fQ7zu2w6xcCDj9z75XpZuPMBi23LP6S/QS17A46txigXHAAAgAElEQVQrDN2EY0uHWVl5ilo6uolm4kqU8mRJh8xYrHWNtFEpiA0jGJMS64o0SxprQvDw7PKC1PjgCbuqdmtd03hMEqLUZN2URBuqzR3yVouoYTwqQYZdp96EUJYkQtNOO5gU2m3HQG1x0B7gyyPBwZf8MF/4tu/Djj3nD+zHb61jy8ARLmNR7/Bo/QVi7bBL83z0/Dovk29jZfJF9u65lYNXZ9z35xc5dN0qnUMD+pP7sdsZxTgwsjk26aDTQFpMSLVge6emOxVIhcT6SN5qY6uq6QOIiHO70xtR4Grw/ukXLCKEI6AJvsCjUQJM0kKqQBZDExclQUhBViukyhmMCqRoU1c7iHQObaa4dvFS7teHaE1OMayHDErJY0EyLe5Fte+h72bpf+Xd/NrqKocP/D4n/+CH4Luvx99jWXvhS9Hv/kVuvvE5bPzCnbzvo59gI97Jm77rBg7ecAXHf+2N/Pb//ASXXHkbe8wQNUkYb21w/W2Xkk122Dm7wNnTq1QTz7A/YjwckLYkvpXT7naJSU4xqZFG0up2EFZiGFM9i72ghUB5i6JJNk6cQqu0kU/WAVmXZFlOO5HkJscXgbKMaN2iKyvyNEGLnJ2+ZDwUeP0kqqxpt09wYWsPifpbtLmEd775Ia573r/n8Pv/O1+7+4usPP+5/MsTA5bvL/nua0+w78AS739HxqvvvpNXnHghf/aRNV42ejV/b+bYKe5CT93I9E0vbyDty4+TxQHpbKBQgrbO0fWIOouEYWB+3wJTmSHUNSZpkc+1m3ExO0EJj9YCoxszdcE3cXqhspFOr0VdjwmuQsRIEOCUxLpmRObpKGhd19RSQkwoY5uFtmK6l3EgtmglbdLMoVqCfGoRn/ZwScIf/vABdr76HPa1AuPycU60p9h52+XId/4M7//ZX+XPPvoprjCPM3vgUtarazi1UDF71T8w9c9/x31338/rv+929ty0lz95/+/TuvJWltpdopmQ5RW9fR2qoaAqHdrWeBnJfI33kUqkhAjCNULKVnsKGR21eBpfCcTGEAcNPX8yHmKU2gXdiMY15R0qKCSSLFFIaZpdMAiMyJG6g1GuYUj4iPaQtmbpL5+jLFOW9u1l8uBH+dzKV5hxJ7h/NMV95UM8oR/i3l98iOy+n+Kf/voX2JfneCl4HJiv+xy89gTnTnoGNkJ5A4sLM4zPnUHc08IcHfPY6l2cOPI8bNhia7DNvsVFtosxnU6HtmqANFmicalCRkkqJcIkDbTEgxKacjgkuogxGXY0fgZiDuAj+NiYJoQOu6dg2QgrA+RpQjQSH2u2BzVVOUHFQEtLiC2qOlJ6i1UJeaeFq7YYPrFGa/IxpjoJl+uKfQf20j+3yagVKbclew7M85QesWZ3aElNZ6tguV3xvT9xCRfe+0H2/vxPc4/7Eb6Vd7DnRTexsnMWW2ckCwcY74yIKodxBoVlqtshtBWV30SqaUi6OE/DkagqEqEgRMq6QtDocZ5m+zj39ZpuNBneVeRGE1zAWkdwIJGkWlHbQFFOCF6iE4lyFmsEZa4RySxVrRnECefXzjE1tZeYTKHLNkHmBLHOoeDp2Bm+OHqYj597BZZPYGdmqDa3kH93dyNPHQywP/fLlC+aJ33125A3voF/+exnCB9a5T/951ey98oD/MpPHuHRJ+5jY31Id/YgDzx1CikPsaAd7WP7merMsb4ypBiViOBROuIJ7OwMmZ5u0nNJyBixg1HNpJJW5pnbT/AR78VuOlGS5AqtDL4aI4NCKEuatem1plFWMPAOqTQma9NWOUoahkVC1AazmJKMAuHCNqsrXyW4dabFGm+/IeHNb3k7/89//g2qr0z42kQy+PwD7L38CBdmC77/x36Ev/jIX7KUX+CDz72Ft//BY1yTPczp219L9aE/phq/ELHnJQwv3occrdJLU6YX5kh7NbPdBdRog6qYoAcV7cV9TM910ShU7DWYI+FAJEjlSVQg0bsuPS1RxTe05n6jaEdPZSe4UCOVwDnfRB6Vb7BvEZQ2qETQShKWxxXdTptJFOwMPUlecGhaYFFUaIRWOG2IaKZFRjEY8+lP3scPXvv9/Nmv38zbf/o7+I0f/SX+aHmHe+zDnD+quP3YXl7hhzw4fIqdw12ufP0Cnx18J8dvex5z11tOPfKb/MFbXstT/gr2qhmeurBJMd7GR8FM0mm8R6KFNh1aSQvqiliXSJ0iTGRQTCjqMTYGpPQUtSV432Stnh35dJHaebRUlJMR+NCkdkxEiozEGESjGUMLhVKm+U1lWd0Ysu/QMRZySZJMM17ZYWu5on/xfr564Tx59jKu6bU5fniWV8xeyXJyksfj3ZR7Mt741ncx+6qf4w/f+i1cjuDBr9YcvGWaC0slpx/8LLdcOUvZX+H00NJbmMOVD3Hi2BWYOOT88jnSbIqLwxGpapi/raQZepfCIuqaGL4Obk90w0l1XiFkM/wvhWvCL0/XdENs6tZC4WNAiMZ0ixAkxuDKqjGmpnnD7ZhYhpMRqdTMT7coB0PIDLmcxZYV1WTEZFRgnOL8I30O7nsVc4PD9E+eQ0k4t7rJ4s0HqdYDeX+al08Z2ksX+cTpHWa3xyw9tYZ+0zv584/+LTe1FpAULFx3DWE85Nx2Qbs3T2IF5U6zocjgGfS3iaZHGUCYRjVu60iWCNpZjyAEw1GF9SCEI/qIkookMY05+OnNx9c4HIUNjfkhauqqIrjIJAZ8FNS1J9QRIzKEbzasigCJxIWKlX6fUgfqyTq+GlKEnFHaIVTLXBguM0UfO1nj3sfu5sff9kP84ft/nKNvVFx9cobPJp5O5lg9uckTn9lBu1McWJwjykXuvGsH8cu/y2u/5wTT8jKOTsNwohmMBCZLEcFSVhJXjYkolhbnCDOOuqyxPuJ9jfUdUk0jZVQgomA8GuIq27AJwtMx4AYU+rRLr21AqoYRqHWKUS1qoaiLktQoUAkmiU1StKgRZU3woIym122zExfp9XZYnBRcnZ7hDXfcwc13XMqYlIdWLnB6eIFL9REYT/jEA3fxgoUF3rrY5u7v/L+45S/+FCkML7z1KK+5dJrv/um7+dGfei33ryxy1z1byK0lli6bob2giaYiD2NabsKKHSAUzM3OIxLI86aRKl2NVLqxZQvTpGV9jQoOoTKUjCDMN2/RDb4kWLUbDtCNqkREgoewq7epfA0yoFVkKpOkqmASEwqXMqwV1g2wqoVoz9POW+TtLt32NLNTGU8+/iTupu+l7hylc3NJuPPFXDP1IBw7wCPyCuTew5xfPcXikSVWc8dTpz/AK08s8K937+dQ+yS9J77AHTe+ixN7DjG3cY7azVBsRUZdibGQyxxNQqghCkutDXgDqkYahXORVqdL8AXFeEKW5YTYRHr1buyzWWmetuW6Jm1G01iMwqAkROuwgIoKHTRJ3sFkGVVRQ8yIsWRzdRsdKlqzguFoQNXbT7iwQtp+EbKX8LGNTzN+4AyzrePk+jB2/iFefXOfzmO3cOL6x5D+JfzlRx0vE8uIMM9XVMkxIntabe5cM2zNRw7ujwyXM1rTgfL8SUZVi243oRyssmf+MAkVeZ7hiTjbVC5jjGgpkUJRVxOi80QURmkSk2Bt/UyZBSBJWpjdrrV3T8OPGn9YlBKVamxZ7fInGpKZlCCNZGQrQnREIRvimTTkSYZQA3aqFirCW9/yRs7f9QTVBJJMUDpHuzCMnUUlc5jQYd7nXBZ3WC4LTj/1BJfvGfLBf/A8/yWXcW7jbvbO3MDCfEY5OyQZPoEhaTx/KiC1IgqYFCNi8GRJitGRwjp0Oo0UkqqqG1h5iNS2JkaB1glCKkRDrybGyGS0g8hSgqexqbiSwgmidbjaEnZZBdF6Sl/g6sYy7XWHsrb4aoPt0uKjYjC+QHQOGx0694SwxcXJafrJBN1ZoBgdZOryDvXvPMq3Pz/jwZ2c2Qcd2zYlxAKVRtypT2Ov+Q7UgVuYfHaN9Z1A2Frg5NbXyC67jhkVUIfm2DmdEkKnAbfHXampcSTtFibPsZWjLAtMdE391rSbd91GsjRhVAcmkwZkBSBNQpJl5KZR2EsRyFNNRUCbBG89eRKa6QYR6aYNT7uONVUAozLyfApMG+EnTPSYvXOBa6+6nZ46xUu/7ztJ9kzxUz/xi5xbvoBkxIo/QxEt0Y5YX53mi4Xk8v7nuLH8MHXx7eyM1tizmONvnCI5fIDllTHRPsltN7XoHVxiPTjq8Zi8MLTKEdupJE/noaqRlEx3ukRfoLMUGR3CN0lLlCJ6SbSWVOvm4KG/saPuN7boxt2TLRLn66/DbrRuCFS1ZVwDwdMynlwauh1D1R8zco6WnSKqhCpEhPfoqJjROTOtnE6es7BvH4fnDOc219kXBT/4va9nZ+vDZMOEFx64kmL0Rc5/smTQ3cuLb5Vct36cm+a+jZnFr7CvdxHjHccO3I7zsM94Bl5Smpykk+PKETJIjGohE0FlLQ6P7qSEQY1IElywZHnCZFI1gsXommSW0ngkYdcSEGKkrCwiBrRMiL4ZrUmyFC00qIAPUNeOFEGeCawVFJPGHxFVi8mgZG1csjeBcqvPKGpmfIdQX+DR8WN8beNhtsbrGFbJ5Em6F5fpWOiUbTY/89fcG5/gj98dePMf/ycuTDz3fWKZaxb3c3Er45xrIYFFxszOtVgfrBKDJc96ZKkmTySz09PYYtj8/KJvZJwmaZxmvsmU2zoQbbOQJqlEaUk1Cf/HnG6apBhlcLZuQBxi98qtGt6y0JogJ3hvUSrFi4DJDT7CqKhIEehEk0cwMqeT9Wgby349z7Hjl3Pp9CHsFz5DYR1eQm+vYfP8KpfedCOnJhWd1hS9E9eSn1/mEhu484kBr6sqXn3rtXzty/+D5732VdA7AnZElk/RX36UqrTgGlpUVTuUSqBq0KNGtIkItEmbhlgdCdajRYOvbADVqvGBRdn8evdLyuZm4PFoISl9iXWNDsoH1zTdfAMp9ThcCATvCVEwKgPGFkSZgh0RKKmwSD8klhU+SIoQsLFi78JRrrryBuqpJzi0N+fK4rv52tFlfuSFN/D/ffXLEM/hJ5b64pOU5b2kCxPEXMJ2Oc29T/axvZr22ojZapM6OI5efhkX17uUq6eRtSVLNV4E6uDRXjeuvVbWAPpVo6AyJiOqgA6BtAUiKKRqym+5kXRbhsxIjGpCM1nSfGZCJsS6wAiFTpPGzqIjRYwEW9HOu3R7e0jzHgGPH5dcNd+jOtflqttezFxvL61D+/jYXRPuffgsUihMRzMod+g4aEvN2dpzl4VvPXIr5//bX7LnjS/lwHRg1QYOXbafBwvL+s4T3PqCGU4c77E+qolbjnYKmQAh2vR60+QmUkhPgiRPInnSQiIJ1RhfOeqwS15MzK6V2VGXDv3NbKS5EHGh6TL7EPC+iQuIXaWLE4IoDbWLrA6GTLXm8KKNFhWBCuc9xIDOQBlPjL7RnuBRUXLk4AGyYgdVpMxvevZeZtnevJpXXX8lVq2TViPUwhUc33OUueIpJtt7WWq9gN7Rj9GaO0qUl+1m/ce03QWUOUbRniEaQRE9tmwgHKAaX5XwIBsFt8oMlWugy2hJd3qKcjJBlYHoLNaHZmGB5nTiPAqJCAFnY0MWSyK1syS7rGBrA9oEaleAt1Te46uKagJt2cHWhs2LAzRT1FsVmzUIJyh3+hxMl7h673OxJmVcDUnjET775bsI4l+57cP3Uz7yVU7dM83a4q/x13/+BfatpCQzU6xsDej0LdNSMZVvUrdOMSpThiphfjbHSslcmAXvsTaSKLk78B9JpUQClW3IYko2BmBQ1JVllzrdaLWf/opNaCIIwdMKbr8rm0RKpDa7QscSLyReJxijqaqqcahJhdYZaaJRQSC0QMcWhxf3cNNlt7BzcpXRZEh0VQPjCYbNvuPmhUuZrEViPqazp2YNQRo7bPnrCGfupHemYs+RG2hNX8+/bDxJvnOKKddhNBwQ6tCA7EOkih4ImCRHFeXT/yXyNGugN7Wj4cCBxGOUbIDVSkIIhGc1V9ud6Yb9HJsNyJsM60ucEAglm8azaKhjIJBp04yzwRNdTZQprbRNEcaYRGAJGAm2XqF2AoelN9Xm8JUHyfbUPPSZ+5g6fiOzsy9ivv4y3RsvY+GKRW57/ib3fepuLty/zrF0CzO9zuTKI1ySLPB4PeKmE88hVSl2ZYeL5x7niqtvI8OQyzkma300DqMTqA2x8M37aRS1yZEyUruCWIOgGQczqcYo/cyi2zKSqTwhzRK0Ulgfm4kfqSAqMq3wPmJkMxnia4u3Ea1yOt0O3dk2SWaQwRHbUyzkbQZJm3YamD96K+tnznHXP30Rq9qYRUO1FYm1av5tQGfKce0lO9zbn+b6Oy9lwf937viBHyZzhjcc15xtRa69ts1sd4EdVzAJBYkYov0Y78aUVUGiJd08glB08g55S9M1zXsQlGx+nipvNPVK4r3FVWM0rhFbfrMW3RBpTnu6gTcLpQgenNvNaqmGSqScZGNoSduR9YElUwmpbNxpKtZ0VE1iBFqrZiEXglooFjLN5dk8en6OdbtJUZyn1bmc629u8YkLY1R1Cdc+53L27HE8dn6bjfE8SkuyqQTVvRL0QgNn8afBPYlODpO1ZmirClkYKhepq0BV1egkQyYa6x0mEQQVmnpvqJpOZJ7jbKPrcXVNaDzNz3wWSsjGfeWqxoskDdFFqqpARIWI2S4YxzXfk83DVxQFdujQWYu20ixfXCVPcyo0y/1TdPSN3LQnx4oJYWaRoZIMx32EL1iOd7Kn1+OwnOfxv9/ASMWHv7TCX/3tl3njVc/lzMYpBgmY7Qq9oJnMTgh2QM8cYeinaXUShk6Sy2mKoiASmp9BXTcNQ9dsLNY2Cy5BUu8uqnVtm/laKf+PJlpd1bjQWGIh4r3Dh9h0/JVooDJEXLQoX4JJSHTaQISMQqCQSZckGpQtCHZAoiR5khM2CszOGvfubHFVR/DQKFLsBII+gjQHOLI4x351J/nGY+xLFY/oDpe3D/PU//9X+Pkb+Pa3/hFnJ6t8+F8+QnvnIrfMzzGl2qSyR+01VhiihmgjSiYY5ZvNVDq0bhZC7wLCGIRUKLmL6ZSGuKtm8q7eXXQhyVKEs8gATlhQmhAjVjX7lZMOZ+Nu0MBTUiO8J9CQzhym2QAjiLjLMpGC2ltqP0GaSNZZImkbzi0/ylP3PcX+576FZbXJ5d2Sj31pmxtefyMvuXWL6b1rfMqXTPcEctrTu7bHFQeP88DJdboHT3DJFCz3coZWslFYstzT3jdD9CCLHbRqI5UkhgnONrhGrxVpqrFjwXg8RktDVGmDQBU881wYLcmNwegUk2h0jA1lTYFCYKRhPGoSj7VrSnUJkqSdkWUKLSYkMpKmAkSP0jqmjxzHj1cp7CX0d86jq8dpn7iWjdUNqq0RCZGoYHFuiVuOHaITzvAnD36Nd930dnb+/j1c9abvo5qe5/ZjgYeUQS0d5+8/9jChHDPTFXSzMb7qU0eL9wNk9KStKUweydKUthFQTyBUBCEgMWQmJ9UaET3OBVxUpF5R1d9EG3CSqCapFUKT1hKCiMd719TrvINQoaWk1eoRtaI/HKHaGVpAVRYkacbWdoHLaqa7TTolCMlEaSoPQjZplOTQHK0qwZHwwMUzvOjgjdS+oNUzbIxOMd+e4yW3vhZEk3ZBdgg+AVni3FmCOo4th4iYIZxF787dJlJQhJrgHVUtCLKhBJd2gtIZWiXUrmEH2Kc3GNdcgZPk2QXyiMYjjG7m8+LTam6B9xKtmnOfrWueHt0rJyW+rsjTNi5AER1OS9ZG62yWPXyo2Q5PcunUXp7Y8dzzxKOslY+R+lPMGcOxVsIL934rqrPMP8cK2W7zvvf9A3pfzkceWOdQdpKFYxl72l3oJahWQk9eSlJk7JOwsT2iZwwueGQWaCuD844YA1pI6qLCliUgkCLsIusCSjRsBS2bbcc9i6db1TWTSUmr1UZLA243xYWkqh3EkqAVQQs0gUR6tDaYRJPqBqMpVIb1EmtHZLGm1+6QZzmlG+HMJk9cPMPzZlOemtT4UKFn5pifbnPNwaPsn6wS+1/i2l7JRO5jdv2LPPyRIT/z0M8QfElP5bgvP8S9Zwv81ZpLuiXzM4qoNdbJZvZWigZaHi0+NHxUtMP5CEjSpLEDRKmRshFwNnXtSIjhWU+EbyzKElTWbsoVtd6FRElKGuGnEhJ8RSigth4VAsJIynFJaScU4x2QIANY7xtRgNKYNGVSeB556DT7Fma47NpDXHvZdXzhno/zXd9+mofuL3nOA2u0j1zkW65rEV42xUP1GcrNmr3zM5x3s0wfqDkz6HLF9H4WD16BoMvK1g4ZJWV/AnkkNW1coZnYChHqRi2PxLkJ3jTvg5K6GRH0DpVERJTPNFcFomFt1w6jDYlReFehZBMjIjq0bGL0pZPkraaOjpBoFUhiiYkaQQshPOM4xrkd0l6L9c0nWNh/nCtuvo5HBinjT5xDyvP0OkNOLO3nOZc8B+Ez/uZzD3LgwDzLZ/6QLEL37BqbCwmGCd1Oj6SE4SNfQHW7jOuEVixpaYU0AdkWFEXEBse+mQ5FHdG2oKotRgkCzbOgtUDLJlwjfEUqAySKkH4T0Y7i6S68sxjZwJ2drwmuUdwID+3MUEpBL2ujdIoxjto3zNXO9Ax9B9YZTC3oukgkUhYlpm0ZlxEfLTvAkU4Tu9U6ZWn+AHMqsDo4zcpIMjPbZf/CIp7IcAyt/FZCbOF9oC43GNsFQrpEcOskEkxw2CjxroTgENLjHNTRgA7NJiIjeQJBKIQ3jCeDZlBaNbu7DAElv16/C3gkglbeIqSBUDm0aaEjlCHicBij0SYlhuYBVI1UgMpbEhO5sLrMlFlgZkpwevNJskQi7Br/eu5BtqoJZTxAIrscSqe5Y/4q/PjLPLj8bj5+sqTIrmbf0ecy+dJ76d3xapbPrTIerGFdl+dfeQvXHVxCSI0MMwxin9FWnzxm5EIzjAVKGKJ3DAYTdJZR1jXlZISJERHAViMSI8hM89JUNlBWDYHNOfv1z8F7qskE4TxZ0symstvZd8Wo2WjbXVSaI6LCRNHQx4JC6hbel5TjDYSNtLwjFzA7PUN7ah87A8P9jz7KcHKOHZ/Q04Z+HZjJL5IMn+TAgWNMt/Zz/9plfGVuH0+66+mvvIfXH5+BgcGF+zH6em66YS8Xts4yGntWqxLJhKyTokTWwLeVJIzGGK0wqjmFC53grCdRzQJjbU3tA0Kp3dJaJCCxYRftSKOVitETpSbI5ptCCWKMxGAxmUakpmk4OU8qDbWIMBoytjWOIZXtM/ITWrpFjJZESiQJXgRk3iOIFrWXZFdeysuu2MPBtEdc32AUBLfdPMf5z36Z9tStzKQFr7o9oXN6mQf9DKnxqNE5FnrH8FsnOdtJmG9No1stLjORlR1N365QhkhLd4gyNhCiYoKWCp3lyFAxGDgm44KZrEUtc0S0WOeaOXeenl6IhODRKKQAFTyJbL7ng8AkCagRmIxMRvJcIkPESNEkXbMWXuaEWpJnFbrT5tzyKXpzVzJavZf5pM1hvUX8ty9w6ML90IG5uYN8y8tfT11K/uYD7+eaA/v4d696Kfd9+INw5EaKuZQvP/ZVRq5PNjXHYL1C9CIwYOP8ClmAmd5enA8kbkBLGqqtdUjn0RGkq3BFc/pOtcaGgJEBRYBoUWH3VhRCQ+r7Zi26adrAT5xvRHbN5dATQ43z+uv2CCPQicCZNi2VMNhYa9xYk9Eu/LnFcDxGbW+TpprUSEZ6i7WokYNtDh6a4dRoRB5zSm+JnYStc08wtzTPwU4PldfsVFucfPgCqlLcfO0iEYcwM5xbXyGWJUV5Gi08lVcoaSCbonSBohpQ1zVCdjGZwVNCFHhhGNbDZu5/V0NiMk2sLc4JpDa76aSmfqeTFKNT5NNs1SQlSkMlJEJFXDTNGFpsNiahNFmnwySMKEablKMh0kX6YZ2dQmJ3T+wbOyt0TU5hz9OfPEYup0hb0zxsv8bn1h9lPtNgZklN4Ej3FA9vGvLlFlPHFii2I73NNr16jkwexiKZlCVbg0CMCQf2dBlsFbRlwc5khFEJIpQUpaQsRhgVSZSBIHZVLZ7gAt5IbFXgnSPLMqJ/lvk1BpTWaN0AzaVoMH0iht0FyVAMdwgyQecJ/ZHDhIoszamCbSBCKpIpaOctWjKFasRwOOTUqQucGW9RGMsw65FPGWywJASO7C1Zqx9hnLU49tw7+BZOEz//ae5YnOf4DT22P/dLJC/5Xcr6HNfsP8rmVZLVNYHSsD0uSd2Q2emUKDRlXZK1U0ZDT2YkKeDKMWnSQUvRQLmtp3YW70vErrAy7C6yzaobKUd9Wq0ezgdKW0D0RNMgIH0d8M4SRUDqRl4agkenEFSPjh5RiwpMipiexY23kA4INXnWReYZImsx1Wuzf79merLKtDrExp2/wk3PvZmnRhYVprn6W+/gQinZfvDzrIcZitYBeqMtKM4yPpKw8dSAJx8peA2eyeyVLOSBQdWkLOf2zpNsbuGGzXviQ4k0Cc5F+sM+MhRIlZF12nhbN3OqqW7IYfWoYS4AUickaUqiNRLwbnfeNygS2SQ4006HgGRmNsUVzQEmMYpoEqxoEp5Jq83YWYalpzM9xZlzZ9ifH+Txxx/lzHnHtB+x1s644tAxLmnvY+WrW5xdXefg7AKpdvz2J+6ku3AVr3nbr7K99gT3/PNHMfumEGqJjdPLLB6/hM1z65TlkOnFGbQIJNKRS8FkfRmT99hc2yDPMxIsRihiVNjBDiIxzWiYkiihicjdUVqJiN/E8oJWIHVK00wRaBEhZrggqKNEygyEQ2qNyXOyJKOsDOnMLK4YMhwMaXdbCCbY0uEninqo2CqGJHIvYdTn2HzKw6f6qKziqv056WCZ7Y0cm0wTXaC/uYoQQy6sro5eFxQAACAASURBVLI9dLzyZTcxGo6xPpJkF9Ex0ptaYn1ymlpJClswqSLWKxACnXWxcUI56mOo8a7AZDkjC1rJRrAYAyLI5jQTmiuojM/idgtJKpOmCy4lqVGUUWCLCSJGpG4RrGdcFQRXo70nQWN9jasLpqbnaLfnKVd3qMqSkYeJ7CHKdbyasFKPCFLTyxaQssWOjzyyWaDax9mJW2RuQKr6rJzRLO69Dt0ecXhGkOzvcMXBQ2g1w0q/4aXG8TaqmJCKDuP+FhZPEUpkJulvj6lqi1KTJqjgFd7XyKiRwuBiBBx1UZJrgTQ51kayNH+GqCulxAmJRzxzwomIRncUApUNRKWIUeOtR8mIcyBDTRIUdYhUvrnKWQETJRmuDRiPv8T2sI+3Iy47sY/l5RFHW1OsruywNerzyIMPcGuasnT8cnTe5tJbjrF4LOHsQ49zr13hQDjB/JMf5dz6E6D3sDBf0kpHKJeAjUhlCNaDCORZh7Ks6XS7tE2OqyqqGCBWBJESbIW1tinDKNnAzYm7m8uzZrdDYDIZY4wiMZo6ekQIKKUbNY0rcEEgpMKHEr9rQkkySavdJe0aRm6G9e0+Y6fwSjZBA1GAD2QuEIuCwZpkKZ1w18c/Rmd6kSNblna6QjnY5JEVww5w+MjNTKU17Syn2z6ICDmLcoEzyTI33no1Z05PmONJirzLfLZAYhzL586TpRk+E9hE4pUkS1NMS0EN47GjsiWpShrko26eD6LDC0HcfSoaX6Ik1BUu2CYk4yPtTqf5zESkLCzaeMqdgiTpEE1CFWMTnpASES3OVvRHA7AbeFL8Tp/znYrhzhr/+rnPsZTAYkfRX7vIPWENicSXjn5lWZVT3HLDbdx8YoEv/v0HufLqWW576ffw+CPnOPvUlzCzS2yfW0X4CVp3GY0Mzq0zJSeE3gztvfvR9Zj+zgCdKCpR42lu+VJ4ZBCEylMG39ye8UgV0VqRtNNv4qJrEozWmN3kSQy7C2zSuNJcCGiTopKEajSiPZUiPcx1MrZ9TdQSbwXB1sws9BDesnJxnaWDh9k+tcL+acXJp4acXTnHJUf3UiQ1T57cYm4xIRcDtooWm6FNPdmhZzRHjx3k3PkVZLmNTPZhOo6N7RVCx7K9tQmzC1SkSA2hHmJtRR0cPjandheak5n3nqoYYVo5UqTE3eaPDbGJbj4DLX9awe4pJ0XTtVcSxK7ri5p2t8d4XOPdCOkVwTZJPhsaE4MUhknpcezQd1u02j3WVyzYimFsk3W6YHeoS8u42GTghqiYoKWjCCW188y1ltBZRr4gqMfnuPLAFQxlTrczzeEDBwlKMRmPybRvmKA+0B/voETFoBiyM5zQMgnWNt16YT2pVnhSIgki0MC3o2we5ODwyhAieFcjkoYzC5DkKcbI3YmHSJqYhkkRI608RUgo6khwkcoVgCHRmgDYqgKTNJ978DgRiSKS9xK2inX2Hj6IXTnF9oUN9nY1STcykx1heWuVxek9jFa2+MrFuwhIQqiwekRtCmLW5qnHH+MTn/w0N9z+PHZcSsdKevkim8MxkRoRoJoUJAHmpluYqIm7YZBQl2gtGdcVmU6p6gllWWOMbk64u+JNkWjks+r8eWoY147gA91MYy1kqUYJQZQSrbJmYqL2WCeQiUDphuM8Gg4RAnKj6BiNbveoihorpvF20uijyopWBJ1INncUvU6Xbm+Bw0uHqdM5TvfHzPQ0Fy4+yWP1FO1aMLr4FJUNmKpF/+R55L49zM2uszwj2bq4ytgcYP7aQ5TbJT3TJm/1WBtX6EwQEkM5dgRR0+61ybs9hpMhiRJ4J2C3XzEpS7IseVqigcJiaBxpDXZBIRKF0LEB2ruKVEucDYAkJp7xcBuvErTxdDpdhMmZuMjU1DRb5zeYDAegJGfPPkmWTXPzVZeTTgrOr2ziRxvUzjKsLT44RC7ResSZ8/fSr/eiegtsLh5jPBpx9szDoCu2z5xkYd8cS0cuI1jPcGcFF2q86bA8Esx3FXmSks11SLRmNB6jkxqtM1SqCeUEF5okntIN8D2EgI9fR8B+UxZdF8Uuvk2Bt801WyvaAtIQKJ0n72ZIlRNTA9qDc2RaIaWFmIKJRNW8dLk0ZElKWfaJAcalRnQWODK/jRmnfO6ukxw+sJ89+/dx5oENclUTXR/larI8wU3WGVqPMh3mplO2B5uIOqGii2ov4icTRK2IpIiQYIsR0VWkRmPR2LqmnRq0yeimkdQkrG7s0Ok0eXul08aIoDS199R1U8sUUpK3E4TXBOvxUgDN3xfOIlyBMZqs08bWkap0zYhSUTAa9dke7BBFi1A7TJYwLJfJOxnLOwXbm+eacImoqAXUUeJDSWocc1ohYo9C1Iw8lGsVJ269jYuTAd2u55LjR9GJpRycJ8laJFmX0daACxfP0p7uIpRgbX0ZnfXYGY7JdJc8WorxkEppMp0jQsS5gPACGSVRNmGYJm0GKMWkLr8+weA8KnqEisQQsa6xRDgb0FLT63Ww21v4ECA0njqTdUgSgdGe4GsmRfW/WXuTH0myJM3vJ/IWVTNz94jIzNq6q7unGrNdeCHAK/nX80hwDuQAw1mA6WlWd1dlZixui+pbRHgQ9cgscA4NTDkyEwlfzM3V1OSJfPIt3O+3oG+tJzKNUz1z3x788rvfwrsOT9+AT56m0lvlP/3nf+D/vH1mjMnpfOGX31349p1g98nfnZ17+8Tf/k//lnn6F3zYfs/+/B2vEy6nD/TrF84S2/UASoRSctAXy8rDr9yunynrhTEe7PeN6cpoHR2DUguaBRWNlJHj40CmqDnCJ2ffD370gmTI4szhoJNUYDblevvIEAm/2RkmOqf1RBGHcQKPXUJV41Qrz+fK87Pi64rUJ17Ohb/7+z/w4Zs/MMZgnv5n/tXvPrCU7zmzctPCns9ofWbb7lxvd562L/xvv/sX/N0fzvzj76/8/tM/Mq+feP/yDb3AxSZP374jPWfun+98+vETr20DgaenTE4LXz5/YbONpCvvPrwD7CcZ8BigQj6tETU/JmPbY6eiFTBOT88og6SVT19unC8L5+cT5AVJCnNjbYPqmUd9R6s/UE8X/sI39mXlt3/5b/iP/8f/zi/Ondf0nvsPP7IuE4ayXTde1oIbXPOF3/7ur/j3/+73dLnz1//yb/nyw3/gF9/8JXf7yOc//D/8+he/5a/+1b/kcbvywz/9kT52fDMawrunD1xvfwCENS3M1pGlQl5g75EInpVSKgvKvr2ibfszFt0+KSU4jooyJ/h03DOIcDkpcxiPx41yOZHIJBmYGC/vPvD9f/uBb379DbKcGG3g7QtJKnbvdHPurKTtv/DH7/+Bf/uryvklI9//R/7xP33h+vGV9P4DL5cVfCFnQYax7zvnsvD9P/xfbH3j/bf/iuuXPzBNeB2F7WH4+ILroNaKl8Jj7NzaRlahTXhcX3F2rg+j1kzbWkTMmzFGw0eopuwNXlAhLwu2h1y2zY77RKfQ+mDvytg7434LapEPzAddOqZwOT1z3wbFG+P2dzzVgpM4Z2esME3QAYskLqfKQwav+xeu7QHlxPsPf8VaBls21qcF6YMPl/f80/cbHx/Or79dWXPi4+cv3Pc7aV3J9ok//PAjL/WMUPhy65y+KdxuG+tyYjS4byPi5oGcC0s9M+dOx8J/QA562c9O8pyDn5lVY9FoiW3v9L0xk7LtO7hzXk98vm6cUmYpYQbeh8Q9BZxPK1WE9fTMWhceZePlXPn+j7+nfV6gJa5ypl3/ke3+mc9XQ3JBziu2Fsqy8Pzh15TfLFz5nn/99IHf/OW/ZvfPsK5c24DlW5bWef8+ozZo+6D1iGI6pUp/bGyzcb2FsfockT6NFtal4iK4eXRuKTMlVIlH3SYVIaXCUpTpyvP7Z1pr9B6pwn2E+T8uLAUQQ/KZ4YA3hMx2beicFD3zbf4Fu098dJ6KUnUw2SOx+OrM8YX/8u/+Gy9/8cLwZ9Zv/5q///Hv0bTwef6B9vnG5XJCl41tPuhkPn38e/bvhVwVt1/wUgvy+Ijtd+TdM+gT3geZRi0DORfwD/Rp+NjZbYb5jyaWInQ70p7H/JqRpjk4yUQpxmSQ1ElZER3U9QnRyrpGEsnp3SkmxlRI5mz3K8MFEePTP70yeaIP4fHHHxj1xHJ/8F8/fsbqN4zHJMmdy1Io6cLrfeNzf0UfN65NeH9Stv/7B+qv/xee3/2a33+88fHz4OUvF969+1t8e0W44xu8pMz5l2dmi9DU/Tb48OvKnRcetzvtfiercS4ZT5m5Jnpr2D5Ibgz2OHXtz4jpRts3kYOPqaUyJTN6pyxLZGUZgXkQ4XU6Jykp/fqJlwv4fmU9V9598wKjY2OnniAtC2aDdyWzXX7Lh1+/5+N/+Dv6t/+GV4T1V4nL+RL0DBXOlxOaFDNBxxfS6Ynl5Veh9dnupMsH/PUHntcL2zxz6z225hJWlOu6cj6tqCk/fvqBYZNa47Se5ixlpVkK31WHvfeQgx7XwY5gRfGAK+aMz9cMtnWwhvuD7sKYMPqgG5wuC+kM5fONdH7h9brz6fOdx+NHvr/t1LqSeieZUjLcPbxoL+cLuWSSwtZ+YCThw7u/4fZJGPkz5/c/4mJ8ePo1Z12xtnF9/cLt8w+8rEp//cKPH3/g3Te/xXZDxwbtyqKJJVWsbYh3ylJwEfpo7EenlpYzvU3WpaL1BPOnkzzVQqoVN6ObM/vgsTW2xx1VxVzJ64ohPD2t+DBSXhjjhvdG1oKRQDJ1PUNxrv3Oj7dX+o93Pl+V83zi9eM/cvrmF/zmuwuf7id++cvJH7/ceN03LrpRUoVL4uO98eG7bzh9WPm8f2TqE2o7l/N33K933AppOZEUpjZIA2HhtgVmO1ojy0I6X7jvYY6gmmCClkwqGhCDKOpOSW+driBr5enwFNAsmCnLemL0xNg3bIb/tAiMyeFLXchz8NiF25hYcvRUUYT9Dk86wrfaJp4j3j5l5dv3T8jifPPurzk/ddr2idNu0AWbP/Krb7+jpRfcnJaF5eXMh+df8eEXv+SP//Xfc//U2fOV9bLy9//5P3J+WVnOJ7pDsvDXaDOoocNh2ECyc14vQQV7bKg+M2Zj7p11SV87XZ8jzL01Fmkq4aMwZ8is23DEb5RlIWVH1FHb6bfONp3WB/c2GVPIsjLHnfW5MPTGJVU+f7lxLhM9GZ8+RgCu1JV7DxraX3/7S173AZKRlpmfGl/Gf2KZv+B3v/4N7371v/J6u5PaJ15ePnAuCZ1Gaw0GrBVSXqi1cv/8PSkJp5y4Xxuig1ef1PWFtRSWU8JtBrw1B2mMMPz/cxXd0SdDG+IDFcNxWrdQL9VKNycvJ7bHZ2ZyUi00Udw1qCLnS4iaLMK6TROTxKMN0jRenl748XXnt3/xHbd9I83My/sTy/rg4z9cueYXTFbEHhQznvKMbvn8zBxOVyHtV9Z6CgytnmlzgqTjxEiIVkoC3NmvEVGjknjKF663jT5hGFhpDHNqqnSXONGOi+nu9NloD2OpB4WOgBi2R6ORWOoS0tEt4rv7GOxt8uXjx9je1oTs0OeDX37zQpFfkX/4zOvnP+B0djE8Ced6gdOZ67ii3Pn26Tv2euHHx533T4nH/f+l/uKXoE/0zeiPjrXBfRv84dOV/dGQMbhtH1nrC74r18+vmBau10Eh0UpDgVIqmkPizWjR1ZUaMeO1MudAPOPy00lu0+h9Mkb8O6fhGHVdAWEekJTZRF0RcV7vXxAXzstCSZn9vtHn5EZn7sLsHbWJb41LrTz74Fe/+SvaIyKiTo9PNKusl+94+cZ4OQksC6+z8qu/+QXvn4wxdsyhPwa1CufThXRt5JKQVDGgzcHjsUF/HIVxoJ6QXEkqqIJJZvbGumTQgpaEEYnIbvazjOgovMMhZ2WfhthO81NQp8jgIX/HBqONmAKWSS6JrIPnEsurfZ+sy5nkLfivuiCzB4f1nHl+vvD+6SlisVImaeEGtLvwu1+euX/euf7hE9cGbb8z8sLp23ecFMbrg0UKf7w++Ivf/S3VduwMYkrxCfag3b8gVHI6I4uSpDOP+6iUxPaI+HZxYS0ndhOm2U9XQhRJGUQjfcOcVITz0ztQx/aoHZpXUq3crq+4GymBpoTWypJgMWW/N3wOPv3jKykV5pOhRZj5QkugH+B9vyGfvqB0LucL6tC/3HleL2iqvO6dd78+c3laGNcbdV35m19UbF/ZdufH640lKU/nhaU48/pgFmH0V0o5cxJhnjLr+m28pttgSYmlZtxGyN4FEnHIZPlzRrCPhpVQnmRNoS5JCh6dEXNSU0Vy3Ji2Nxxht0mpJVzISmJ05/XLKzk5pSjWDbs3frg2Lmtlu73yuTXevbzQHq/Y6x+Q+i3ffvPCtr+y90quJ5BBPT1TLy809+DJJuVxe0SUC4JI4n7fcXdqVlKSSGZNC42BA0s2qhbujzDqWUpin9H1kGGOGKG+3lUiiGRUGu0xUFUWcXyEl2gP4z9mn/TeMHHIGZnGcr7QZ9CP3BukxOf9I4kvqDovT4WxT/r1SpudjLHUTFOhppXunX3bOT9/4PXqLGvmd99dsPYDzGfafeP1k7Ddr3z58oWaB69jw/XCSVe+/+ETSwn+pHZjqmBzkpOw9RHb4+NgSfq2aQ/T7umOWkO18LZIG32j7zsucmD8GYqE+Y0ZJSWGDUxgWRLSjbY/aEOw9MSCMV2xORl7uE4tWtGTkkoG27h/cT7+w4+cygld3uGnb+l+4sUGeV6ZTZHzBXBUCjUpt2sLKtDLE+QTPjNqBaYx+wNzQWYipwutDyw5ZclYm3gqdDPMozhmBDt4pCopDD5TwkRCuPD2/jisHnNy5Jh8fDRMFLMw9Qmr0MHcOupCHpPMZJeEeriXSQL1zlJCYh4hzQPNA3elbZO2Gn+8wst3H5gCy/kDjzG4fxr0HgXdTPHlzJIunDkhurDUhVEuuHby2Gm9s6xn+mPSmpFoLIsy22SOB4gyxZgimA32j3+k7TMmlDawGT4bYTt2sBdyIh1Tr7iji1JrpiwVFxBpwZN/fGaIoprB7WiACktOlGq0trPrBgrnywvL6cywRD6f+PjjD4z9xucvn8nmNFc8aTR764l3y4lPH3+kni6MlJH+hXP5jpqV9ZcxufVaeCoLvVcetxu3zxtTjFoLRSukM+P24J6FXAtSBJnOqWZ87vQ2SVnRrMyhzD5wjPY1TeTPUHSF0NXXmqOj8UlOoT3uNsPusT1IWSOy2g3VwrbdQ4ePY6OxDVhSBozHLTiCS9ppY0db5uW5sLUGtfLYdlJ6R00FGxs4xzJPcM3I8oxr5DS1sQXuqpVOBlfcRjh/TQsprhm9RXQy5mhZuD0eeC64+aGjnmCOk9j3ERDD8J909h4ihySJZo3hQm+dRROzNeYQuipLcpY10bdB23b6MBKKz0nNwecbfTDTZNvuTMKRf0jjvIZiS7JyGzvJO1mEIROWM0Km90k6KX038kk5rYp654c/3miPK5KdqcKjC+tpZQ5n2zqXWjisewIWkaA/uRtFwsJFIHLhNGM2UGB7bFRNgaEcHzaMOUa80XLBJYzf3eNwMhH67JhkbBqX00JWZdUYlWeLZYTPyFfzlCAJLs7t+srT8zNNn5npxstf/CX72BCD4kAzPFXSUgNbNvj8T//Efn8OleE2eXpy8iyMe2PNCzYH3g9HLE9kWfAkKMaYM7C6g9WimimZg2MLaRglAylSc90GvGG6hO9GEpg2af0Ye1WZWul9x0dEGKWkLLWSDgvMfU4wSG5orYes1knLid1bxCORYE6SzlBVzrBkvDyvtK5MFpaaeMxGWV94upwZ98EPXzauW0PklbUo58W5fDjz/WbMHgKPJSUGg+vnK2vSEITk8+FPMZgYkgzD6fsWAilvDDO8NYan8KE4eLqieiQpKNPia2WtTJuohHxa0okkPXwsJIN1NCdyybhNZpskyTw/v2NMCVvNlMi9cf38hd5uPG43aipsLcJmT2tG3LlvN9DK5VwQHfzy2w9Bx/PCi2burz+wXD5QJdO3K+6DcwlPaAb4Phl6J81BqpUiPWK+tLKen9CcMBu4D1QlerEZwQZxL/90EP+PF10HszB70aTkkuOUIjKgHJijM3rC5iCVzD7m0UlFioKIMufArAfFxBOmYdnn05hL5f76GUy498alvkOXJ6qGHl00ocdzaKaBt6VEzSmKomXa/RrjC8oYh7PTGPQRtDZ8okfqK3PDhmNJ8elhxmKd2QcyPfi55ojL4fwf/hP7fSNkEUYhoVmYphiOzUH3+Jk5480ccd0cY/sgS2L0DRWBrNSqTDqbOQ0HjSkizISclBQ5TtVCpo/GVOXD5RfMR3TTmoF7xi3sJouCjE7ShA9ntAeXU2LOQU6Z6TMOgpQQccwsXuODq6xlAbeIIEIQd3DDRuet7Vc9ulsN6pyoAoKYYUggO6ESJ6WE4SxrSK1H378eRuLx96acyOeF/aGcnl/oKJpXLs8BE61lpVwyNjvtNmN0rY5ZY+7KbZ9YeeLpsvDtt79kSuZUnmE2TsvC/fYlgiUNjMT0BOlElsGceyjqTLAxwzVMBa0eApBSUNWvDYiZfTX5cYdH28gyUMJzwbyTTJiAiUUHC6goIjXu9zljLwFMEjICH90HuA/S2BGZaMrknKnFw6jJJujC9dYjFmnfKGvBUmUpmfM5c6dzbleqO+dVSPYIBkk58345h0mRDVrfkXqi7x7F1IUkGSxjfWA2KSpIEfbNsLnBjPglzOm9Y+ZfF2lvUFNJStYURcphTueyVswmzaJLxDMpZ8RhHAefDWNOIZVKzpVq0Mdg226oToYbaAh7GAOG42bsJuFqJ85oO0/nleW04qdCfXrBS2GWE8yd/fVzGPKoYH3AnKiApbBkXbOBCjYHKlBSCWWeJlBFyOEQNzs+B+qTshbcgz75Zyu6czp1yQgSrvkzFkkcJ/awUCK1vWN2uBCREIykik3ImskY1h9MAdXCaA11QCrTBrf7oLcBtbLamb7dsVox5Gv+XdKEpsL0gSP0wwFMYs0X9JnewQ11x4cx5mCMiYSzOHNaYI0keh+Raz/C8UxQxEe4JB1Y7hsPMRJOG0iKAqoRRnffG5mBi2Nz0qcyjgWeuJNFmTKpRSP1VEK9Y31H1IM5MXdIjmum50RKStYVtx5qF800iwKVUwoBwv6gnsL5rT0eiDq5RCGwYSyLRsSOTXI6YBd/4+KGlaPLYeLjIB55YGMGpxrXKPxZUZXg177dOLlSSlDr5nFt3rZFqooILOsZm05Z4vVNeMS9Hy51qZZQ9bjT3BGbjNmRpJRUOZnBzPT7a/h/LAWbHZGOFieVRKoFcmEcnWtez5yfz9xaj/t0NPbZmQ6aFlwsujDPBxrvqGQMISVBZZIoWOKYljTurMMzGDOypq+CGYjFaujzCbWfxGdRQSycIIdZHGiacAnqpI8W749hgfu6UlVwV5Y1v+k+EQ0fjDEM33Y2vrBvysu7lVwujNGoJ2WwHgdp5uV8Bu+IRrrxfhfacubyYY1Mw30wpiL1RHJn9ht9dJI4RRZGn8wxqHVB1CErs+/MPuNgmQdFTH4yQsopXNnMohNEMlgcUtPsgOY6IspoOzZ3NCnDHbeAcFIp5KzUIjCcZMI+DUuJ8+XMMCE/rWyzU1IYV+194BZNQKkxAS3vLng5c1qe0KUyRCh6wmzS+4xO1Y5GQhWXuGeTgntCdVBVY4qbnTnf7uv4Pu8RX1Xy0XxI5nz6M3a6Yf8RtnRzODY7mg8j6LgPUQ/98ezG7pNaToemXSOiXMDlMI0ww60z+0apQRxvj1fcK0UMN2XfbrQjobW1hiZHD6xRk0ZhODraYUZmMudhxbjfGXMyPfC5N/bFGPvx4sJ0R9Bw1srlSLGNiwoSIy+BV751NSIg6iHrNKOjmI3g8IlhEDpsFdyi2Plb5ycSm9zR8BxpC0E78vidbpR6CC40rlchBzzi4VURnXomJ+V2v3MqZ5aUyCnh84G74BpdpTNjwVgkCNzjEISMcRySwnGMkjXUQIoiDn1vsRQrK2OGSb0xDse1+FAtEcVicYCZOaLRAYtEkS6pfMWN9ym0g3sqOWAhIYWnrcOYO9pD5TR8BNWbgbowZeC6YId5dDmtoLF4KacTWip9OnJa0LTyaMK+O228krwFmb1WJOegDyDo8bqOWchFGcHfotQaTRTGHPHKj97DT0EVTRp2hvrTW8eFiJN3h2nkVHGfMSHY+Aq7hHZL0SQImTRGTI54QGcirDUdTCBwt5Ag+4wR3iTgmH6H+sy+wXJWfDS0wzbD9SstF5aT4t3pM2iZbQycTnpcgYpNiecpiZomj81pWwtcOsfyfPZB08MuOYP04z7MKe5rcVQGb9NPTZmcDrxbgtVQUsAMo0eTVHIJJpQYvTd8pvh8ijQOVT240DA8LGFP64l765zWFes7u1Vmj8NDLJbxwyZjCHldGJphWcllRVNmScrojUnCNUdquRjuAYPhcQ8PczzXo7nLFHVEJVKoJYqsO+BhWSkSZlDiIEmppf75im5OKbpD98AENTomn86chh5WjzXnsEWUhMxBXSolCV3Cw5RpoV8/OtQJWMnMa2P2x9EdSSha9o2cKvigPT4jOZPqCtIZo4UaqQAEXNB643ZvoErb77EhTuGGqqJxMx3dySROOdGEisThQaK3eXj/higAYjSWn/vIvjlMuYaZuwtFJUysx6SPIMB7AikJZvyu4PUGHjSY9HaPET0Vtr2BRkyO4Yeu/3Av07hhECf7jGj2XOizx3a1D2bbMZukZQ2Io+1IDqPtyowbwyQoYb2RNWLncxHUHTEBzQcneWDz6ASEeD1zHC5HT3tch6/t/+HZELlYIT93ctbjasnXTb9pDltMceyYCkwmtVREMmTInDAZfPl8o7nwfllJ50pa35NzYl2ecZ80c9AogIOEyM5aTszmvGV9pQAAIABJREFU3O9XWncyjeSDdVnwEa5dfjQPok5OBVTQqsi2M/og5cw+WsSs+9HDHdi3SkxC7mFc/nY/9LEdXbOy9caimUzCxyPwWoiFkyZsCjYG04JYLxqFSEVxZixz9/jdfTaG7RhGEljWEjE3q/L84RtIC+fc8VQOWbawD+NpiYVpWFEqbTYGUVxeX185nZ6YWqiao/DgqAvePeAh78c9ONj2CamSssR1qBn3oDDuc+A/Xx6pIBoHWspCSUISJWuhd2PvnTUvCIPzurDtwj4GmuJezOphsUaidWfvQT09nSrbvjN6JLk0T+S6oGUnW5iti0+GC80gUxAXao3leUqgw7jdQxkpJWAglUhKEQvWzPTENCFhuBaGDKrE6xQjSw9YwSPMVkXgaIiSHlDbP6ee/rO+C/CD5D19RuIrGuMOHpZ1EubEOQ3WEkhv4ISK2QQNTDeZkSSGUhvGmIb5xHBOS+b3//Q9v/3NN8xhJOtY22m2IcspiBkjuo4pBRFn7g+6RcfbWscF9r0d2HE+3mQW+JiGbPm+TzJQTjm63wFT9AgUjOVRyZnpb8LgN/wu1Fd5qYz9GNvzgo1JFuHh4/BdPbpXEqJCcsVmw1sPQ+wsuMebbZhTiQ51WhxibUzm4W5Wcjm6lETKYDJZ6gKEBePjfo/srqqsqTFacCXTekKSkPvO7o7MkGPOVCgiMQWYRaioxxxDksMvYQl+qXQEj200GjjaUXPNjekTP6TSOVdSKcfjtq9MCDfHNFNrPiYmoM0o8BKYXDpw1EgXVh6bYfkQTTw9UdfMmEb3zCqZ0YxBaPlt36Popsx+67g/aHMiugR/dBomxrAR8EFZosC5/9R5Hlt33BkTnPQ1BbrkzLqEpt4NxvCYpo7lqgOj72jOLClFZ+5GyRXxjKZITpjTY2HjxmPrSKqoCDUVVAwbLd7QuaIYJm/YsVHUUVXKWilLJZVMOaYu2x3NjpRY0D32wW1+oaaDe07YUdroJGBYYS5Bextm1PSE+2BBIdXgno4OEh18n0bNUMpCWgd5Jto+sRSH1Ww/KzQazJNkHq+zOWlJJFeGbYzHTt+FddFjugxoJnZEehxbTm+N1gj7UYucNkFoWwPLQOdcE5wXNhH20ZlzUFIsjk9LxfrgtBR6riARJf/l1sB2VDrD43kXgSJCSomUV+7XV07rQl7CdrSIIjbpZiiGekRbuUQTgypJ3xq7P2PRtemkJVNrYkrIPeENwosbyV2O4MJo1Tlc9/dHi5GBiY1HAO8aAPqaE7MdPzud6+0WdKVc+fHjHbHJUhN5KaSpnCwiMpxELs5+uwV2aoNcVvZtOzakBccO7HmCBu2tt4aLsKaEDY+Rz8LQO6XE0Fh0TTNs+td0W3+L4Yi5g5xgPS1MCwx6H52XU6GOyN3qNsJ5Kws2YR7Fbepgb4PzeqJq/XqjBpnc8eEsdUHbzvV2j0IhTsmJgXDfGstyinF/3hFWkgalxzvMFIkQWkqMsLZHAq8olDP73jjVzH6/xbLEE10ipLG4k1WC7iRRMMe+c3p+isOz688ScAPXd/QQbsRiU1KIHbw5moK+VspCKkt0kSq0x52ExXJQEoKSUjwGtuPakbzCaKFea52UBU2VMQefX7fACMWZbR7CAyfrwrOeD9mxhdx2QGtO99hQ1zlJPpAccTHmQQlqrVNKIknmdtux1hCbqELJJbpwn2EF6h6j85EPJ0BeY2NPickFk9h55Ip4TIWi0UUOoot0mwwDxsS9A4Na4LYL5zVzqoJmC5MgseAeD2NdQbNw3yfv18R5OdOkk2umPQbTJp+vO0tRLqdyqMHSsXAceAFspaqy947biJxDAclC28dX+0pHybliAwZ7THwWOxF8hgJPo1sHwpGu7UdoZ8A3ih35cuOAGGFqiI9ySqzrCQhoxj08GnxOhg16j0MwuVGXlXR4+l4uzzxeP3K6XPC0ksbkJBawVEqsy0qqhb4P+gjfkpf3H/jm/Zn9cQ2zp0NpCUIzQdy4ZDifz5QcvsexrFeGDUYf4B1skI7FbxxKx/LQLCDFP1fRdRFaa6SlUDS23Bxb7bbvNIS6Lowe49j0FCfWviOpYDZ4PG6ow7JeEIF2b/Q5gTvXm6G6IyK8vn7hsX9L65PvPpyZNtgfQskd4UG3ARTqMMRbvMAOr58/4tZBY2ljYwS1q48YeZBI8zyYBSlFMsS6rGjJ3O63MLLRI/9KHFE9eKjH5vqAIpgT1BlAa6+s5wVyQstO8gmTuNGPxAEdRr8Pxt5YawmMc39AqWhasN5JOWGqsaFNwrKuuAmukA9/g8sl/tZhE9VY/sxjFC51YdsGs2TWtVBS4VQzW2tIjjSLc67se2e0Ti5HeoYUOKStNiZ2pCa4e3T6c3Ksfb4WGoiO1Z1jkSa0MfFhSE5M67gL6+XCnEJZT+Q66fcbosp6PpNTYoxO7xOfzr5FWKWKs6wXFmL8T8sLuQqnywtOZuyRu2Z9R0U5n1aSG70rn64bWWCKsLVx3IOOjI33z2dO6wktmUGmW0yDPkcsOJNyfTTMWsBSpVKIBsPxMOeejjmHTenbQRzd+Hg0lEiJtdnoUgDDxpGdpTmKtk0kJ1rvwXPPlbk1zpcFUz2w5kJSZalx8LvH32JJIVdUUkAYFr7PxYXTWkN2u16wPikyWKswxNjGINcVs07NmX67UdZnhMzjvpOkwYzdRvLBeISRv64nci3YUPbHF9ayYCKUkuitU5fClPwVapnD6fvAXdBSQiK/dwzBp7OuF9xi/wHhUXyS9BXymdPoLQ6AJQmag8r5uDVgo7dGb8bTeaWUjLpgPmlpYqoUlTDeTyClcNsf5Ow0UT5+eWVZA3Y5rytTEqPtIAktF8QaRYX1fGLuD5JPlrLQ9kcsUzWRhYCHrMckTqHk8nXpvrc/Y9HNKZNKjUIkmZxiQ2nu5LLQR4wBZV1IowcmNQeLJpIYxf04MYTH4x6nasq0MZAefgf1dKLtnZxPtPaIMa017mJMjPScGea02476g1lX9r5xqitjbKScYkzWhMwNXBFJ1ASv1yuOcDqdOFYBDKIwjr4xdwvTEynkUvB9C86ulFigHKtqM2fvjcuyMPcWNxXhu3rvD8Zh/dctBBZJjHUpkDNDBa2BJwnCsp7ZUFQcwwJ20MSYh4bbYvxHK6oFmXemhSjEJEbNnJR+v5JqQauQ84lUFC3KUoWEU9cnpkEfLVgPPqjrmemCkRgWMTE1J5aUcDRG0cOcerRXcq7kDPf5k49SrQulLiEM6GGKk0ui5Ay1sm939n2SBPrjlfO60AnHOgzaNkJ0URa0KD5vMAZtKGkxWJ7oEz68e496p9agOnWH10+fmROWJWMGYyj3vTH7YE/K08uJZErHSLNzOZ/JdWVIQiwFZa6HcKbklV0jx8tEWerC7d4pqYbDl3tIh/GQAOdEzTH1vX1UCYbCPK4xPkIqLhrG3dPCx2NGJl2pFaEjGMtpZcsCGrRKBW77xj6dtSqQmZ6DUqeRKDzVEc283jvDPuHpxH5wYtfk5LowmrH3nXkwjHzMeG4oNpzbj99TT9+x5kIW57bfsFpwXTEmYp1iRrKJeUQxOeCqlCRoXcLgfMw3bcThuDeCT03CUB7dvkJlglPqAuOBnk7MY7klqXyF1twP6EYjX27unfVyCUYRJ0rutP0WPOdh9LcFJ8RjiIQ1aYpldHt8jubAJqJPaFrps5EI/xD3Y6+hmeEdIbMuZ/r2Gnshc4pCM2PbHtFipJAdJ2Kpjk3yGp7Rf7aiOw6zj5RT4BpJcUmhv/ZGwSiSAw871Fl2bLbb9gCb1FJivNzuuMeGv+8PknWyZPa+IC5czmfMlNmdHz++8vzuHbU69/tg9CiudaksSUiW2fc7nhLb7QoUGA8QZ9rh8zkJhsTo3G43DAUtiBoyb5gYLsEZVAEkM3MGjziXafan8lcXtu1ORvEBRsHnZB9RvMacoT8nOmU7FilPp5WbDZI1hkTQ42id5+cz+3zw6Mb99jn4nElJRYhNoUMalHxmbHeaT1JZGWnh/ojQxvUYqd0mJStrXbAOXcC1MH3GmDs7295wM2pKAUNgFHF0dvrWmaPTRw8RhyRsKttoeN//5DoMN+bR6eYUPF2VmCjmNJb1HLQwjP3R2NtkWReSRLry/b6xPTpzf6NlwbKcOGWFOVjOz5yfFh6Pxue7kfqNbQ/MXixEFW0T7BDkMEEk4a5cX42yrOGB0SBJZ6nz2KSHQYt6ovUZ/iE10RxKrsxxjUlkbIwJ1jvLUg+uMWjOaF1iMUV0vafLE8/ngGNsQJM9OqJpTOuIJCZBvVQNu0dU2e4bqd6ZGBnwY3lptwcmlW4RpLqqHPdYtAx7e/B0Dl53a5VSJ6kJ5pfgFHuYrPcRXf+ynKipsm8P5mMPM3WvOLHb8G1nb07S4KvPkhn7xn69YjWmVVGYZIoK1/uVmlZ8DqztX3m6koLOCU7ve0jv60IFti18hNfTgo+VLAXE2bdGqUGR9BQRXikpfRgQk2jKBViY4wZ6PhgmE992sjT6GAznWD5Oci3gnYlwfvcNJgt1ObG1yXJ6Yslr7BzmRG2wZAkfZKv0tmOacDLWdkqC2xaUvmVZcaJTL1m/7jvIQZsr/zxI95/Z6eZYnInG1s49+LdpXdk32PZHUCoQXp4ufL7eoM3g7XliCkexjQTU1gMbEYviq+4wGnlupPO3+Jispyf2/krOR57adNIpU0vGxuS67+zbF06XF0qBcUSEUCpju9IeG0lT/Lw7e7eDMxqWhTZCOKEq5BoLECkLP4GahpkE3fK4DiIhPEhpobWDQqKAT2oOKAOF9XlBbBxigrgu00JYoke3NM1hhEKNsjJ65vK8hKqp9VCszYmLkLQCjibHbKdqCTPlQ2ZtGMOdmhIuidYm2Z1SCm1vPG53TuuZ7b7HAmXf0dNTjKc5isnssWh07BBPTHx2xhykGsuCWvIbZyGoSzNSlV2VrBnRxGNr+GzUdSXVEzZ32jDWkvC28eXeSJqRVDmtNYIfUyj0RALWWRZhXRJJHEmFX3x74fX64GEdZ5BrpdbAibd9Z06odQ0mx/Qwwh4PcnEkhaGLo7QeE00sSCUOX3fMoB6kdydxe2wBC2jmcjmjJcckV+RQ3/En+F0pmVNWXichac6ZobB1cNdgwOToMt0mbbvSth0h8vPq6ZmySFAC3UnnJ1JyUgoKlYkyFNQbKReyFk7Pl6N4hrNZyYbHCcOchd2O/Yt7cEo1aGBaFtq+BzY9OqoGZWHtx/UQp9bKWE7s28beDNWGdSOthSFweXqmpKAzLufzV+HIsMnAwsheFQ5FqM/OuhTaFLatczqtB+d7Ums9dkDRzClCn4PH4xqvS5JDH5Co65kioKlyfWzImAxpoexDSCUEV7fHRqkL6fLMZgmxhhs8PX0IAZJnTjVDhbZvbO3B3jdU4GlZyFXZXmOJft96fK8mnAlao+B6WAQYxhw72WNh+mcrukijSEGmI0mY3dhGRyQKUshG46burWGtBwuzVubjEcXtKNbRWcUbfKIRyX26sPcHns5I21nW9XD2ysw9pKQpNZiZYcYYg6VmllJo2w3szON65+ndN/QREP661OgIR2O2FnSUVGhbZ2+DZT2xpPDw/Hy9cjmdvnLwzCJCXLyT1PlpkoyR3IbR5kCsk1IsoNoAUUN1hKjgWJaIKH4U/pQlMMui3O475xrUJdRpfQMNfKyUgx9IsAmSwmPvlNNTSKsB9R2IzqQuK9OJOCJRpmZOOehZ3h21ye36Si6Zsp6Yc+Djgecz08KmUMQPQ+aQuA4mJiUEH30j1wtt/kQYK6clmA42D2/aiCUXD46mo/TtgeZ4fu4hrTynzGhR0NM05lT2WTAJ9dxTVtDKbR/ojISK/tjpjxaevyi9hUXk3Dfadkc1IBoscOm9dWwYv3l65uX5XRx0dDzlgOv74amhAZ0BQZgnqH9ZNLjESWjdUJuHlWUsXhSllJ/eOm3vWIv3hTlB2G8Tm+EJweG9AG+y6yhwb4f53F+Zmg/81ljKGhE2EtJhx6N45oocNMX9vpHOF3wYSAcThg/K4dFrx2P5sWOYQ6CsdAP3UAxKckqujNkpZVJUj8SUgpwzy/JEHz0mzDRjV7I7Y4HlXElFmB7SfDi4rblQUixkbQzMO23OcBWs4X1gHqwM6502DTdnPZ+ouQa1UzLLNx9optxuG82NU6lMU5a1sHenFmH3LZzKjuLZXvcjyDOWYf7GjskXxhzcHg8kF9ICrU2mK+7BFZc3C0sGj4ew3R5oWlCfPPbGuq6kssbz9o5oIR1MkzlHmD/9TDDzP1x0s0UsNHrQ6SWw2jknYxoqIZvLqmx7nBgO7LdrLEjmRL0H11ZivLc5EBsUSdicFE/Y6DQ2sg1cDqxPhOwdhrFvUZREHJdM77HQGN1Z1xMJoW1f6N4paQ3+KzMym0oJaMFeQZTb7cossQB0h2170PzBcpj2qL/lovHVTxcc0cG+h1F1LBWNx26I1DD5IGhKqoIsS0S8mEemWMoIE9eC1GB2rC6QS2BlS4zf7jkKo00MpfXGqSZe9y2iwms9loagNpDZg8erlUxsySdC3xuYBX96BD58v16BQWcgIzMIU3pRiSJ3wCLg5KS0fQtO8wrpZwe5YNR0cJ496E2OoymRj8eTFJDNNGgO897AYKkLdQlecO89zNPzihPOZY6xlhp+CG5MJpYi9mcevgDqPYqsVtrYYQxeLk8InfdLxdTZd4swToWUFCMWluVIA1GCn9z6ZPZG2x4sh1pwScKyBOVwGHEoeNDJci4sbybm7vT7lY4yZwmutemhTAxIQ22GL4GGWY4tK/u4HsuYBDJQKqVWSk0HzzUxW7yZ37ivZrHdnyZsPbE8dp6fz6hWpnfUMn2bzNRZlkzNIfLZ22CfgpQTeDB0gm45uM8HmkIQFGeDHWybFJiyO8kWzI1UKm3cmb3HVCDKtt2OTpUjnqjghEorp8G+hYIzueN7Yz0ttB40zCmZuqZYaArsfQ+l43KidYex8Xyu9H4wRrwzu1DzQlLlXhd839i3HkEDB2ebKUhRsitZw9RmPZ3i/T+M1/bg6bRSSsJGuIXZhP6YWA0jqzF2sghLUXI6HfLuQdKMz0MudVwvlUxdC8Y/r9OVNzzmv/tFCTnBN998c9BCjlYfP0jB8LP/RIX62eOFEsePr4cM9edf9LdvEvkTzn1QtSQ6adVYZgmxMZavz+3gWr790PG5480flPy3Bz22wBBfP/AfJUD4t2vwJ8/wZ/jltm3crldSSry8e4nv//q73566fO1m/nsfPz1XP+hKwUh44yfOaV//7q+PcVyjt0e0g1YT3E//eh3e/ExFQ+cV//z0/AW+bt3fQgTfnseffNOfvEJxNb6GDmpIHD59/IS78+7du1hE/P/+0uM3f/3Pz+6T/85z9uNvjPsqvudPvv52HdxjJPa36/H2//71ceNeeXut46bRr9fj+ItE/uQ2jL/Rv/6Ot6f9lQ7Jz1/Rn3DcMTqfPn1CRPj/2HuXHdu2LT3ra61fxmVGxFpr73PyZGKDEwwYjBB+BBdsUbIoUOE5bZkUSJSggDBvgJBSKI0h7XPOXitizjFGvzUKrUesnULgLeUp5iztrXWLGDF676239v/f//nL5++/9v49zXf/413+2VN1/fL4/r4J0+HkQ6+fPbppr56r7udrVb6vj5895e/LaP76x9cy/wwfz5iP5z6/6O9r5Ptf8vFsvj+rAcZHS8HM+PbTV3rvPD/f2FbPUvz+T9nPHqD91fVmP/95fHw1MHXU9v512s8eCDLfY6YT0gfO9rOvkZ8/S1FnqKh8fP9ubnl3mtrH1+gb6PvXPXiP43r/t+X9Gbq98P+1xZoZ/+a3v3//7//PHfgXbbp/8/mbz998/ubzN59f/vn/23R/UXvhv/4n/xW325Pv/gN3XZn3MnzYY5i4YUCD+nV6VFq73ConQgzvpgnBmMCZEElT5dDLA8F7SkRliFOwShn01okxoyH5qTQ8ztnPmkCYkeejd0SEaEYI76eXV8ga3d0VY5zwYaOUhojHx8cYHM1mAY3uouu1IGL8b3/+v/M//6//gi9fvvAP/9E/cn5Bragq7yaUHN19pxJIKXmCsvgp3Ft3R1Fe0BCp73rEUcH6PMoHhOzPAGe0jjGZaSHxqExmhIvt71dxW23KgPdWVcSVJYBNKNHoPlzKqw9QbBg5O7qx1mOyBAKGufXZzKffyHTERTxSxt04//yf/jNqrfyX//gf8sOPX+h1YENmdeJKjQGMVt0pp56nJ+bifkMYvUz+gOCFU0AkfK/65y1kiDjFrQ+GCUiiWUOjO5picBeQBpn6T/xdS4nLbNquO9q9hxtk3mzEWRNBxQfE1hFxd6ERUBws1Fqbv8/tzaM7X0TF+Mu//C3/7J/9d+SU+G/+yT+mtkYKC6XUySTxllutDebMQ/Bq3Y0l3nbqk16V8uLYSHNzgImSl2UyGfz9CGKTJ+L99yUmljW6trxXylWm+Uh99jBs3hADvVfnQ0+lThSnvsms7lt1xc17BafillvrAxuNWqr/nqDI8HYNw8gx8E//h/+R3/70lX/wX/wD/vRP/5QQfID9cRsU70NbvwhBSZIdCSs28aHzRmD+74agNMQRkgKlDlJeqN3laTlFhkAUH55bL/TWXYshSu+DmFyydpaGxOBcBWPeGDoigSCuTmrd/x2DCbgZtOq85yWFj9tewNdHa92FBCpgwyWBo2M0/uzP/uzfup/+ok33P/t7/wlfvvyKYW7tFXHoTa0XrV2uo43Bh1dROUslJuOcoXaDTgp9ygDEN+vR0JCIOISllDdSWsEcsZj2hRACj/tFuzoprZgEejMEnwTHEDBZUc3eY27eX9ZWycldZ0EjIc88r5jIMdGq2wYHgdb9SroEpZ7uusnLSimF3iuqxlFO4F+wbBv/0d//+76RFRfn5+QLmF7AAmvOs581N/4xaPXCTJxuHzPHdcwpuyHdHXuNQe3u7DKbcjcJlG5gyreenMIlkdE8RmiEyNCEacTMgSMqUFulj+FGgd5oZ2HJ6mkJU9ER40yx8G0OmwYIFbfH2lByDKSk9PpgWzK9V/7sn/+3UCv//p/+e/zmj3/jRoqhPhwaPn1HncKW1NMgogh5SdPaaYgMxNesoxa7MAxyckbzQBm1Exdcc6lCHcqwSLNGSMHjboI6VCkFXPeKM3KDcvVGA8c2mnGelytHVdGJawyThqbiTZwYlzk8wXkaNj6u0wOPXpLRiCr8+Z//hS/EoPzn/+Hf5XEerGmjmaEpuEV+OHkPje66E0CVqwxKmyqKEJCUCGlltMs5G4aL8VMk54w6dxJwu3zvg5xcYne7uTFndNeR2sApfIhrzc1lWK03b9EMVyBtObJuyXPR1Djud++tmredgghRnEDH6NTzpNeLmDLtqqQ5uAmq/Pf/0/8CwG/++E/4j//ef+qyzhgd72iOuvS48uGxVEQnmunAbLpYZ6RRjNGHlFE5r0oXo1Svr9ropJgI4uaLPKH5o7tnoHf3wKkEJAiPalx9YMHDdTUmSrmQMUhpYQzzAVgfdDPv968L9aqMJtTu+mIVQxnTJDRVIOAIVsy5xzYo5fgl2+kv23RDiD4IkPf+Y2c4Usqxg8jU5+FSmt5mFajOsY3mXNHZQzTxStfthuInNAPNgqhSi5GHawz7AAl+UrVWHSca3lk2ibRkrstJR3nLPkkvgIlrZMWlTH6SOm1rdK/Yc149ekVx8hFTezdfAK8yxl9t06oipoTpWIo5T9JWZImBGNUr+TnlFrWZHGtA900Aj7BvpczfD2ZCM+fL6mS6vffAuil0MPHf23p1pkPw4WCM2U9uVUa9nBBlhsSAWQCNnvIwcH301Kcu+QVVcZap+eAsTlMENolPChrdNNI/+sH4QKe5+6j37tW8X0KIIjAGmjJjxucIkRRcb4pOC6Z5xI/DQ9yWm0JCLBDyQKTBBIILkWCCMr8uAJvAJX2vqNXtwTNbTMyI4AO9aIxeGN0xiTFEN3TM6tcpnv4GRPWBooZALQ4A6mb0UqA3LDib+ONZzL5w6447DRKpY1ZTMTPMwUuoE+TMLvjAACWsQ5fuDJDq4HIJfjiNOBCN+LK3iSl1M4omqAMiQjdF8441I8aI9He6mfc3VRU0IKU5fjUkTCKdRg4ua7PRnCetMvPg5p9DWbaVos4R9irXAezdfjaDwG8OvUMXc26BDKL4zVEmmMcwL1aQefB2ZM43NETX6oo4dgAIySFWmHNRRoNlSUTpdCquXh5uUsCh+r07OyerB5CGmDFtlHdaGMl19bMfrBhJnfhW51oQJvhqGDbq9Cx5pWDWPZJKvXCR8DNcwL/l84s2XY2CBwcEWmtcpdJanZSsjNigDXeEDHNu6pjl/IAJnumT2uRX7tac82mq1FEJYWIHQ8LMZUVNPNxRRScBbJo0FEJUQl7Ja+aohY6wrMlr4LTQrj5HM+Je+Ikt9KmSuMsOcf0oMCrOoqXT5qFh8v49fR8AqfpV3uagwtsHnjic51XECWYJDe7njxmYtwMTI+VEl0yvDyRmynXR7Pum6o396fMPjiQMNv3+82QPGiBvjCHkdUdw9cf7XJJ3IJGB5oxd3nr5GFjhDNhlSX6FnsMRPxhnGwAlhETKARuVFMLH8GB0XygiQut+/YzBGRaeouAHq9u0HXUZJDiDwnwDQgU10KiIprk5BW9rpMx5nR/DIJXonvh5/zXxBdubt1UkBIb7NAHzqB0bM0peyOtGL0Ivl9PgKM7i1TjfVR+Q2OioDmT4wWPDn/dH28W8nTL69wNoiCIpO0RldDJOrTMmoe59bWDQG1etoItvUKb0UtHuOMPR3WYvCCkn0MULHPGEjdYrrcNZFF2gmDK6V7Ixrc6xfS/NvYx3tYa4ycnUyDHO4ZyQUiItrkO+Hvf5jngrK0TfGBmgKaO90qtDyNtZoXt1+H2k5O2rUSqmAAAgAElEQVQ+Ub+puatzkLMQcFJhb9XhMEtkjIgMIagDZzQElzz2Tm+wrwsEpVonxMR1TgKfTSfnMDBBxJBhBAYxqG+I3VhydmxAG+QceLuu2Upz1ZF9tLQaaZq/+gTrO386zNvooHZvLYzeCOKJxaObP8NpDkpp+cNtui4L8xSDUjqtVV8I6pUdo9NL8aQEbPJBFdpUEQy/TnYzj0Zp/uDeu7IpOAS4nYOSfJrYhlOIrBkdbx2IuD5yXTIpr8R1o5uRswNHrA+ITtpXEiR1mAfe2fAl61CSd/RgCA5FSSk5K5h5pZTu01Ebf+WlUlEkeHXYhkErLDm53VcGo9hHbzWkSJrVotEhgEpCaTQLLNv+cRCJ+U3CJHg/18yrQTyFdstPrgPURkoZA0ra6ZMHLEPo5lHvkgLahVobhhHMe1y+uEFSYlue5sv3rh+et5jhMUVjCJLdGefWYJdxvU+AW/eqR9FZgfonqJKiokOR7iAZ3g8EvPoO+IaL+c0mvk/NcVVATup0N1OagZpXiKJgNiHSwyaqEWfyqk15khCjb1w5J+7N2RESMiG6JXe04vJEsXl1Z7KGO2lxDXCrFZHZTx3zehl1VrmG9e/Xn8GgEz96oWYR1HGmLrEUSmv05jOCMQNb35UCzRQpgxAc5j2Gr62QViRmr+TMvKU0wfqNRDeljch1+PV2jM66rb4ZpUAMfpMQdUt4q67jDtH7kWKDJWcvDmL1G0eI873w701jdGdprc5YiMooF7V73z2G74oizDXrcVIGW60MGjEGoihtOJWuz9sNwXuoQZIffFMtMMxv0GuOaAw8yoOYVmT4+2EheMuiD2+nqBKzziQKceqcFY9Yakaf9uowK2myxwDpUKIM6O6CQ4TSPQ1DQvCDF3NGsKqnsWA/K0785qhBPVjzFwp1f1lyRDGuw6+Jx3V62sCMejFz9qpGwUgkINqFiBsFenU4YopO76r1RGolSSKobx4ynLVpHa7W0eTQ64BMdJ26bVUCa1o892vgIPGruQ++DYJGckik0RkqiKTZ9vBT6l1+FNRbFzFG6tUpdfC0CS3ii9ZkkvPrz2RvLiMZ4yKJkJJXSBHY9xUJzEHhvN7NiJraL5+RBXfpRBXaUHrzGO9eB2gix0hp4hFEYb71mpC0u6g9blip1NLY1p234+CqFdHlQ8LiFH+vtlvvDHxA2Mvd2x050keD0dC0M0aj9EKYg5mggnVnGS/LSkA5ysB6YRFj8J6uDHES86O6Qyom7/lGmbjIFKZUB/oIxOzXTrq5wwtFusfumEaSRmqtHoktmUSnVh9wCIIo3I9Cjokkw40rBl0jo5nzPzAkKK15jzziV/yBurnA/ECMKaPTQGQiyBx6DeuMqHR1Yb+EqTvOcbYYJuN4vv/w3jSKtF6cvRrTnC3E+b17z/CqjVq9pxyDx5KX7m0PQbjfD7QXtiUTYmRIpvVAGHibCGWYM6iDeFpzM6/a7tPdlkanWXchf4gTFwpldNp5p7bGsizUerI/v9BbxzqgfqDE7HmBruB6T4Zxqt7onlASUuA6T2eXIOTws0p3Sr9kvFeF/v3aEEp3/TNmWIjeW1YcKm6Odw0443ZJgWVVos13WJQxjEWEIIKpMaYRW4OvtRQ9MLdczYfP6regqD6Q7F14nuGwVZRlXXz41rwUM/O2W05KmOwJH8grSJizG2+beTVt88B3g1MfjaDfbz9/7U3XrNHGINDZtkSpbUJuPKRRgyKhsobMInMBaKOfHXol5xUPi4QcV5aQ0Y5/w+rQaCGRl0y9GvvtieNRQQKmPsG10egoTZSrOnV+M8FGwEaGehG3FRvNhxD4BsLwK4uKT8glClYrOgTp6n2FOaCIUSnNr/YOl46Uy6e28P4OCgNxR4oYUKg0Rq1YM277EykHHzqqoepDg9EHy7ohOHg8aCCpUk6/8gRVmilnHT6gC9EJUjlQEOq0NrI/UWojxI3cO0OEx1kRlBQj++2Z63pQ6qvHiYvS8cgRt9wOjrNwXif70zbNGNURg73RWp1x6n49Px4Xi3RYEn3Uj/bdniI56IzBCSzWKbP10XQOIGIgh8hlispg2TbO82JZdkSzL4B2YbOnvITFB2fR70ApKP042T4/82iDNS7Tau05eIi/wKN1xhKR1shpY+jw6X8QRowondKbb5qijFGx6hHoow+sQ7BOG5UHJ/u6cNXOqoGkYW76frCrDGJW9iV9rI+B9/gFmf3q6H380SldvNCACU13RsXTbad2eCvweHulVI/Jeb1wS2k3CJcHM4qBGLV1Hz6vfp296uD8128U83RtmdjP1aCXRkdoeNpzvS7PopsJvq0X1BpmK3XodP+5c9IHadEr/tYYbZBTmO0Hmx07cSORfNdqhzA3u16wueEOg6sY13WyL5ll22aElw/1rDfKdRIC3NaFGJjVeMR64TgPmGG3e4aaV46G8xUw32QNFGUgDAnkJVBRagMTbxPlOFiXTBalmKAxUmujVS9wygTzyJxFRBuQXC1SSvO+jybipIr5rKd5O1MHbajTB/9Qm64siaEw1JPPUox+9WcQssOnY34iMFj3RBgr5/UTpT/QCSiuQwiWvL/VL0qpnCekuCO9IRqRmIkIwSPOqK3QqjMMok83OE+/mgcVkAa1Y/Xw5FJ9RnunnG7bsz6gd2fQik+Uw/BNU9NMGY6wBX+xfQMB0QUdjXKc3hqbimkRIeXIeVWkdzKDijmEG6/qjObAnjGjPYiAkgL0enrLEaHWyolf70iB+/3hGEr85CYl4roS8ko0ZWFlBCMvO+V+0ltx0LomVo3UMn32fdBLp55usUzrhmom50y5TtZt48vTE49vb4QzkUKfE3rvQuaUPBcLoVtgyUq73iitzJ/5fHHSQoqZRX0h9x6AwXkONLlFW8yQmNmjMnrjfByEuGAjuh3ThPYeaS2dps5VrefJbX/itjjJ30RIOMTFJ+6ddjWadc9TW5Nf7WRaaVsjxjFbL96rve7HTL+YviEzWin0mPzAUr/eRtx23HpljEirHmyK+YBQRCi9UK7zfXWgszdoo/jQa84d2tXmTCBM1UGlnIUQAlkSppnzuFPOg1q9JzvGwNLGVQbnaHQrBB28PG/OlM0JWW/EDKP6Icl1+TV3VGQslGYsUTyPrxsLg5hXzKrb1Ak8HgfP205tJ1lXFCWL0tSZl6MPunvqvfK2zm1fOK8G0lm2HSUyPhpLDoNqwzsyZm6tXjXQxuXyrAbH/UFOwdMZQgYVYmAyeL3vnVLEWnGm7XBebVPIsmHWCTmx7stUejhreZhSrosQHXdqAbY1EzRw1c6j1HnzgSX6HCOFzEiB1rzX3cZFOYZDmfrA1NVaW/Z+ssd5ec88BZ9VOfLTi5Q6vpPn/tqb7ro9gQZ69WpQVcnZJ64qSogrTSBrI2rmKnfMEjFnl8l00CCTwjXQ3ogBljVyvt2nbhRiALuqy0EqvB5vjN7JSyKFndKENjrkwSiNE6GUSo7C035jXBcprzTtSDfGJI35Zmb04QWEqnBdD3o7CMvCcO0EYJTaPJW1NAZCSGl67r3NMGpjSxmSD9UWMXSciLnUqc6Jforhw0W1rplxHtTWkKi0DtF0SmAyvQe2+IyslzfzZ7+O+Xee1SORTIPnwaljMssYEDq3pxtlGI/7QTka1ZS4rtB8GFcNzvvlPcPHyefPL2xPL9RyUltlyf49+hDOExYkRAeljMFtv9HqhKG/bzXmPy+ZlU2pHY2R7bawLAvWjdoKSY2AT5xTiAxx7W9Q5ShGreaR36pAIuZAMhyGHYS8rKhFb5nUk1H8uqkSXZnQK9fbYF1vxAXK2Z3v0S/2H36EqNzvr6ThM26ZAzhfJtDP0wchOVHrxaLuZcyTSCYpkhaPeX+PT1KTOdSbo6MpK3o0pV5uyU4xcZwOWa+1ebQTXv1LcH11iAtbgXpCLw/ezkZaNugRm/382ht9wHUNbFzc4jpt+QvbLfP49pXrfmHbxkJgjca+Rmfetko/D2ScSO/ImpBeOb5+JYaVezmI60KdySdWissIrToYf3ilG7KRcqR0b8WU6q2o3j3F5EOVNHy4FcR7sqado5xsyVUAyultl6lISlsChFGNUQulG60lrrOg2nnaVugHSufzy4+McqcDT/vu6b3DiJungtc+3MKtiUcxHlcnhUyUjkVH0N7WQDEXR17d01hUIqhn8yUVH/A342qVELyN1s3bMqMxdRJGM38W3QTT6Aqi9j249a+96bZysn168ZUTfOGXCQ0ZkqjRp7KnCDYKtRcqoGEhBpfWlMtZA7W7mAprjDGIObDcVs7zTmvCo16MO5w/ffUhrAn3R2OgrE9PLFGp1zeu3lB9Zn9S1rwSzkaMiVYOYnAYucyqptNQGZ4CEBSNzBQEH7r06r3Abo4UezsO4oy+xpx/+v5StbPQ4nAhvUTK+UYUT58wUZgAaecwKKF35CrI8Hw0JZNDpksEBnFZoTZEG9ua6DiaUYKDPXo11Cdw3HLk21UQibOFMcg5ewU9fFyoaSFaoHbo4+T+9iBpp3V4uu1A4dtPb+Q1YO30l8wGS04ME0YXtmBOkRp+HZd6MGqn/DyCPYWpsXSKfv6wWSuld+hG6W4aaZhHmoeFHHbM4DrdmLLdnr1dNW8le17Zb098e73o5ysiQrUB6wvhysQ2CDRCMIYEajNiM1orSOuEbfF+ZBZCL/Qu1PMkqUeEe2JBnFjLQNPDxf4Kz9vqffeg3hIbnWVZ6EO4Hgdqhqe/CDF/n1RLEOrViKPTNdBbZRBJGniURjdXZAwG1nyY+ihCe71TS6deJ1kjNcLjOqA08v48Nc1+WPz0qOz7Th7CogGI9Fq5bc9c60HKEUnKGiMZH/Bac7jT9aisyUieWkktBWJAluTp2+JgJTG/TocZQY+43LH3wf3u/fQYlOPtlbBm1iX64PHdOjs6vbl9NoinPzztG1EqIRq0SqkNnSaq8yrkGcjpqNhOtOYclalN3tbkkCiBa3T2fWN/3riXi85KR6kmDOmMmCijcO+NvGdyhMe3B+vtxvO6c+93OsJVCyaRFFZU8MG/iJP1rCPWyWJe4IRELYMeYVhzNUSHhUiUwOguiZKobnb6Q226OlySMYa46sA6Ohy8MdRPyNYeyJ6891MbklbCCtI9OWFVqEFpUujjPUhxY7tlDuuUoyOTb1lfC/uS+HpvSM5EKjl1SntwFlDr9DqI2bmqoyRCH5gpaYuscQdJ9NAY1UgzFXSMgfXG42rEnFhT4KidCixU2hgMAtu2TrdKn7i/2V5Ql6mZuJFgtMOlUAmXFUlmWTePq55VkaTAEI8DX552jmqkoaCD3ivX8T0Oftl2hiYHAiFYAEIiWuQ+r2YvL8+81cxNOmeHlBImz/z0ehCkcI3LT/28EURoy0m5PPivnBdrspms4C6eFP1qJxgxQI4LmOtul21D6omSWURwXLs/ixBge7q5RhUIUzaGGPROSJkwr+ExLVwdQrvms1WuYX5rCQ6eX3tF4kZnBwnElBg9w/Br8tXabJmZR6OnyJI3pDYe7aQ8GrcstLevLM+fqNdJb4G316+uOlAFLqIq25JmP7dSWHxoaZ3ajJADx9nclZZcKhc6rMmTo0sdbEn5iKU04+3+QMbgfsG6+FCtt4tB5OrvOWOZNPvLSES7eBvoGqzbC6iwqfA1FkrrvN2/+kAoryx74rZH1k0o7eKnV2MpB1cZhPYgRFjV2G8LR+/Ux0mrF+dxp9WGxoW0PPPyZWdd/LC/HhdQUUlc/UHOzyzR49bbVIXElBGD6yxu8hheBIWcXBYWI2exD6WDbz8DmQGmSwrs24LJxqKG1cM17gJvtbspZL9RS6FdhSBKjsIahZyCN+YCLPmFdr+zbpHPv3rm6idHAt2e6KWzhQQmfP32lUHn9qsXam38/t74/OMPHowpiaf9ha/fXrFRvztn6XOQdxH05OkWWUT49up9Zh3GklZa80GqylTRDPP2Fl50tKnn/oNtuobnRWnyfLJhRrfgds5+0syB2fRGeMAaF0iZ4zHQWhhBIGUohXEVzlooAjFCe5wka8hwXWkwiDI4fncyJJHWAL3x9nZg4XL5tcDTy2d+87K6rXLAyxMszxtLjijZ0xI0YouSYiaG7FS0a7CvG617oGCI+PTbXJeXFPKavCd7NWot3jvCpd9hOrfi/P+q+LVrwLZMPa+6HlVVvlP9gnLeDyLN7Z3LZx7HnXINlpR9SIhRygl2MUx4lIHEnfj0R+joBHUE4ssPL5T7K2t3Furb6xujFAJKIHGORrNKVOW23CjlznUV1ySL84vDvMrHpMQY/fuads8g7ow7jkqgc1uST3r797jt0YbbYoNMK6k5Fa44UF3GQRRjTd6ryznyuBv1fCDLToziPbHmpoUYxQdzXJSzsYZEfn7i9ez867c3fvwcsSVxv1+kvLFEp41VHB25rEIrDyzcSNdFWBe+fbuI+Qlph6sTavA+ab2ISV3fKd/B4iF6q8nz0pRSKr0UclqmlM+NM5cJpX5PwdXRQTKKa8lt6ocHbmLorXGUQdFE7b5xQeNxVXQEHlcnrKsHAKQX+vhGlYVRDoRXdN0xW3m9F1JUnr78im/nyX5b4C2w5Bt523heN+iVPk6qdCDR1X8Gn3/4xLovLBm+/OoTv/v9neOn3/o7LbDtKwGo551aTgeugysK5vd5to5qno5JGL3inYVp80gLKSesFd+0Rd2skSMxBNRwl2Za+GTfpWYDL06yKvsaWPfkxqOwkUNnHG8sz09oCLyeg5ZA9hvDIHbvZ5eRYdmJstC4iDnyw5ZYNWF1eF7ecdEtEKPbsMdEzgbz9gbmw6RvR2OMSmvGFTKKx0qlGJ1k1j0dRs08wmd46+g8fpaM/NfddEvz6I9EJibXYI7uls4lxung6eQoXNYJI1DuF1kaMQldhXY+GK0gUsibEdKNapnX62QZsKaNcgqrQSyD0gYvL4GmkXI6dHnUTtBAvu3kGHlclXo2EhXdfyAsCVri7JeHoYSMtcFRTkyaX3tMWGVwXpURvGlP95hptLME5aqnDyi6u1eYTqxhxtXax8DQ+uWhkUNmDHTzHKCgaJra1eld7x3HVcaNp08v/P7rnXIdyDBKUR7VSH1jybtDsLu7pkZaKZMVIelGq53jfifpwutRWRJIXIh5MKqzbHuH+njForGtKy/PL5THG5YUPDRnaom9usXcfRdVsNlv96XwntmFmxmG9+DANde1XmgX4jRNRBPCcgMT2lWQ8O7mM++9ayNGZ3jEmKe3vhGTkkNi3268XW71LNV4DKFdB7/ehX56uGESV598fVTKAEKiYvTW2HIkjAchJtrbSUhCa5F1y4QGoRVPP1gz25oIAYYM6nDCW32Pnm9Gayc5RdeMF5ejMRN7Sw/TwTYXUcq0DtDpZ2HMwM1uEVUhReM63XQzCJR6MUacOmMDS9hRWPNCTwuPsZP3lbBfwIX1Qj0Kt0/PxGzIuGjl5JLO021njfDpBltQtuiGot9+u1PPg7Cs7M83Ym9k2Rm1EWNkTXAgvD0O9ucb53WwyHRndOdhi6Tv7reYGJOtG2lclzEuWBd4p5DV4jH2Oi3PGtxMlVP04XRevKAYSuud29PqLaElMIaQtJMyxOA3v7xHpBlxf8FSQlOglK/O+ih3cgyE20LtbtbYV9fU3t8OTOHp6Qd0RJab0a9MPd/o54M2fMB41s7Rp31YlJR33h6FRufsg5c18vY4uIaypExUILoZuJX6gdksrRGss0bhl3x+GU83RwdoIK7jG5BVCRpRc4vtiJ5k4NdCxdpF7AdtyoIYsO+RxXbOXvk24HHe0Qb9GFxL4P71G1+eFr79VN0ccDU0uqC8XG4jjHFDJRFypHZIEnjaA5I21iVyjgLBp4rrrB569yFeHx21QOvGftuo1qmjUFvl6bY4uLwbQTuPXhiqxJRJ6Z2d6nuwBFdCYD44e96fPGKknNOTM6AHhnWUgkojaURwI8f5+sZxvBEIXP1EiO/7OmITAB8ymcTQRBlK1x1Nyh6VVyJdlWp+iFj3TLq3t4tvr5WrDSSsDCtctTBqRPsg7y+oDr/mSSWESApuXumtI2IOVWmdPpyOv4aKJWXLG9d4fLwTfTSG+UDTdLJUNaLm/WzDHToxKFTXArceScE5GEV8SElMyIAlKL031ih8+fLMv/zXr7Ra2WP3zbVNHN/M5ksSkdEp5WCJSl4VteHVahvkoGCDmFxx0wbs6xPVxpysu+8+LOpW6PdKphzQKnFbfCKgDuux8T7JTy7D+9mu25q3DEKMHNdFFKMRPKm6DhB3hNXSuGpxNYQEztIIaWVJCiPTLBFFebllOjYTMbJb4/tJOU6uQwjyE+vzCyksPK+J1Ae5XizL5rIwNRZpaC+0qpy9ECySeiEtO2+/e/D2ODhroZtLCPO6IWmdZpqVCCRdGDlQ2onhrryzVVotfvVP2c1O8zm8xy65rye5hI5B7Z1x3snBTU5r9jnP+XigVPK2ETWRJJDCIBqEvLuFWlYsDGJv3EujhBvrokQCJC9OPDE6kfJCq9/ISybffkTEZZ23PXPvFy0F0n7DzpPau/ex6YSZ8EvKSPQDPMXhpAUNZHDX3LTQj+EgJTPcHQdTfvcHbC9oDMRtdX1an84nfPMJGtAgNA2M7j0zCcpGoBWPDR/95PayEffE2Yzj7FTrkIWFiIYNLuDNMO3sopyW6ONCm1duTReHSZeDRRv1LbI/7R6Tvbn42SRz+7xTyqAVQ8iY+tepArQ+q9rhOkrxnm/ed1+so/n1O7jmteH0NPuQjCkpZVIUzuNBmPa/1rxCCpN6Zd0tmzZNCym5Gyontz0OO0niETtdlJw25DwRCywpsq1OFlts524bkUAOO6+PB2tQPufEFQPnHrj/9PDhngnnEO5n5TwKeYGwBt4eDhKyIJRh7DGyPH/m8dO/IqbEOwlK1JNV6Q3DY2dyjAxcDreui7t0ZqWrCKNXr+YHmEwSnHoaQxndLdMYKe5c5QCEoLg5og1qHSzLwvaUYJxTUB8p9WLfd8LxRswL9u0NpLgLUZU+PIvODw4jR4/Badb49npnSUbt1TXlI7HcAlkCXXQaSJxsFWJ0otkU52dRJCUfHqozK0arbgHWd7cZ1GYfzrD39dHKSeuKBJdFKtHJXt1IwXkltVRacVv6YHiiSdrp9UJ0pZST+PxEsMRVHuiyE1Zl9AOrgyaKacD0Gaph40HaV573DZFGDZGwuJX11JXH9Q0rB7enTw57J6JqaM70GeKaUubl5QsvL8+M60I0IUndlYi3EDQ61KlJIFblGgVTPB7KfsayFU/vFQnYEK5urnAKQlCXViGelRgkYP0irxFsEsxECERUFwfUm1JaY9s2jiNRU3JyXz1Zbzs1Glc/aRrZlp1t2WgxwdMf023n6J2UhSYXtt7QdLHGO9vzCxwdaYO1dqS6Vv8+jBGnUUoV6Y3nlw2qG57a6GhxPXIwowx3rYr687Fflkv5yzbdtC3kbUGG9y9Endhl5rlGMSXqdRLEJ5GjXSSEoWGmpi48f76BDI7qV7SAN9RLb0RN6OvFvj7xuA5uIdCPB3Zbkfmy3nvEYiCKA0HWfOMpB5d2bDf6NQj7E8uaaffCLUcYPiE1UbeeymBMgXhp732o1ZMcYkCaW1tHF7eNjoaFWZHNjSltK7TirITaicmlXzrF0Tq6B96pEpOj5sYQsgSWoJy9UUsji+eoHdcreXuiamSMk2EQ0o1lvaHcGLJTWqfbZASExDVwZcCW+f3vTr69Vkw652X0EemtcI3OmgJJIvU8MU0k1UlXwzkOvdHFVR5RHSlYiuP3xIKrIrK3HGq5kLD8FZv9GA4K8UPNf/buZfdqvQ/zpFwTZzvMxZtyZNGKdCNlJS2RIQv17XSp3eg8BePx+B2fnz5xRbhM2FJyXWQr6Kis4/SsOwSLsAlUDdTHN9ZtZdGFnAPSvWWhOTHeiWXaCS6eRiWQw0C6V8gSo4drZtfX2hiOj7ROm5E8P//4LcrZCRg0g3IemCQ0pg8WQB+TF1ENDX4wH6ejPUM4EIzy7c6+b6S4YaNxfH2j9ZMRhDoG67py+/IFjsLYNjQlSCvPe2bZF65RvNWRMun5BeZz1xQ4ayOugdue6F++eFR7Tjztz6gkmnRP6WDaYudAFRHysqEUWuno7EnFnCegx1+KYX4YvUPGzcB0EJs7vWqFGIwmChZJoTm4ajSszLZESIw29dSnkNaEhMDDKot4oGTUlRgXBq75XZfVFUYaWfMNJfI4Ak+7ogFGP+nBrd4mDU2RLSicFUuNJGDWuR4Ptt6JTZGo9Ks5snZCraq5m3NMXW4MYWYkiqe1/EEr3Zynk8vQGOYPxHWoOt1UtVbX4EWjl5NilbBtxO4QnNY7ITaCFaIVFl1cXmQNu+7sy42jRqwGznJyf7sjnxbOtzd++/WVM208fXlh2W/kp0/E247Zndf7nacfviD7My0olyUuEdbsYY5iw9FX3TWaIQREfSG1jh8Kw9AYkeHWVZsBicFTKNH0Ht3jf742p58FeTdxuIZyCQaKI+1CQNVlXWP48C/I4GwdbKVcF8Jgje50ehwn62rAioSMxUSKyktIvB0gYeP+eucslYqg0bDo09+1GsfjzXWZkiF2+vXK+e30wMzTCGsghoyNwvU4SSGypO96Vaayw4Euhgb3zw/zOPkxjLCFD3eE2XQwjY6Z62bfB3Aiwr4kRgy4mnBMo4TxDhtRgRQGYietASnQULbQod4JFrmtBsfJbVGW206MN65xMK6CWXUq27hcIhg3dt2pVVna4V+LBddD18KQ7lZmDZi4vVjFnU2OxXQC2ros9AbtOrB3y6cCItQ2HBoj/l68Hz6iTvnq3fW4vXWOWtn2DRWPhEHqrJ6F2h8OgBlgTfxdkEpePnH87o3Rlbzu5JQZY5m91MqJsuw3VHd+/Sd/zNkUtCDWeHp5Zr0tcD/p5fkW09QAACAASURBVGRJK8ttxinFROkdCYH71XhZfQ3fbt5/D8Hz7K7qaE4R3zz7u4vPnImcdOE8TiROl4x6rNC7ZEzM4VQ2mbZBJqcapXVHNOaUPJV38Y0zSINW/WBWl63Vcs0BF/NQX5FRuC07Rx+sMcIoiBp7crSnCfTuVmLMlVBPy80H7bbAAuUa5LTR8YMuJT9gZZLE9i27nfea+vMBtbUJ43FAT0iXvzvTTBTce+NktfEHjGAnTCAyuEd7nmRuq/QKIC0TxhzgkszoQk5P9GLcj29cR+H5JZIiJE5CM5a+EEcjjM7z84/Ub3fGUbiuShsXj+vBv/zL3/L1/uDTD4mkgZB34vMLJxevb195K/B39p2xPnENGBbpYaEnRehYGA5bEQgONfCoFDE60CbDAQuIRAaeEGzR/991vVP8Pc0RqkpeInFaJjvQysW6LYTgTALELabdDEkBzLPVrkN4Wneu/kaQxpYXD2FU9aHIsjFGp/aLHANxNJaQaDGSc+T18itTiJGO8ull45YjP31NvF6v9Mdjwl8H53VS8saiK0ESvRgaM+24kyNeYY7GMKUVo1fX5dokOmtIBCkTVjOQNtOS5wEUU8S6wpDJanVHnIbo70gMSDPK5SGaHqLzDkzywWMfFVe1rhM+VMilIunGj88L10NcMrVkKpGnHrifxv10p5gJtH4S2elqnPfGswjnWTALHCOQQufqjZAaSRcSU8WhHp5q5vMjCdnJVNJoPTKqEdf00Ud+7yioCqLvS8ctwhIGo3U6yrBGl0AzyBJcZiQ+uY+mmB5umW6dgduuaScxPVO68e21EK/Bb379heenT8T74Hi8UrtS7sY36/zd33wh/PaV9PyJf/P1X/H0m8iPy0ayBWpjDXCLdx61MXLk0eC2ZI7q2vRv95OnNTGqYTIo3SWTOXpf1vvRxfGYIX3XJgenL6eYZnDmxKYywTMx0hGkD0KYNvShvB0VGe9zobk5im+ymBscmDH3poLGwbLBCA2Txsv+xHqLtLOxLjtXe0V08SGpOpAJAeqDdp18Wp/AFtDAtgbSgNEDy7Z6QCXNk7iHwBwWrjlwtYzVjrXLKYIIM/2PMZSQFiRGRm8+Q1B/s0sz4lj/cJuugLtw1G3xNsYkrlcfTqk6/lEnCFg3bGxA4hrCT49vPP9ww+IO8kY7G/3RiHIyDuHz82eaFV7CT/yf58mqRhsPzq/Bk11DZNtvKJm3R2W5vXFI4yiVX/3J32b947/Fo1x0zaxpQSxhwU/M2t2JFoNiwZDhEI3SXGpGN7QL19UdysNMtA2eYya8JzswATsX6xpZP+20q9NGJ5iiwSfRbXJcGZOMFvwaUs8799JofSXvjW0Vpyu1SqmdP/rVr/jy+ZnaKq/3N3JvPj3WisQXztaoooywETI8fXqhDCMP4XVUjqeN/TBa6Zzl5BiKDUdk3l5uIMrjfvLycoOudAbX2ZzI1Xxo002n02wiFMeYUKPhE8T+M5kU8oFUdPqXUYu3OT4s1zEgwZF+QseG+sCBTlRhmPvl+xDGVckm3N+aT6WB2Du2bD7oOjsjHqg0TCOlGq0MiIHX18oeOnUcPL4exFwgJSzi7Fj1Pux5dUI0Yp4HQgw+BAlKGQHR7GwB9T58bwYaHe/oIXMzW8vF9O+fPnDiXloIvcMwxqgcR6EFIUqkD7+SB3VyV20XvRtXfSCS3c3VLlc3lJO38+JpF9anjTVEWJ/g7Hz97YPja+Ivbifb487zr37kL952tvZCGivb0mjrE+u2w3VnvH5DkkOAJETE4Kgnjy58el5ZNtezjDW5000D1v3wNHEJlQRnKDSMJkBMaN6RkKZLa2q31WV4CuTkz/Yd8XqWxprSHDxH1Lq/dxr97zKHt5s6xPy2dW63hSoRCYmnH39EovFCgviJQCdnYVlviAasFkIviJyU8/d8ennmd3VQJfP0pLzdG8sS0dK5NLJnMBGsDjQaBGdO57RxaWGYYupwHguR4yz0bsRlIeFGKpvJzAPBrH3MO/4gm66VRshKYBACnL1RRmGM5ptu3HwgFQZpcVTb/eE2unupVBs0E2ox2kPpXyPjuIhrp5cIty+cv/2/eBq/47CFBw/+4t+8ojf49PmJ8SgUGXy9v8LX39PtmeWHH/nh3/1Tfv23/w7fwsDiTkg7FjOPu/N1y+ns0hwEU5mpw0IpRq3QRmOVQOm4Ri94OkDvvmGMSeR6B974W1HovbHrhk3XypoiKezU80EpBWMlxZmIO+8p5+NgaEZzoGqlo2xb5jgDyxCWqLw9Hvz0Vmjl4uVWuS031s+RN43koZw/LZiuNDF+eHkiULj/rlJypr5VtiWx/Pozvw+J67qoj4PUXRdN7ei6eExOXtDgNl1RB4csKSJLmLHxDk/X0ZyLqwPqIMjJRwDi6A7uEUXwK2ZQY3SjtopqJBiexLEulLeTWgs9DZJlN8+Iud9/BK5ycVQh9QFLZhg8auSoJ5+f/ojfvr0ylgfl4frj9fbMfVwQjKeb8Pq1kkYnLgumxrat7hLSjUJHlsbZLsbxYNONFBfCtIW3Wt3BOFzxV1F0pn6ctX5Qsxzr6cNBNwD4K1G7Ua/i1veQuZ93PK7H/PARd1+2ERgE54ykwKiVXiulvpHSRjM4yoOcBuf14C9/W6nXr3h6/g35aeXSO1mEt+Pk//i/C+k4yf/Oxd/62/8BX374NVcebPnBLTwz8oLUwhoScTxQFo8/lwdrUsKayJ9/zZ6E8zwZ+up9bJ0tNhu0dnk7SCNtGGOmYCzLk7v5isOG3gdpqpCCTShUoNROIJJyorVGWlc0Gln9dqjg6SfS0e4tCzEhifdpY8hkhPXlC8cIPD994vh/WHvTX8uy+zzvWdMezj7DnereGruquqq7euYgDiIptkVSokRRsoYYkSU5VhI7iQLRDuQgE6AMNmIbEQLZCGInkB0hgRFZlp04gwzRtMRJ4iA2yRabTXazx5qnO59p773GfFinm/Q3AenzBxQK+56z9lrr977PoxT7hzPWKsmgFiQsUCA0gEMPS6rhDrEYMCxzrl2IDEIfGEWQ0OiSRe/QIufUg/V4FFo3SBsw2kMpiM5RFRLnIyFzO3N0VoDIdw8EkYmFeXj6Fi66KiWcbfEiUrBiWsY8zfVR0rU9OEs5qlEDhW0T83lLIQ5xdolIgb6bM7U9LAQGQymX+GQom5JFOKBzNzm1M6DZczx/9T5OjzkzLrOGpI90R0t8yLi+YntEc+oMw3MX2OuOWJtMOO49l9aGBDHADFs6a7FI5jZRy8harSh0kb84IhEFCBQ+aVyKSN8jekH0K0i1yPfWIkXk9zjmIrkYMD9ekLSmVCWSRHCe5POxJAiBEpkZIaSkWy6ZLjuKOmIKzXTm0VGwnHc4JGujCm0Sh9MFi+MWomOpWmbdgIJTtKrk2MOJ0+scuwF1JZmTuDKseHkv/zBMEuzudUznXaYiBZUB2NHhZkfUayOoJMkf0fVzhhsj5PeYIISS+biVFC6GFYc4UpcVKnhiFPQ2vHmnG2ImzYWYQ/DaZLdYWmVntVHEVbJFyYAVEqFLEBYZHKlPqLrgDcrxcLROWFiiXTDRmqVcY3p4lVPVmGRqlmHKnZstm1WNZ8jSkltEPqBrx31/xMALNtZ30Oo4e/vSlOmiRA5LlEwIUQMKlSpEyHe9qjT07RJVlpRl/oFpIehtngR516FMQUpxNXDMjI43HkRa3XsnaXCdo+0iru9ANbkyHzLSMYaVwUFplFoj2QVIyXyxn5nKQhK6iukysLGhEVEyPezwvSfJmmG9ia0rZBUx6w1r22fp93c4dXoTcaKglyUbY4FSuWYjBYx1iY4F7cGNnHFXJ/KgVnmGQ40sS+q6otIa6zq0EhiRiM6hZUSoREgBXRXoosLbQEor+liIECLWhjevXYTMgzIpI70X2CAyv1iuBu46D9tcb1n4lCNuvodgkckyGFRURYEREWJJQUU11DjT0AhFI3qEqTDjgrHRUOV2qC4qQnT0yylaV/hykz4JRrWg0A3HR7tUZaIX5s0op0orGLmS8AbUTcoMeGoFUhboMjFtO3zIaNrMWe5XrIg8z0kpEUTWGn2vTeT/96IriAiRWZo+rr5EKd/rWptD60EErNDormV2PCfFjjYtMUNF13e4pUOXI6JfMOuO8CFSjGu8URSq4Pwj69x75S7PvnIHNXyAzeY0Wiy5Oe3Z271L2D2iaBq2zp5m88xDPH7pFGEoWTBmkQJnL55n4TU76xO6o5r53hG9nSO0xghF8pI2JYgKgkVT0sWOaevQwuKDoOstpS7QOnfBpVjNZcV3gTfeeqTJkZ7NE1tgs9qntz2FFKtY0qq75jOLwtqOpCUBwf2b99gc1LikMNIx3poQVMH9W/c5XlgmQ9jYbBhunWYwOYXBsxYW1FXJ1sltXrrrGJWKuoR7e3N6IRmLwP1SY9cnzLqS0FrqDYnqAunwgGFTUqSOStVEFKPhgESBLgti6LGuJ3gPQWJ01tV4PM73jJqKohhj7Ywocg8PQEmDUkUeFJKB4wKVo1iRHCY3NV1ssUFQ6IrkXH6+qqAoqjfh7ipB6joq2VIPPcpL+tk+A5W4vrdg+5Rk7cIFbs4KbtuAs4EygLGJhYPEDiPVUZ+6hHCOshixd/dbTMs1gk1sNoH93ZbBoKAeZmqbFgKXDMYBSmJ0oiizFiqEBIq8AKEI0SFFzCxfqVeRs+9+eheZz1qijzn1ISCGHpRk2ff43qFVQ1EOELLGaEtvHdZGKNYRtqX3CWk7Yh842J0yGQ/p+wXTXmGPA4WdoyZrJLvETs5ipWL44IRlNWD/qOXuK0c8fE5TVoeMK9gcDhmPGkblhD0xYn68S7+YM2jG9G6B0Ipaq+y3EyBDTxQabSpSisyjp/W5nRi8I8rcSuyso1hBrOC72Mm86MoMxooQfAa9l/UQ6zsGoyFCJIrkEcUAokNXg/zSTB5TlJmJITTleEhMMFo/jzWJstpE97epFFQbaywXU0wa4fwBdTWgMIIYloxGiWQK9ua3UcWEopqwWC7ZrCNBDGltoB6PEQtHYxKu75nNWxbLDutzLXu+8IjYQyrp5x1llVEeSidMCBSFphd5f42PeQgnFYXKDca3bNHtrccMmtwj7yXWKULykCxKZ/p+u+g5vjtjrVRURrA4PqQYVnTtAYU/pBmO2dr0hFIQrGFpl5hiSakDw+0B94/v89WXrzPvAsIdMbRjdpPm3u4B7cIj6jGpl3Q6cjhwXLt9m61TFebEWQbVFkuR2NnaYK1seO3eLiokNup1rJvhnGehNRIPviU4j0cjg2J9VHA4tXRdrtkmMovVh0gIdlUBXPF0kbmr3vWUVYXtXVaKhNywcj4LKINPFDIfwZGBuiqwS08/72mUxi3nOKlp3YJSahbhACdbRsUYX5RYYwiuY3a8S1GfZNwYdtZKlO84Oda8cu+Yph6wZjQ3j+bcvnGN1q7ROs1iuuTg5gFicYdJfcxE3Mf5QL19gbafM2kqiIl+uo8r8nDFIFC6yFXQ1XHLDDS2y3oVPahIql413vJ3QqoMoY/YFQbR4kRuIiWl6X3Cpw5UoqkanOixpaRLgqLriFFimgqMRhSaUVHTsIXRhr0bgdNnCubXbqJqwTaBhWg4NRzSUxOOPLHv8LqCugBxiNA7JNtyst6gP7yJjYrjvTs0ZsHB3ib1uMLohBGBQhSUuqIsFPgWaUpSWuB9vnZBiFyaSfm6RKxMAonMohVkZu4bWxJ0SaCntR0yQpQFHkW3PMYFg1gxZ61fErs2N6pih08BrQxBQNtZbNfR2h5Fj1tWlKMHEFKzd/MqKhl2th7nsJtx8n01249vs7kO33j2GttPbPCdr93Dnl7nZx48yXYRODEcU5mCo2VkXJ+meeAk13cttxcD1gdDgp2zNtyinR1z1FpSklSlplDg9cqwnCIRjfeCNvQkHwjW4bQkX0plWSirk2Dweeeb8+maZlATRaIqSrTUKJUQ82NEXZNCz3IxQ2pDIw0iePrgaVNHKks2dtYJpiLQUZWKQp/CpynaLRiomj7NGI+284ZKFMi6QYQps9mSQblFs7XN7t5zjOqHQE/wnWC9MqS2RZoCJ+p8lYggKIFIFuc6SiVplzOsW+BtdiDWOg/eRTKUpiBKR8CCyvjT3kW8z+KAt2zRTSKjDjsXkKrIWmznecNY63qLdlmV0gaJnB8R3QJn8nRPNxWTjYQvehaqJ04iJiaa1LI2luzb6xy8eJ3Qw3AE84Ml0/5xtjZ/mMGgYTb9m/T7X8YUgvHWGUbhEu97asY7Lv8QX28Fz7WJ7ztxgaH1vLIMWEq8NQgiha6xIoe0RbQ5eI1C9rC2NiLZOQJFVSgKUyHw9MHhgs85vBjeDMKnlAPtwmSBYeh7khIUg+HqTV0SbIGzGbITJTi/RHiPVJKyDswPF1moFy1b6w2v3d5n7XSJTp44LDl34mHOb20zmoxZqJJpCOyc3mAyGXLUSbwVPHVyzG/8T1+hu/pJfvEX/gIfPPcwv/Ubv8G1qxfoH/wwg4e3aO7O4e7rnL1ynvtzh1vOianluJMU1YTkNbgpbmkphKDUkd53eRItJE1To8oBMi5ZtBlZJ/luZExpg9EZ0xdSHpYoU1Eb6Dz4KDIbAEj9nGWIaMBT4JPFhTzcMqKAWHO4DLgiMhlWjMMu+juWxy8/zLx9hYNuC1zLiRMFvTjFl5/9fxhUksn2eW5843keoOTKlcd49xMt+4Mp969G9Au3kNozXNumV2Pm00XOlMaEXWXLB9rT9j0+HjHZOMHS9dBHqmYNyhWwyFl8zBoZpXJpRQiRM8vkxzFtEy7kH11ICsi6c+tWkbyU7/t8iMzbFmcjKRX0vqWdH0AyxGCwbhdJjfNT4mKJ7VuimOPSBaK7x2LvM1w+/6vcenGbb3/mGs07LvFrf/cpToQZT777A/ydv3+dW7fn/MrHTnJ5UtMYyebkJNZP6H3HYTpGtncRYoNmuMbhMl+drDcQR5s0WhNdZDmbUyZJ4RXSCJpCUuiCdrFkUEuCh8KUGQUg/Jsv4lxdV9RFiU/Z4Rd8tmF0NtCHRF2tM5s7INK7jqExJGXoVMGoho2qQJkaKRqO7x6ydW5IOm4phyWmNmjXc/Wrn2b08BmKE09TyBF+uoA2IQc71Gs3aKe/Q1n8R2ydepJPfvMaP/L493OQXmNNT5CmJqZEe5SI0jMYeMoqIWJFL3vuHvQUVQaU4zVSl/TzGUrkgXCUeRDvYt6MxgSYOmNOw1u400UaTLVO0jFTkkKHSgUxQHJLhAgM1of4VJLCEiULRtsTug7qwQ6DpqNpDNJIlDmiWhMYKkZ+QTi+z/WvTVk7X/HvfeJt/He/9FnccsKf/9jPUb+s+Af7/y+ue40Ye1IasLnZ833vHPPI23+BLjoGes5Pbp9AOscfdXBFCo5lyemdDeLCYgvDhknYfsn82FKbGtNITAi00yVtF6lNme/gdNbrCBswRZlpRKLAlN+NgiSRcuTIBdoUUXJBUWaYjogRbwOLRYvSHQiJ6y0qOpJRrJmSwUTQLS0Pn1znWzf2qKuebZE499gj7NTQrDtu3PgSr94uOVJPcu35b/DRHzB89pWneP/PPU2nBKnQ/NIvv49nPxXw/kXC4Yh5u8NydJaQSjjoGMiIriI3Dy0bJ04yMOD6KWVd4vsOoS2ug5gcIVio8hDISIGQkdBPESSMXtWeoyOF735dhMwQGGnyQTuE3OqxQVIMhiRnWbYtVV0z63tiMcGFlj44Cq1JKRAtGFVQi4CmZ9BsMT12bB72xP1DusNbTB/8QdILv8dxeYEHRgVq9kme+r4nOTg+T7f/Au95/4yX1YLNdJ3l2Z/g83/8x3zUv4hUT7H74j/i6MQezaknQJe0QtEMhwQDx4sj/KAkSsHm9ulcW5YG12eFUFkOmS0dpSBnQlmZakMieof83guGlNti9do6pJL5dEoXI871GReTIvOlpXcZtiOEQcsSIUp8zHfBPvRYv8wD3Qg2TrHOYer3kuKSvv0qvXyUl47/Lz78N57m1z62xWkJIkV61vjrn3yFjV+4QFN4hhuejUpjpGHeLdi7e529a3/CnqxYO/eDTOyM7TKxHBQkFL7t6No5g7qkl552qSlKw/q4xJRDimqQh6Y6Q/eTyM473weWS7vCG4IpTE4GBU9Ra4JwGJVbZIXwuKRYRE3rHENTomVCRk+/9IhqQKpr8muqpZ86BifH9HPPqGlwSTD95gk2tj2zzWucPPGj7C2ukewfMSqfwixP0L/8bcIDf4Zy6xP80eI1VHOJ9z61Q2fn7LY3iMMJ5wdruNl1RAGtEfQuICSo5IhGIooC2/YkLbEyspwv0D5hZMFyMWMQPUIZjDIknbDOrZgrKTc636pFt9RDhJcUQmCMRLO6syGhTUNMHpMEB/OAMCUnLzzC9PCAQxYENaDWhvWT64zHBY4T3JneZjq7Qe8cx8eGD/3g43zwR96GX36Rv/RvneMv/OJniC9LXvmbB8BjhNQgZeDj50/wV3/0o1z6yJ/lGyheIvHx4RbXXeRfdYJh9hAzkoG7U8umClS1oF8s6BdzapUYlXnK3gfB0rY0w4YoDS1Zx0ySjNbWcN7RdR0yJSTFaqGRVIMmO5u6nLPte8FyNkcrRVUYQhAZeCyyOUDFxLCpVlARx3qtSRsbhLYDUVLKki5o9u4tKehQ5RY8/ENsFGtcKiKXH9aci4Gdi9c5oQu+aBOFkRwVMDn5BM9+8R9wfHiL7ccf49G1B3ltdw17A4hjmspTVA3HbYsSidlyny02MOMhRIcpMmXJdXNS7Am+W6EWC1KEWue7vJQS3qusPll9gs/qnjxSykOniERpQ/SRzvYUuiDISKQAVTCQDqVGFKnDuQgugO6xKA6POorpAae3R2if2L8LxWbkxS++xtojT7F9bo3db+9yd/0xrl51nGmuMg3P8/pnv8F/8oGPY1+9wIkNz4fm5/njsMGouU1x6v1cufQIz8yXbGxuI0pL1n+XyIFAYDFEXDDE0FJUFSRFVRTY3lIZSQpZWioSOO8gZrpau5i/+SyUgIFpIFmOpvOspVICXVcYreldwIclwc5pW482DdasUZh1JmsTFse36EKBUZK+28vIy7RBig6/fJ2YWkgHkF5lc1Dxtz6muVBkyt3u3ztk9BdH/PQL/4Li9pd48G3/Dq8/c8ydyTV2TnXcfuUOLzx/wIUrH0K4DT54MeLMOhsDQZwdsGihbT1SGESSSNWgS0nZZDCOUYrOBbzPET0tBMJoXIwkYYne5kghUJY1ZT3MipsoSSFkr1pRg4lkBEtkOBognceYkiJlDGhZDDDB4LxkXBa0i575/oy17THtcsnh4Rqv/POOH/qP/3OGp5+EwZCj+W+ztfn9NGKb1L6A3hkTG7DxJqfLTxN5im2xZPfG3+Lph/4208XnMOlJimYTGQ4olafRguAl8z7ll5+L6PGQdV1wMO2pgoLe0tpIMxoQ/BIZe1jZa+qqJIScZijVn24P+6czRxgNOg9MCg2VzC2XbKdVyKhplx1SN2ydXScqg5hIQrXDaKwodaTeWGPQGJQMbK7vUOpLDEtPXVymcp+mHn0Z0cz56Ec+gSoCv/s7v8c/e/GAm/2nEMWMj/75n+Dnfv7HeORtP8ALQvK/O88nUuQ3v/I5Pj98O/7Ld3jqydPMrr3GoKzxSbC+IbO9QEChNL5rc69cldh+yXA8QkpYOocVmsJANWjyIuIiMhpUCm/uaVKM2HYJZUkzGrKcH+UOuUj4YJnNOwKRuApr+z6XCpZ9xIe8O67KJamKHN07ZnbzDoMTDSKe4fTJJ2jnN+mLiqoPhBu3ubuc8kovKGLixCixJyzv2q4ZaMEtEo++b5P3vPAB/uTkM9wbXmCvmxCvz4nTXcK6RI0fZGvjFNNlx6LdpWpOUdQh/4jJ7jSlBE1dknpHFB4pPL7r0GVJiG2OeUlDFBIpLW/cLwQUPpJ/mCaLFn1UCJWHh36Fa+xiosfQLRY0tcb2c6w0DMoJIglcyqLI9XpAOFjSlus0W0NePLjK1w80T3z8HN955WvcPX6ExVhw++Y3eWjzIW70pziYnWX91Hv4/XuvcuWHP4T96nX006eonnuONL7G7dEA0R5z875HTAyb5QghlvTBIbvIcACj0QhdevBNtij7lq7tMz/AW0IGvBG9z5wGpZEoXFzxOIBRlViErE1vdML5iCo1sh4QQ8R7i/d9Nl+kCGJA8tMMfCpPYAbn8O0xvu+Ibol1RwjmxLRNiPdJHJOYoBize/OIn/+BX+GZr/w6Evj2Z9/F//rae3nikZ/i2u3Abf334IGf5/u2/00e3xlz5aLjnU87Lg6H9DbgSewt9hFqnYFUlLVCpdOk1FEJj+462tTjQo8LnsIUaCGwecOOCD11YVBS0yfDZLSSNwIpKZIwOLuk7xewgksRBEUhIcG4qfKLWcwpStCiosCgdW5hOgSt05iBYa3IeWfRzXj5OU39qOL24DTbzXv5fP+rPNS8j0nxGHH6En5xTBEfRcsBLZ5B+Zc5af97ZruPsHnyP8Uv71GJS/T7DqsO8anGyJK6WNAhCX1gedwzUSVO1vhFz4m65P7SUTYlUnQr3vIgW51dRoAFFwlRMxqOs5b+rVp0IZGCpSphUhWUUmWmgV9xWZVEDgyD4Qa6abBpiRMjBCWbm5vUVaIoBUJ61ocDRnVCy46m3qI0Q1R4HSleJTFhq55Q1Il/8tVPcX3zIZIInPqrn2D54Fn+D3XM78xe547f5ujmdf7Os/+Y1y/+u7zjjOGF7YqDm/c5W24iRoYHm8SGAXHUkwJ0SdI7yayzCNXTBY+uKrokMGVNmC3phCCupq6uD9kooLN4E96oAec7KB8TShWURmc4Tjtn3lmQEEPE2QwnV0oSvGE+P8KoQDGJxBaUHvC2d1ziYNYzPzhm9u2v8NDDQ4am5Kv6AaYXL/Jw8VTRKgAAIABJREFUsWRycMjbR0tu71acP9nxOWv4eFny7DIwWibGH36SnZcOuH0EayLy6OkZd+98hnTtOS4++jiL6T5DDW3oGQ9LRkNN32u6qBkMIn3bkXzEyIIoBC5YVJKUylAXkqWzhCQYVJqYcjIDchsxkQ+DISasj/iQ8EGACHg0ro+IgUEaT5kEziUGlaKfRrzzlIXCY5hFTWoDu9PIuaFgoCRX3vEYsdd84flDJk+t8dIXlpyx21x+8id5XY1IIjB8uOXGbMQXpz0n//if8Oh4i3v/4gW6i/8GH7vUsyPv861XDlnfEaxPNhmVHUXdoOucOZbJ4vsOVpB+f3RAkgUhlatCSI67SwIYTSIzGXpvSfK7PiwNDKoiozBXZQDvIyFF+rZFJIsSKQtIMQgBrbe0S0cVBYP6LDJs0fUVXrW44IkRJIYkLuThblwS4pNQn2TygW3+4a9/jb/8197JO/7uv+TXXn+eP7P9dSbD/4ZhPSLR0RRj6nJC5z1DFSkLgVGRpWvZaPL9bSgHzPfu0M0WFMWApBzGlFR1gzILeusBTV1lPnRfDGhMnfGH3hOSyMOxN8wRK1mjjB5FQhiN0ORMrCkzi0EkokgUhcRGj6lGRF3QohkYxajOdmlRCYo4RyWBmgxwZwc8+I7I1uRR9tXf5x3NR9gyT6NmXwcXqE/9EMKcxHae0fg8svuXlGIDtfk0blZhwwsUaz31xhXC7CbT6RxkYjAcIOaBuoxsnT6PXcw5sIa6gGSnVM6zsBKqEm/7TFSMaVX5FaiipFElILN+5C1bdEVCB0cRBTpJZBRIJEYWVHWJURn4MBMJVEUKGfL9wM4mpzcnLFMiyQVBBUQxQhYaIRxGb6JVjVRPk/wCkb7Cf/lPf5Of/NmP0OldfuY/fB8nz/w1hpevEORN7qYtuupBdq7f4vc++UnGT36Un9re5lO/e4fl9UjPlPaJEQ/sDDi8f8R4qLDTKUf7RxwetnR9y3hYMqgEh12L9GsZSag0oe3pvaMzJoNrJNRGYZT410PPQhCiR2vF0ma4jQ+W1EeiT+iqIHmHwKPlqgkXwDpLdAsYjghdx7zzVNU6jgFrm4IzZ8fMbr3CQb+gfGDEA7Mb6P2e2+kU3fgqB8P38kDnGA8VRsD7K4USgm8dCk5efJx39Qn11dcZ3PwOo3CDm+0hr734ImbrCspE1spIRaAYTAiLKbUQ9BakzpYMGfpMR3MJUsya7qJABIHRgroa0C6X3/MYxArmowgiQ8AlWVsfgieKSBc1sXfoMpP9U4i5gVRKXNSrH6DLmiQdSEViKpaEG47d5SHi+CLX33OZ9vcLJlf/a3arv8G953e5u7PBA9vnwQ+4OlsgDh0sz3Pr2g0+/O4f58d/9ALuFYn/wYd41/sWfOHOEe29Peaiz8aRBKPBgFIabHtIjAWNTFkkKRRmUCC8RUoNPuVjv/M5o5nysT7ndfNO1xhAl2iRULLEuZ6YTMYTKEUfFLXXRNngbSR6hQ6WxJzgFlQ12GCJVLnNmVK+8063SPFOrmCLhxhsPs7pdz9IP3uOD73vIs/Pr/HA2Yf4bzd2eFS+HRMsujpB745JoSUcL+jafTo1R3QDoitQzQ6Fd0gtSM4zKBTe7aLFNroeIUXKf78YKY3JUgBpEMIjSoW1PVImhDKoUmbu9OoTvCO6HklEm8ydBQki0LcdCEEfSorUYypDsJEuCJZJZpKddCQLXghqnUiTCfv3brP90EUevjLi6PAm59eO2DI/Sx8als4zLBpKo1BFQ1IKXe+DMVgWRP3nKMQ283hE/W1DrE4CdyjFOoolQWZ4Er5jPKyYuR6iQgePj4LoHYVRzHyRd7Qhkbwn+ByZlVKjpKY0GfbULjv+NJ8/nSNtOc8LeVGRrGfhXIZ5l9mwMJ8tmXZLltUGp8YFhdQEdUBd5WZLcMeYMmGqIUXZUKpcgdWiQMkhcI7Ew8xfKtlpvkOzUfFX/qtfwT9+jv3BmE//5m+x8dAZDqY9V1/9BmJ0Ev+Hu5RnL/P7n3+Gg/kDHPzJEZevjFhc0rz29XvMlwtmRU+aX2PeW5ZOUunEaFjQR2hdpE6KOia8a0m+zZXRlJAhIGK2D/cp0b9hCRASZSqCa0lGURZZsGgkWLkqCIi8qMQUc2ZV5N2iMBHpAkdHh0SXkXr+2CIKjdkcEDbOYoTgtVdfRvTPs33xbYjyFHUZaS5eZKjPUQ/32Ko2ccBd4G2F4MrQEu0tXny9oDu6iucOe2mTY1ki2/sMd1+nrgvixg62i/QHM6Ra8WFdQhPR0uc4XQKDxsc8HFkue5L3qzZfpNT6zddPjmQqrM98CVh9IZ0FIRHoTJWyjt5FCjOGlFbWgYB1LVFpSDpzbSMUyTE/vEux9SRXd2+yv77NwctzjLvB80cC8eI32fqhHcqdhmu2plgq0sYpRpfex63POc6d7/mS2af4zE1++gceoZsINjvN26Xkm/evIVUiVQNMJakGkEKLCUNsWWFdizCbOBeQSaJjxnYqaXKCJcQVLzXv7LRZZbdJdF1OAYhCgZaYBEkUOA9lVVE7iY8lQke61pK8ICbBoGhIlJTC05QlSo4xg3fS3d2n6/eI6YiU5qSVrcSIZ3j89Af5t/9izYWnNvnqS/8b1576WV44rnly5yLy/j7CGJbHuRkaVeAgSe7HgippHqwH+MVVtNmBZCgL6JyiLgyD2qCEwEjBQCUmRiBNTVNXRGDhbYZ4x0AhNUJkwP0ivtFRzLxqH3OpRqBIMdL3FiEl894xmgyw3RHjtR2UlmjrccIgTI0IHpkCSiSSaBFRMZsGeimZLxTWv0QwJWrxMqP6x7DqebTwFHqCkhOEHANzdDnLMlj1EEmf4mr3DGvNE8jTrxD3LnK4eJHm1INEJLPFEhkj2guCBCcDXViiTGBm8/8/6UTRFLRtoioU3jrUKioGMscBV0YR795CMeV8esSwqbFOE12g6xb03lEOalzwHB4c0iMZNg3KO9r+kNbvUY8qglGY1CKlp5QNRkH23WbIROYblKT0CGn0MD/+I+/n5Ibhmbd/kG985h9z46UDpIu89tmrlKkghHVe/7plQ7ydmR3w6pdr3v+RddorLRuX1yntPneuHtG6IzyHTOoObxS6Kim1yvp0H/FeEJeWXji8b2m9w0tN4S3SB9CSHk2fPF2X32BCCIzRVLqhLEVuqymJEQohPcRA17sV5SjzQ10MCB9o6prou7ygJY9oHT5WjNbGDAYj4sF9juyCQbnG8a0FVxcvcOH8wzxy9iQCOFuCdfsYu81BodiWkibs8YBJzMdjTvl9Xp/eYd8J3OZjFEWgu/EF5t0cb6fU9Rp6lJjevYcs5cp2YXL+0AhizMbh4aDBWoGRmQEbIhQClEh5pV19hBAZd+ccMcW8WybD5EWKSGmItsd2LSEKWg7RxZDYB3SA+bJFWUVR1vTek/ySYTGio2VP9dwpNK/d/SrN1rtYbGxz59IvIRcncPEEM3OCo04xMoKNsuH+qxvMmhc4NTjLS7eOCM2YnbngkXHk3nLG8vgIrQNRtBQyZ5PrypCcoggDoizo3QIjBpQDidYSESCJQEgBmXJjKd/HZqCRUt+9XgjeoYzLDAlvkSJzGBLkEoIDHxRR5eeSXHbxKTHAB0FtBLoqkP0G5+uCxfEZ9sMCxztx4Sbefx0p9kju0+zev8LN3SFm+Gc5v3mWZ49fYyM0CJ7AHXloAvOiYVhE5l6yUCNOKI0xE2pVcdgdUqoligojEl2wVGZAU2VMY/KWIlqGIiNcSwVRSIJRjI3EGokRms4nFrbFtfOcR4eVDVi8aY2OaZXlDQkhFKSAjp6CsIrJZZFlWeZdo0vQJ49SHcsWUIm5lKh7B0zv3mKmH8WMNzCTO5TVFkKOkHIHxBowBCwiaZTcoDFnkCLh7We5PXyYyydn+L1XsXLIoe+w0WA9yChJaKzvEVIRUkEKR/SpQFUlQlpM6AkqDwYlHp/ewEQqYszZZCCLWt+qRTfEjPtrXbbaBp9dWSlFrM07G6MqhmXCL+5w595rDCY1hV+gO4VUDi+mBFexXCZcPKbWniQlfSoRcYk7/jp3Dj/Elx94juWXHL999VnirQPW7hRsXbrCd/YO2G7Ocml8jsU3biPLCww7zWB0ifJwhhxPubkvOLGcce2VV1kbKcS6JxUGZRRKaFJILPqOqlHoKNHR4eKSvp/TizJnj0PMLwS1CnOH71Y+BQmVAsZolM6aabmaWOqiJLgeqQPBZn9STORFNzpU0PmfUQIXHdpauoFgu65oqgmK+4ixgbiGe/1V2uVdtrbGPBHOoc0ak1rT+k3Ci8/S7zU8dGZC0ayjigZ9nHgweD6/P+buXcNw5xwb5yK3dr9B31e4cJ9Zayndkni0iwdEUVINxiQRUD6r3k2lKFVWpJdG4EO2xlZlkVMO3wO8CSHhXc6jphgzsFxqkpQIGUjCoExgsXTEAG03o5wYsjEok8xsB6HvcGGJC5ayHFKuN1xdHHMwXic99218nTh46u2E5R7t2kWm0wVpv0duaGLfMbs+Z9pqTl8ecPvlAWthxu0nT/Gpq3/IcnyJzh1z4ztfYTwaMFAdKAe6RJkhWg2InUQJTRQFSWYjiSQRdYl3S0LwmBXUh5hrvEbrfw1uUhYKKTxEhe9blK4QMiCFJomMRdRaYIJA1zVqoNFFZJE6pDToIBBVRVOMODM2HG0/SkyK3vwklyeeZP9P/uT+HzOsF5w73fPJheTfR3Lq/Pdzd3+fy+sDSD1tnVAyUjcGLeeI3jOOkbMmIs0IbyOH9/cYXppk+4sqszBTVIiVMzD0c0K/QIkMFRc4tDCUSjAqJW004AMhBrSwVDpjOiEXupWQmTeSclOzMDXeWQotkCGzGFy7INqsAVMqEnqHT4qjGHCxY9J0FM4hZWChztDNDpDtNtvNGlq9F0GFUg/mpqiYIFZmbdIkTz3FGCNrrJ0z9pHPHP5zzo2usD95jrZ+iqMjRZEEhQogM3DexJ6EJpkx7XyKTwZMoFY1brmkkJreLpDBI7xckeXyiTGLQMSbd9tvyaKrdZF/qDE/YFUYjMqGCO9DhmNjaY9voLWnP77D6a0L1L6lPVqg6oAtPO3SgJsT7V2GZSDVJ3mpbXn5lWcI7TO8cPsd/NMbX2a2G/mR/S9QPPjLrG+t8c0vfo3BmfMM5BaL11+javaYXut4YP/dzBef5GufUmw8dpJXn3+JCw+tcf/2DXaevEA5rFm0BzCNNOUYWRQgJHVV0S2WDMpAaz1ORQpV4vpIjB5RSHRVYooS0XffvdNNuWUWfcDLckXXFxAtKZW5v11lQWF8w0hgA4tlx7ztUaJD+I7oK5RWGY3pOoQs6ArQpmGuFqxNWkrbYe8fkk4dMrxyGb9/DX/nGF7+PCGBe+ghyrPnMNtPIrqOKhpOVZdpFoZyf8KT5yPmxGnuzgK2q8BA8gF8h4+ayXCI0JLkcyU1SQ3B0LmQdSnGEKKjNAalDD5EvLNvwk2c9/TW4l02oroUSd4jVNbDew8KhbWQosvCQA9VkYeQkCvTwVli19M5xX675OTOWe5Mj2jLS2xuPsrdF2+jPrxFKm4z2imYx0ARRujY0+8f4I8CZx7dZtQ23POJJ87v84fCMjO/y5e7n+BMMcEXuwy3L1OlIUk55NCgy4rkK2LI3FalBkginctHXKIgRohCZZqafsOSkhMabxRmhIBBXay0PA68R9LnKrga5BOEiBiR0Cv2cFlkhaifLTCqxqiC9Y0NRsMNhlKwNn+Uc/IBFhuP8dGLFzlRnsO9+FscTD3v+LGfpvt+le+LGbPhPU21kfU+G0ClGMdM7DIhUoSAFQUuFdTG0bk5faiplMyAl6IjpTnLZU6v+LCy48p8dSJ8tmyIYLMCqdJ0C4vEUmgYjwao1QlICxAxM5mFkChEfl5R5kU8QoiJo9mcYQFBa3QKuNbhU8AnRx88hQzoZGk13OtKUu+p7TYf+8BFivUSWa6DqIHFakPkVyDAGsEmKXWrjUGgkR+g2ft1QvVreG5z+9WCzWaTpo6EuCB4l2c6TtO3Ha1LtDRIWRH8FMWYPvaQJMl5RAyItEJJpmxHEYQVv/ktXHQReUodkaQUUDK3a3yX4cq+X2AayfGeZbI14sS4ZqQd/eyQ495yQkikGMNySSoXEB3oIcc+8YXbr/F/f/kLtOOPcOYdmlOf+ks89vR9ftH+Mp/88jHPP/ctjl5+nfesH+OPDnjmm9/kfnXE4Fhy/9YnuP/Fv8K0+g/40Ed+lBc/99v0ozNsr42phoLZ/D529whpBc3ZhmpcM++WxN7h7JTkHW2fd+paCZLS+ODzkTsKXOtxbUff29WaK4hotEjgc4QGnye5fW8xRd7ZZJh3poupkHfLznmiTigrWF/bIrkj5HzG8shQbfWUxzc5urNgfOphzp2/RHHjdRa3XmZvfUko7zJ/7mWe/+yzrF/cYL+sGd6qqS7/AfLCzyA3LrDzyBE/OVhQFmPudRPete1x9y/SiRl71jNsYM1IDqSm1AWbo5o2BrzzJJGj/mIFMM/80HwETiEjHPMAafVlIJO5FsuWGAXaVIgIgkBZDDLaMCRCn00LSsOwHjJNRf7eSMW0s8QUqRFEL1gsexZEqqMF9+Z3se5R9IkZC7/D7A++xOip97Flb3Dz6ALDuia9fhN30LF5eZtTr97kmZevsvbwZeRIkL62y8ZPncIPFafLIac/9DRF0XB0tMD5jmEFOiaWfQINruvyIisjve/ziyM5lM5Hz6hSNouEbKmIq6uV/DQEpS4IrsvZZ6XQwqJ0QZ8sMimMiAwKSbSS2WyJs0sQglp6WjtnfXKBx89vsLWxzs3dnkM54KFHLqMeO8XpM4bzG+/hfZfP8ruf/Q63N3v+i80zKBJ9GvPq7vPsrAWK4gSDsEdIY7wYoJKiFVN2Y2S2LJj3M84Xgnp8gfnCUhYN1gXaPmBDoreeSSOQRUnXVyydx3tLhc3kL5O5wVJm9KZ1EmK+836DpxuDw7YLQgzZNKFUjnwlR4xZ6yNTYtFHBuVgRbrr6EO2zCSViEnQdSCco9pe5zuv3eT01iWuv/av+NiPPI4cXsgnqdDlnaUERC4vpeRWrJQhJBiUayT3Nj5uHid19xHih/nS5zXnPqJZ33YcLca4LkHhsVYym7fMZxZZ19Dn05hrLdZrpE0galJqKbTKNmwiUpkVsCeR+rfQBmyG9cp6GwltRyTzRgUaSUCKDDVGZZfUZDKh7zyq6Bk1E4pmRKFbZL/E2wWyUvS64XjvGe5ff4U/98MlX+vv8dc3TvP8j95j+A9/lf/xG99Hf/8PaK8k3rY5ZMte5qv7+7x+7QWUeZC2+gj/8z/6z0iioFIfZPjygkl6ho3xXWx3gtu3HkVNDyiSYGt9k2jhzq2b7N1/neM1wfq4ZF5s0tpI3wuqgaVru5w57XsWtiMpgZSepN4Ad+dUiCDhe0tIUOiAtR7X94Q+EVVBIQMyRGSQVLKmmNQ0dYk9voeQHVsVyMEEv9uxd/0mum44++Alti/P+dZLlhcWJQ++64epl4Krv//PuP7KSxzuaZ699Rznnp3jLpzn4vAF7p76KMP/5X/Ab57Ev+dh/PqEx9++xcMxILXE3r+PnU6hnzHdN4xSZLroGTSGrrc4m3m7ppRUtaFQAm9bOt9hREmhDLrQVFWdZYq+e/MI5UPOo8aQpYzZBKAQ2uTpt3fMFi1GGxwaS8QvE3KsCYuWaBXJ9SyDI6WSsS6ZL+dcf+06k82HmU09d2+8xAMffCcv/sEd1t4Nt557gO5sxeL66yhdMnjwHHH3gPsHgsm7n2bH3OLTL1jKsy9xy3wcNdzhcwd7XNnZ4UJ/l/GkYkMM8i5q0eHDIjOAAwyGJc4JlG+RYhWRC4DIxK6YRN69JuhdoPffbR+JlDJxSkRMpQkOkvf5ZCBKCAItBE2d1U0qWpJXCNGzSAkhOnTy3L95k9A3CHq2LsH3v1fyyGOCr78c+fq1IVceOsXPHDzLhNMk4EbX8c7LbyeKCGmXYnyZYwoaJMYLzqgl0rV855ahW7vO7bsS843P88TP/hI2KkLoCF4gZUldCaI7wAeH7TzLucOGHhc7BmUDqvn/WHuzGN2y8zzvWePe+x9rOHXmPqfngWw22RxanCSapKRYkBxLciIqiRJLAQInkBMPSoIgkGH4RkEcy06gOHESR3AEWYaAyDRljZFlzW4O3SS72c2e5zNXnar6pz2sMReruknf8aJ/oC7PAeqvvYb9fe/3PAzB4ZzHCEXSNSH2Rd1zUsN13uN8cexlF9CqQ2iopMAnQ1OXZ2NaZWQt0dqCjyziGk+NQkCMrFEMZPRRi+oC1Vzw8CO3iM0NOi6hpUKEAeQYcjF/iJPrQBESlNf93GdYRqT/i+TFaW6ta/qt2/RaMwwt66GgVIVyZCFo4wiMxujA7f0lI6MZUiZFMEISTIUilIa5KeDy4B05BNo+4dy7mF5IORG6WG6AlMiUPLmWBxFxMhL8Gu8zUTVsFmu2JlPGpyoqU7M6vIrIK8hH6NmcZrRF517Bbd7iL233jM0n+Qvha/zP/9XP8s1/vc+bOiPveYUf+9E539h8gheebNhsPUaYPUv94vN0b0TEYEjyLDLB++0ev/b0F7HbZ9kcbXO4XnF5vscQMymtWHeHbK7fJOc1VvXUzJmMGkb1hC57YojkBEZrFAUzVzUGYQxKVVR1mUjLORN9ZFACLYpluIC5c9GQ9KV7r1VAKYFQpnBVnWOzHNAuEJzjys3bXNyeslhFhj7y0pe+wgvP7ZL2xmxZw0Pdkmv/4muEBz7K9/4X/yN/8A/+Dr//z77AwRnBIZLFy28x/fRZnv9f/wk/9rHzvPjyLa693rH/huPJ115nqBIPnz7HN4Ztdi68h8Q1ct7m6BhmzQ6TiaZfrZCjXZpRU1IbwqBtg0iOGAdkTuQUMUriuw60ReRvPS6Z0ljTSpXGkygQnJSKHUJSLLwqS7JuGLqADIJ+FVgtevZXS3zqEVi0baiN4XB9jX44QyNvs9NssQz38urTV5H3v48clnDvNql7CrG+xM64Qb1+jeXritFDI3ZuL3jz2X+EuvBXOPvYMxx86V4+91OWJ7cucF8VGQ8SGyIqQql5eKLzdH1gLDNJlE1VN6NyYNoGYocWAymfmIYVeB/p+w6f3DvfwxAKj7cyFcZYNu2C9bpj8AFFQMnmhNmQMRWolIjKMt3bYtgfWLf73LwyxmOJmzGj4NGbm5ybn2E0mnBzP3Lt1SMevLTk7k98DyoHovO8dutNslhwTs9JZ+9m3QUmVYvVNS5tOPKWNJqxNzniied6PvWBS0we+k+RdcW4EfRdZjYt5l/nHX7jC0c5Z2xOWJWAYvNeLwLDsML3J6qteowyBhHit6rb+UTXpCRaK6yUmMaSQ8QkCGEoNW081cgQe0e/OaauGqIyyCioUiCmGl1fQNBxxiTkesUjj/wEt/Qz7KdT3NNrRgSkdMVabUTx3VEUXSRRbsAI8tYpQqpoNwOncuDm8jkev+a4f1nh/IpV0IhhirCBqC3RV0zzMeNR0TPt7kxxiwGrR8TjBZUdEXxX8vwh4wePDxkXAiF/Z/WF72jTvb1/wLQZYWpV/EKhI/hElIpARItMdo6xGaPEDI8kGgiV5urRNRrpqNMhblIydbo/RKxbNsMWt9x55s/+CX/481/g2q3E2fdp6s9t87OPPcBRdxdf+G/fInGKv/a+Q8JbR/zCsefp/uuI+BLVzodhcS9X0n/EA6d+mvHp/5CvvfYHnDr1XcxFxauLDa2NmKnlVDVhPj1FMxqQpsLWIw56SexKrGtaS3xW9MseKQLCBZCRIUDflyiIyCAjxODQWmKkRFBgNsUSAdboMowsJC6VOX1FoY5FSgPr4qldfJu5fO8p9m92iOEsB3bJTtzw5HO3sOfPcOHcw3z1+Q5u/z/cd6Hinz9acetLPX8UE184r/jxX77K5//SlKd++wU+f5T5av8yd6gabba4nRq+fPM6h9Fz5DWKN5nXM9L8LKKuGLoKg8N3K1b9mrrZIuaBru8RSqCkRugGTqJjJ/Bk1LeNOfoUMZVBpLIZWVs2Xx962rbDUoHRbLqAi8W6Sh1p2x6pA0k2hKQw1pKUYdVFhuoeZlun2XrAcPDCBZj/S0bVBcL7vsm11y6zJxaYV98Lp2uG63/G4FvMBx9jce0llocf4r13/ddU//GIL/69/42P/NKH2RonfmhvzId9x1M3M0duILeO2gXS4LgR+pKzrSYELzCVQW4Crd+AFvTLDc5tGDU1xmhcTHRDJmWNrkZvnz74oWUIAmkMNicqUxMMJCI52/IKCqQoiNS4qJnZCmMnHBxdZ1Qp5MSwE87wyv5bNHWNi563Fp7qKODWx4i9q5z95BWadIXUP8z6D17grk//AJfV1/H5Lr60eY3anuM+2aFyAGVpKsvx8W26w6/x8fgV/vAf7/Ej/91/hrUVMQ8MKVBrT6rGyNyyiAa3PMISmU0qut7jo6DvW2JUuEHgek/IgbFS9F1P3w9FNwS4JPBZ0yhDrTWVEqVhGj2j0YhIpEsdo9GUYRgYNTWxjyh/iA4Zl6a4kLC5o8kNUZ7mjvdMwWrSHe9lNd3hjaS5oC11ahBeI08YvdGDjJnoEnqiitHCweZYsNqb8Xd++yv8uJpw/v5HuPvCipkP3FhdYRNXhE1LXGwY/D6VmPPm8TEVFrE4xqcR3ie6tqMdIn1ypH6DdwVulHJRElVG0vl3cQx41NTUIw3C42NHzIG6qrHGkINnVI2wCFIy2NoUF1nd07URjWIy2yOpCVu1IIuOo9tHNLZmOj3Pb37p8/zIw0dcI/PX/q9T/IZ9P//TYz/EC8+9wn//V7/A8gd+nnPD/0u1PWXVfIjFQ09Q9Y7d+y4x3JowVbf4jNliEB/niRf/FnL8vcjDb/DC6gZpvMU9Fy4xH0NTRZSOHC8fVJ+oAAAgAElEQVQGkh14a+HQ9YxxLZk3seiqo0RGh6DHpcwwaISx37IlkAkxFAydD8QscWFTcr1ClhtzXdPGhBIZkQVIhRlVpDjQmBG+W4MUyF3LrWNDmO1yZw5cf6vhWm8ZTweevXqbeBT4wJ3wgu/YP/oUo4M/5mPz61w5gr/fRj6xZfhnXx744kJzSU/ZnUrYuRPvA+vbb9GpO6hPf5Jh8yLSdWxPz1JpCcKwPfJsb53l2tKxbi3e9VTWILIgOE81HZ9Mm8HQDTilqBUoYXm7pmuqArspmMOKPiqy6wjO0/rEQMa7knBpFAzdAoZdNt2KGEyRe2YJPpN6zxAFYVZz0L1K6C5z6/rvcvzKy1z8xMu85+k/ZvPox3n9pUcRl2/QL77JJAZOx/tYP7Vkf6dFPPoUT09/hfh/fj/jz/4Mn5s+xWe3HqBCsp8k6DEToI+KxXrNsEjIMGF7LIjRsDORrJYLOgfKNgw+FHSfqeh8ZjW0RDIyJVJ0rLvNO+vDKk2WkN1APxTM5RA8RlW4WBxoKWt8Uggh0bpCNnOOW0tUU1AN5DVxtuCGbAtmsZnx5afWPPE0bNSSz37ySe6++A2o/xdkPaH+8/dyno6ng+OO5RvcKyZM9ZIX3Ve4bD9Eoy+ycDe45a7wNdnwwo1P8z478MxB5FJ1hKkUU23xQSNSxHtHIya0cUPXL/Ap0jmBXwUG11GjEVHj+p4QIkN0tG0kB3+SXwarJY3VWG1R2gCBOHRIAe2wRCCpKlMSHrHFiQZbayrVcNwLhs5RVVPGdYUfOqAiRc0iwB+/kvhyuMFfft9pvuFWPDxZMU0TQtQoY6hsIglIRrNaJr55Q/DwnuDpM/DLVzOz+9/P2TMDTz3xZRp5H6vVNdxCINuK9aoFEzk1m3B4uM90UiMXETPb5vjwNma0w2qzwSUFHsSQ3nY0FcNGykiRivft3dp0tcmEsKF3LSIntJBAwHlfxkidorENijVHN/YxM40KY87MNnTZ4NKYGonxgcPbN8lxw87limX/BnHxPNcPZ/zsLzZs3/MYd/ExZPvH/N2//ntc/LGfZOur/5DwWMvLYsb3z+/lpx95lH/6/A2+Z5r4/Ot/xM/85Pfzt3/hSc4+/FukdsZdk8TTV5fc9+CHOH3+DPfsWFJ3ldV6hR+mqGpK1JG51sUjdqIW8UcL6qop0rlQ4UQCa6jqcriUXVeQsylJFWGQIdCYCqEKYSgkRaPLAvS9J8bMqK7ZnkyQecJ6pRjdcZYqr3j9uuMU4EVktVnxXZcq/uTFV3n4wXtY7VV89eVrXH9+By3GPHX7C3xYL/nVY/jwVPFKgDuDR5uGJu7yeHeLVO3yFy98hMXmmOdv3KYJ28zDbZraI81FtNxhvV5wetuwf7BE6YbYB0ZaYEdjQha4vkdpgSQT+hbvPcYCiKJlIX9LzaJNEQlGUeJjrsd3LSGDsXU5hHJAKmjbQyoNt47fYhgGsFNcLq+G2WVs9qjRRa7eOmI2n3MhwOOHr3Lp+/46zatf5Mkf+qv0T3yF1ZUnEa7G9J5gTiFPee748D7ysQ+y+Pl/gd/92zz4g7dQ9yd++bV/hw99QHAYPS9dewmZtkoNLhYKVmDANgZpNFUVefWtfWbjGoxlb3vEcnnIphOolE50TRmI5TXSFxLZyUNByA5F4TVbWdRQq/XAcbcGYVHCEFxmiAZpJ1itqbWgx9Fs7bC7O0NvnWa99KTpFjDQzDLn754ymkOcTsjiUbaWmYmtCMmzSGte4Xk+Yj/JS/oFLk5O89zNX+fqzvs4K05jwsCobpjOzlMdRu46d5OnD57h//u5p/mbf+NHiUPLPK0wozsQxnDt1gqPIyZByIbNMLBer/FtjxRQjcewWUMMhNjRL9vy6iYV7/A4YiCnSE6RoU8McaBWAllXZKXAJXRKdCgUmtA6orZ4UZPnc/RYslm2rLrA6XoLhCIc3MSowJ98/g1+8Gc+S/fV3+Xjj3yYyTc2iJlDjLcIQwadMDs1hynytf2eT79vyuEB/ONbmfQbiZef+Qo3/sYW34wjnv9XL3Kme4qtGuLoLMc5o9LAth2zEofM1p5wcmtNKOiWOJcZXItiwMhSZs2UvK4R4IeSwnnXNt3jwxWjiS7xGgmehOs7QnCkFGl0RXYr5HTCerlgp54TwjFuMmcdGvLRmslYcPvoFj54ZrvnGEymia/xwx8+Q3hwBzG7j7G+g8PHf4n/8h/d5P5P/wRfe/4FDtUtHuh/iAdm38vZB19CPPMaet5y74ev89H5WX6xPc3Ow567w+/xsc/8FT7/e1/gQx/7Ed73wEOYuID2FqppmO/tEJuG1bDGtLdR9IBipkfktmMkBEJ4qMakymNywkdoV55uU77MlDPOB8aNoqlqhFD0mwOSKKF3MfQM3YAIrhDKRBHYHQ0tIzWibQMhOy7dscvles2VzTFJNIThNm9dXTPcDPgz56h0S5WucRjW7MxmfOSy4Vd+q+WhS5Y3Dmesw5KtHcWfLmDBPp+5Y4cf+Mnv4/e/eps/+PohZutj2Bk4/yxnzz/Ipg9Mzk/QwwzZCMYx0vuMi45mrGlGhm4IZFFEmjEOSCVP4k6ClCQpZTaufWfTDZgTW0QmxYjIkaoy4CIIQ5QSZSPSZ/SogsFhZCKYGb7tyuuk88WPJjTr/WOMahkGRXa7XLpzh4MrX+B4djfhqefYPXcf1c1fZ/9Kz2p4neqeEfHR7+Lm9nuY/k7Pj/3EZ/gnf+/neNH/AdXov+Hs/ffwxfgBvr4OnLp2yHJ1G+vHXKzH7I7H5FrShEjdRVrnmVqJSQklBatlh8YwpJ7NuiWHkmRQMkFOKCX/LfZCHBwuDCUi1dQITGkKoYjDgJSOHDUKgaalW/YsugVZ77C3cxalW87s9LyxWbF9KiD3LlJvC+xWxzOvvMXXn/ht7rrwPJ/79z+BzwElLCM55iFxN1123DG5m1ePnuGeU9/PB2zNqr+GkFMqI9ibJL5rr+a1zZgPfOb7OFZbXLt1g1OzPXxMvHr1FjEP9KsNUixwztEvlyyPl6zbASsi80nDcrUheFfM1yHjoiC2PdNJ805N15oGpSpCiqTgiW5DtoqER4/G1PUUAbiu+J/n1uP6ZXnjMWMkUFUBi2dsD9i5dBc3v/4senubRw383H/+9/mxv/UIB//6eb57mpDrilflPvNTM+5udulfkRw3ivddrvkHv3nIx/amfNhqXugd53/4Dv73X32OnY/tsZzc4vL8YWzqaZcLagyxOsftfo02FYhxiYvGlo3zpNyXTTb0CFnSHiKXVI8UkkpJTFMR47tYXsAolK7QdVMwgGFAKImyNRqPYMA0migkk1FNthabVhy1gZxugxpxc/8qk0mimXiM3CCp0M2IrTN3oq/dYFCCf/P457EvR77/J/4Dnnr1SY6fepn/5KFzvPnofbx47i4uVw+xs9Pynve8wH0f3ePX1ueY7u3yUz/147z0S8/jX/gtPvGhRzj3wXs5vad56TXPhYsVW7MpGyqWfSD0S0xyaJtpGkNN6TrLCrwd0bpAVgojFFoWOIdUJ4ppITDa4IaIEAFTJaQxpBSpJTBuiCHgUz4RGxa4dQ6wCh1VM2Z1sOaFtkeJmquHno1rWby1jzU1zlU8/uxrKK3Qu38ON57wwp/9H+zGDduTbd5cz+iHAy6Q2I9j7q8SXxsM5r1/nl/41ed56c2rOKnQKcOxoBmdwfdLLuzukjEM6Zihzxy1a6yH6faY2lpS0iUgZjVVbdDa4FJA6LrwQmXGWIVO6p0FpqTGewnBE30ghYgSmuAlwbXUWzNisrhwDHJGux6QzQzRFUh8qnbQjSEMETeAlBu0nNJ2ipeefpJH73mQr7xxm4fee8S+Osuoh/WdFWk+onHfy91a0r7+Iu3WFT7zNz/Av/z685jPaNLiYdrXlwxmwp+sjnjPciDt7KJFYEfUjBOMZcQGQbfqWJZ8PDFHlt4h4sC00WxSwOpEp4sHMKeID/Gdg+jb0akpJqQUZCRSRobuJM8cE8GnojgPHUNuMWIKErIaEOoYWU2ZjkcoA2okWb5xA2V7bpqO69ef4eb122xPzvPY+x/lzlM7ZDxDtiQUMzknYwlK8NDuQ6Su43dv/RG743u5c1IzFRlvz7Ha2uLBCxOM6picnvDKiytur67imhk57HNjMWCNog4REQJDn1htPM53VI3ApQqyYogJl8tzrVRNVokQ8tuybLKU+JhJISKNKqZm5yEmTNakxiK7DUpXxaycNbUekUQk+2WhmKVMoyuqsObglcdReos3v3mTZf9efuS738+D95/mS396gz+8Cfu7A5+6rNjKji8eLrk3WybTEV9/VXB7e8Ti5oJ//uKcR/+y5eBmy3j2fr707Ovccdd7eGL9DPew4tJkzFzVqKRYryCJijYMVHFC73rc0OJ9S96cDAPJMjwjUkJJiTSSlAVG1hjV8p18vqNNt8ScFaHbMPQDQma0TpA9wbVgBclplAoIrTk6uEU922NKZtgE2vgmMRSfV+g6nI9k31DLnqG/xVubFR+eZjp/ijt+UPPEE3/Cc3/2Jt008Vo65GD6NUajR3g138vx5Cx55zJqteKzDy65Le9j9eYf8vHHPsmN5x7n3u/+KLc5YLlYcWbSsDtvGE0VeM9mvcGQmO7sMG4kxwtH7NYYIxkYM6BxKVNJqGrNkAI5iG+RtVKi27RopagaWyZiTnQd0iiS8qQkEdrQKIXRJ4u1HchGs3ADyWoWi33U9CJ2eonDg5vY2YLNpme+c45useLW0Qq5WnHX2HJ5u+ab14+p6hnn8mmekWDEkvvtmD/tVjRSM7z6POtDR5B3AmtSf4NodxDNObohIFXDzpmL3Lq2YTzeBjHCNAqZi4APpamlJATADbgcyHEgZkmtFfV4XLraUr/zXbSbFeOqJg4O7wogRAmLEMXu6oaIUBJpa1wI1NMJQ4SUA5WtyEqTlMELg9GSqB2LrgUs9XjNS6//Pvfv3Il76Tqf+wsrrlQPcyQ/xV2jKaemuzTbY54bP8LXzDFfnLzO937yPv7p1U+x/LV/iJn8BuH1Ealf8NT4e7goLBqBVImqsjTSlPHPCGmxJkdQ4ymb9piJCgxOoitLkBlb1eTYo0425hQTUhuMKUun7K0BoSukMUhtQQeyz0jlMJUBEtbGUuNPCa0EhYYkEDbjpOBgdcTR4SFBCdaLDdOtQ9pV5Hh/n+PlG3ztjQPuvDzhtq95uv4gnx03dFZzSsnSrJcVQ6V45MxHqZDkeEwfHTM55eJsQrKGcdxQV4adS/ewfuMVVNqwVJa6kcQgUKqnDyDJTEYVzkuU6AiuZ90Xo7cN4UR4Wn735WJJPNHU5JOx8SwlUkSEUiTvMDli8kC79KiUGenCLIlCoXRGWwi5wJDqUc18ukMlEmKxz9FxILqaN775Kyy+GfjqEx0H9ZQb7UXi+T2OPniRvWqPD/ptmrOCX1wElnHM5smO9W7i+gc6rv7ZQHzxmHs/vkO6vEfcskzqu4jdTWJtGVcNqj0mzcbIoNncPGS5WVKPJVkpwqYAburx6ITFUTLtKheFl5CKLDPy7TLku7HpBp+wshATtM0oFdDSkaMjq0wQGmsqfNvShoTPMB0purAm0rIZOqLxpC5hYiLljrw4ZOMGrq2OOfPABbbGW4T4IkfJ4I+OqM4K7v3UD7Mzus7Do2d42L/Oen2a1d6cj3/Xx9h7+Tf4nuMDPl//K7qoWOoVO+/5EH3q8ZtbqNgQ/YbDUSTMLVkPaL1Gj2E8GmFDj0gdlcnoaUOKii4njNbUShbttitDEMW/DFJKqqZBCFE2FTLRJ6zWCK3w7UmDzSVk8oyywMiyKIT0VFKhmgozPcWNlWPdJex8QlKn6MMriOFVRtMtGgxH60Ou+Mxus8Po0kWOr32TlK5i64qrocZvOhyCLnYcHN4ks8ukyQx9T5BbVOMLSHkDxR7JrRnnlq2mONBaPzCrR2hZ41KJWRpTURlDCooQuhNVuEJpShY3BJT81uNS5usFxlYo3eBP7LlSKvzJ5B5C0LuAlAIlLXFw5Aza1GU8WgSQij6UmJpSEd8uWbb7WLni1maErB7my493vPLir7NvLZ/56Z/kow/scfdM8+/qjj/cf5JfffH3OPfI/8Df/fc+ze98YIfH/83Pc3l6iQf3tthWOxwdrWEsMBkanWiArnVs/EAXIm23IkvNQMQmWeSdwiONQA1gDQRfwLrGWKyuqG3R9ZSAqCWgSb1DZlnklkIilTqBXAf6oSP7Ey6H0rT9kijWVJstohTEZoyXPXdcqOli5NTYsTaZFGfIumbv9Cmm5gLhled470N386WbVzmzt8NH6lMIqfi/n4386CWBWCWe9y/gnOasBKpjXnUGuXiNBy9/kKOjYxZdJETJ8aDIbUeVEjErRMoQA1JrbFWjFVSiWKCjW5TKrdaYnEscUwqS+Fb7SIiA0WUaTauydpIU1NaC95AyWRiGGKilKYdaXRGkxmeNUgZjDS4GXG7Q4zsRdp/dceT9d9zP8cE3+Oprz3Hp/IxmeJXX39jmqt1jzR671Z1s2dM8eLzmqef26E9tc+sY3O++iRnfw+q1Zxndd0C9SVx9XRG3t9iqaxZDAuUYJc06CKJrWXUDPnvC0UDKgsqak1HfptDfUhkYKRhYX7gZ71ii36VNt9GWFCNKK1JQiHxiQ9UWLaqy0wtJJGIbS689ynqOV55RVYrO0ntSUsi6JjnPwX5LJwbOnNri1KhiGHaJu2d4Y7HL5o0bTC+Pufnide7+2FnM8hXy7RuMJte5aA4Yb2WufH2H/ZcXnD57hcsPfA/9MGVwmjqvOTefMqTIqlsjG4HUmYzHNoq5VijvCH4gk6iaCqcyx8dHeFExmkxQRFLvIEa0AHVyu8snNd3KaEJMSPqTDcjgvSck8LEE6KXUZYovZ6wp7IK+9aS+JYnShFq2HVunt1mu4Mypi3SHNwkycVZGdipBHwT7qwXjpuPOO84Q3MC1q8fcvz3i+mA40zi61HAgtzBn7qdZ3cS7xO72HZw/e5n14dPUkwZTKdZth9YjhiCwpiZ6DxayqiBJwpBRVjEaT4jRMAwDPoPQZdSRKE5oYm9/Sk0rp4gUoui1o0DpckiLNOBTJFPMwD5ImkoTXUDZMjDQesEweFIICMoEn7Q1x/0DjMIR602Hmo5xV09z3I/Z33+eL/3Oszx69gy77z9LLQ33iTsYD+8nRMk9uzP+XP0gUXyOS5PL3FdpDo+LayxHSS0cXRqh0fiQCUSC9AQ8wjumE4vpCic4Jk5q1QGhJEZW5BggSLTS/9b6ykhcuyFkgdZlLFZbATETc8CFnuB7RC5lmRAdMXqSyLTtIbXJyK0JezszuqGlVoK58dTCs3NGMpnO2a13eOV4i/Z6pLv5HL3umD32Xr4kBz569iKPnEpEMn905Trb/ZJLO9tM1PN0i7eY68eQ8zu43a1YLW/jYs1GGWoraeZzcrtkNRjWbckhWy2oq4YwKNLQUWtHZWu8j2gFKQay75FS0jT1yYbDyYhmEbumlBC5TOspZckETMggDUJYfFLIGDFD+X61NRihkEMgBYceTUtzsq4YzzXqvjNMznnarciFj9xHdf5ezLwmm0D7pqLKM6b3NNwfGuZxxG++uU+64xzn+syVF7/CaOcst2/uY6RiaGvG8wnbWlI5z9BnvLH0ccD3jkEDKFRWmGTJKTIaWXqfyDEWzEOM5JjLPpgDwWdiehch5iJHyAptNFK8DecWSF3gFplMigGqBjuuGYWOJCRJFCVy6juMrGlGNZjIkMA3NZWuObszQXu4cZjo03kODlvuurTHomroZc2F8UXmekLftSj3Cv7qIc8+15NWp5nvnefOO89Tz6FrDVeu9dzdZCZblnbRo5QjR8lm7VAxYhEELem9Z4g99dSQTGbtIy56kIpaJggO4oAVAmkk+qRnkjOELBAJJIlucNRWkZMg+BNwsyiEsixKhjmFgew9IpfR4hRlseSGCk0kDB3Lg+s0TU3OhnXnkKZCj2ri8QKZPGGzxpmtgt2rpwhd0ag5Ou8zUVMQYzq/xpDYnW3T1ALX36JutqhtaYz1QwseNkIzHk+RwpFVJMaIAZQuuL4sQau6AH/CQKWLSl4qiD5965kQhUiREUCpb+mT5pLWGiElSQgEmhAhSSAkkjRIoU6A6bEc5ogSjq8VtZ0QU8S5msm8JzSaQe3ixhXT3W28HPPmsufFtSeKyDeHOWemj3J1f8XjlWQZEqq5mx0Mb97ccLjsCu7KS1oyR6ItFgwSgaKazyJB6jGyQVqJ6xxJBHL0ZFmcREKUsdcsIYnM4NzbOy4pJlIqAEYfA0rXaClAFEYFImNtuUlmWd4Qus6RhcTlSJKGNHQkY5F0iKwYjadMlMYYwda0YjTeog+aQzTDas18a8ooW0bGcrRpaXTmyVcOuHV8k5QDerniWNSofBE9r/HRstkM+Cy53nqkG+g2LeMTKHffrwgxokQZbU4RYhLEpMixZNltYxCxw1MYLMY2yOyR4m1zREnx5JjIOSBzRktFOmFtKCXpQmYkMqQCyxqyorIGLUsqSgmByhHhNoSQMMYjtgym2qLqAw+dG9Hcdy/V9oT5toGs2SfQB0kwhti1zC9YHtVnGbzCdi2X9gTryjPxjizGTDXsZEflKnKb8NHhouXg8JDoFzSVJK02NCIjs6KPEoauDDslygBIKqjPJAThhEH9nRJvvrPyQvQoURXqkLHECJlQmJqIchUXEqlAaIORAbKAXDY95z3jrQlUJSjtlUCNx9RWsHaCJiturRaMxju45SGT6R4Ew92X97hzvIPwFrpAv7rC5uoxbmjg9ANsn55jdzTVSFEZRTq2SOsgD2gBHo93a2Ky2BAQIeClpY+JIB1WZ/os8EmRyWiVCrwmDhAHlNEoqVBvkyyEAKlBRHIOaJUROZOiI/q+/DFyxCdBPOFVyCwK/CNGRpUiC01IA27ZYXVF7jqq1BdFjp1CNKyjIARPFxJCGkIIbFYtOXrG1RaLGLGVATUj+kxOK+Lao4ShGTVILfA5sjs/C3h87JFDS98rosnMRlXBNCpFDmXjQ0nIAT+U10spy0h3yoJEqWfKb3umckrkt98AUircBjIhZYI44RQoSfIZlygDJDGBtsQoUVoyqkHniDuZ7jO6JJDkWOOomU/mtNkTqsh8VJNne+yeqdl3kq8e9Igqs0iaeT1nsej4hlZAQKcK3bfsH3tWywEjK0ZaEKNj7QaMMYybCkSBhQtTbtnRDyTf4bxHn/zNkyiJZYEgC0EiFX+e99+2PhJKmZNSQz5xnOWio9caiUCiy+0oZaQ1uOCRymKtJWvF8WJFqCwpBka1xUjFeDrHNDXjRjOqFG7YkJNHjStk03C88CAa3gqOY+e5sVxgw4ZqPqFVktbvoQA2A35zRGUNnW9ZHnc0aDZdT+c8WmTarjuxZ2tEzgRfDuQkBAFZathSElxECI01mboZEfrN29Htk4vuCVs5lwM5AAR3ovTR5XIWPSl5ssgMuSKngIg9tq6RlUZSynNKBKYTjY8DZiShU4zHZ0kji1GOFDRDFIipRYVMu+zw/UA9m3F+0nD95hGidqAjI33MNJWR59rWTIf4TvQvqkTbb7i9XKKERyYLbY8Yj+m6iCOV2jS6HEpCopRC5qJeH3wug0LvJmWsXKMVOeXy4CVBzhKEJAuKosVAwXBlkk8kPZB8X+pVRhIt+NgTvScmA9KQjGCNQCTFcjDU8ynJzSHA1khwqd5lR2m6wUKqGPqWRnvuvec0zk+odWCoMkYktHHMxhmpS4Rn3DT4DFFkapkhOtr1mqB0qb8p2HRrohlB1qTsUboMgCRiuf0QEDlD+rZWtUgIEYjeU1eFNhVDoOs3JSKGJCYBsjywSihMXaNTsY7G4EFqhtSSpUYGx3wyIYeWLCL1aE7b9XR+TdQSEQ3kAZU9fQRTCZyQKLnBjCxh0+K7HiHrcrNKEa0a6vEORo+IQ0vKA+u2J4oZRqRyE1ICIQVGSVIM+ODIWZRXvQqUPlk4SpNTwA2ulAVOPj6EAn3JiXIKF0ROQBWXmCjPgo+BLAwxRFKOCFX+rVGS2gpELPBrA+A2mBxomnEpXVmLSAO9XbI1mxDHie15RQiJ60ct47GgkgE7eKZJojO0bYuKEtt1nDIVXXJ0nWDSQJUGpPegBFJYRPZIEai0IBiNdz2hb0uDTQisqXApgszkEydaJhED70xhAQiRUcoUepgxuJDIIWK1ojEWciqHcwjE4DGjmt57pLYomRH0rDctVk4hZFQVcOuWWtdIIWmJxCTpQyAGhZoJurBh/3jJOmXO7+7Sdh2TGm7cGmi2G+bjhqGPHCyW7B8u0LYiy0xOa1KX6ZMmDAPH6w2NsgxD6dGgJUYUeE2mGEBQCg2EVHCM2pTftakrVkPP27tuTBBDSXdAuemH5FEiljefGKkbjUgeUoeUlhgyQxjwLqJDJgRDrROjJqFVprIWmzoQkaglzgiaKmFOaHXyhPJG72g3A7UyGJdJ6wW7ZoXYhbduLpltT3C9YKduGdOgPPTRk20mysh6fYyLnknVMKwHGhRCWlrXYqwEZUhZYqQAQrlwSEXKGZ8FRtd49y7mdMt/HJFJ4GMghohSxRwgpChfagRlNSqV7qfvW4w2ZJVQxrL2iVoKRLK4JMhGU5mGZtQQBsdotkUQY4TynJ8YVCM4PT1NYw2VvsAwBOIWVKOaRk3YP+q5ffOYnfEOV/evMasS1g8EOUfJjDYZoy1aaqwQ9DGToiBlhdCCdujLTL2F4DqMyliTEBpEEqXTnAMppALROFlyUPCFiEAgI4iEGBliQRsqo1G6IgtBJhMFKKnIWtK7WG5KGag0yvWE1IPWxFzTdz3BjlDGYCuNY0CmgtpDarbHDW2uCDIjhUegkJVBo8hJE7ImSoGSCi1FsfvKDNnQx8h0nFFWgNIYK4n+BGCjEnzkPHUAACAASURBVCF4fABtDKqyCKnRImGaMcNmQUwgvu2qm3ImpFSwl6LQ55AChEIJiVIS78tGS+5IIRFjwItMzBkRNWRJwmN1wuhMDBErI0ZsGO1MiFkzwrOsVkjh2ZrX7Mw9VWqRS4/rE5mBRnh26ynzuuG1vmPpfVmctWRsBW55jIia2oKVGSNCMYUEh6KUfqKSxXosDVJEEqC0RaeEDyfB/5ggnXBj39aVCjC2NM3qyQQhErGNICNSCawt30lOmSTBK0l1YmrIQjL4DhEMJg3INEVKxdBuWGRJlC1NEhivsVEjqxGi6pnUijC0TKxnJgYqNuRhjQot6+WaA9Nh2QNV04bI9WVHSjfpQ8deM8bYCWJ5QFwPpRehNHHoCX1H1BYjNYIEonCzpRC4lFFKlB+RUNJglEAb9c4N7+0LCOKk0apKQ1UYDSiS9IwnE+KmQymDQBJC4ERJweA6UujxOtAPS7JSTGJiYgE3MGjN4AKjaFkeLnFaM5qdYkiRLnY0tYCV4vbxgqmxDMIT25ammRBdGexRKhPFQKoiPiVCPxDzmm61QviErSw5DhhrS09CCoTSJ7lcVd7+QiSelEySKmxlHxJt+y7WdKOA1vXURnHCOUFIVRYYkVomPIpKGaJ3NDazjprt+Zjeb2jdgNESL2pSGUxBYMnU9K1EqD2GNuCGARMrxvUUWXuMTGSaEokxktmoqFZCrPB5w2qwVGsPvWO6O8ZOMlEkqmoESTOS4F1fmj0ho4UlKUkSHhEdSVeAQIaecVOjrCSJghxM0SFIyCQJMbyz5SIkTTMmGI3GF+xlJ7B2IKt4giITJwe9RCtDpQVaJnzMKD2i7QZ0XaNrwXJYoy2Yeky0I3qXEcJRWYkbMkP0WGuxdcW0HtPFEdatqJH0QhG0xrmeLANSWkw9phptIe0EoQMIh1BbVH6gsQ7dzGgmI7quRSWBlBEpElEmYogQI95LqnqGUooQAkoKdF0XKMzJRwmFFGUaKYtMJJODJ+ZyKAVfNqph8OSUEcoSQyCKiDYNRipiFDSjUYEH9Q5hztL1CVsppAlMRjOOj1bMdA9jiRHHqDZi9Aa/AQ9MxoLGBprsSWKHuRnRVJ6D3rGrPNOsaP0anRTKTsrt2w1IkRC52D6GlMkpo5Si0hIXOrLLJPN2zKv88ZUomp0UM1p8C3Rpa4tRmrqucH17UucsDZcUKNzikyZTbQ1CQjOqGKKmij06JYyxqByK2USkIs9sLFVTM2kMVQXdsGYM6HbgdCPZJlKrzPpon7DpUH7FvE5sNj1XboKZzUlWU1vJlZs3qU1NLxRDGxnHSLs+QtsZ636NchEd+sI6Vgopyq2+OOAM5Ijre5rGkJMo9ucwYDXvoB1zTic/EGVGSY2WCiUNCY1QEhFLwkVbA1GQRcJqgVECXwrJpFQEskmUEpaajghuRbtJ1OMtjg+POdysmJy+AC30sUXgsDLRKcfQ9sxGmqOup3MVtRmzSQtmKkKuaJMoKE6RSWFFdj1GGqo6IvsVWQpc9lhqmnGNwFNVFpXKxXM4+T1VBq0VyIj3PcO7SRlTWmBMRUr+pEliQCSUKCYJHz3CFqdQzJ6wCZiqol+1eBUQZkzMpZubZUIagcyK1CuSaRiGAZkNezunuJmOiGqDqqakekKyFSYLhItEo1h3PbcPr7NYHuOiRQwd8/mZEsA2hoP926jpDl1XeAjBl/S7J9PT0Q6OgYTSGudbTLJUlaUe1SCKQaH3Lf3QU1mJ0fqk1HAyHKE0Qz9gbSbH4g9QptTmXLdBplSiMkiUMmgFInv+//bebEmSI1nT+1RtcffIrAXo7nNayBvy/V+KIhzOSDe2qsyMcHdbVHmhXgUcGc7wiAykr9KuAFSiIsPdTE2XfxEV1qeV4WF4qYfA6JSsbCLsI7Cbt0XR6Rz3zNGM3sPZoi6Zn193nv/tr4zXnS+7M5KSPHN7KrTDGaOTMZZklPRgWRzPN46HQN/x28rtw4qMAx8xPVeJIFlzQfVgzoaKkzMxZR9K1rho/whemHOEI+wMfQWfA2sdpJCqMGdnmJFlIqUwcdK2If0ELCokzb9vwSLgRp3OVGUWweTOsg5GUZzB002jhbK/MHzQTGBWnn64cb7+ym3u/JCe+eneWXxyl460O5/WRD46Y3TSsoAMpu2kS4ReOMiamUnpj+gLjqmoPmLaTsLHGft8BunBLxcNEeHzxw/0MULM2mErlf04me7Y0cg1eqK5Fkqu1G1DjoM0JjP/yPa0or3jKeFj8PH5M/XpxqePNz5+fuKWQOYReg7N0TH49MPfuHnj85bxt4PX9pW0f+XfPwv7uXDMztjfkLqyris//uX/RHDUOvY4YO6sObO3xr6f3NLEJHM+DrIOllrQ5DFAHSM2wAzR+jkay7pgdl6pyLUxFIZNJkLOlYZwq5WM0h1KWjgeg62EfU8Pe2BUnaQhoTncGeMkGZzt5PTKsSQer79RP/6dPg++vA6yCPd//sxX/5lcK2lR9uIM/Uguk6/tVxb5ypZvnGWwziD3zBp2YX7eeX37yhyduj5Fa9EGX986P/z4xOuXrzAzn5+fSFJQC7jftMmYIxyBpwW0VBW5dJP/tKCrOeHi5NtKHx2zcMvVafjsdJ/4MRh+sLcjYFhvB8tWWJYajqhjIlrCymRM5n3nt992lmWit8T/8b/9naHPfP6bk8oTMzl5JvbHgyWtPF4ftMcX5vnCOBt1WfhYjL/88APp8cZ/+b/+G2V0zpfOWFbsFI5zkpeMpMJME0sGbVIzYIMqlefnJYKfNAbRoyENShFKifaJ/cGaBXGaGed958NTBheOflKWG44EWw9BPEpslZgCp+kUTkqqTBnoVnh7OZDUOV1oQN0Kw4zTnNMdNeeprtzdaF7JOdPPuPg+/vg37u1BUeHcD0wXnj594Pb0mVRWcla29ZnTK+f8fyhLoX76d45H4+3lFc/lAsV/048QkEySitY1gkhKTN8BYSnKltbvpeS6VLa18nicjDGZFoIjKjP+nZjWiwhnb8y0UjwOq6SNfOkwC5HZ9HQje6KuOWzQF+P+9Sc+fP5EWhdun574sh98OQ9qcbanxFqEZe7oeWBq7PdBWjOLN+7HC84k9TfafYIon3mjMBCBRZ2kQtcTVLHRYpjW7uREaMfuiW3LkfWlHOVlCgZj/gM54vE4WGumtwYaA6bjcWCthyj+SKSnZ7YPN5ZamTbRnFmp3OqGaMJQekl8+jG8/DrQzsbXL79xkNiSMvtJLs+8vu783z+/cMsv6PqJOTt5NLz+wBQ4+wtfH6+MppR1pZTC//6Xv/D29Vfur4kPVbGx4XmyrRu5VF5//Qc5V7btxnk0vr68ktXYtsxSK6XcgnEnE8mFdhxMW6O99B2oq6QS1aM5qDnTFRmNmguSVk4/mF3CJzAX2rnTW+xpI6CYuKNSSOUj+9GZ/3xB68Lj1584cuFTWmlNw2qLSk8VuSXyreL2Sr//THkurNxIz0/8dHzls6w0PUlPzm8//cr9MXAJx49j/41lqywy2JaMnG/c5Gp/mPE4GrfijP01RhiuAYNVRVToFiYFY/5h9vO/GnSHADXRbLCfDQdKluuAOX1MNHuUFJJpbZC3lW0rMf21RD87S97YpADOqcqRQ97t8IT7M08fKz/9+pXXXlm18vrSOTL09g/afiD7wOfgcMG6s94yj19OXn55wc+D7fmv6IfGcQ8rZfrOTIUuK4cHUHt5EnrveLpRk9OtMR+dHed2W/EBS7pha4E8Y+hSrwOGMeZ+HbbJ26GsaybnSp8dz5k+TuZ5UOuKlIKkkLjLSaiLkreV/ec3+n6w379w+/hX5jDuv/3CuZ9Y2sjZ2baD0R1p5dItDjeKp7984O3XB+tN0FxZ1yde9E6RFa0bUzo+BsjK62n0/hUtKW7zscOAdc3ss3POzK2sUQYzySmTU6KfB8c+oQSi4WldGX0w5/17tit2ogzEGjIHGSJDNQlxd034ZWUCMYyZTvSNZSC1BI7MMiUtJE1g8Tz1/I17Tzx/qnQ3bmtFtPHhtlL75DEGszvbmqm10k042k6qxpxKmSf/9mScb6/849ypq7JerCEXJyPggkmJ8ng0tGa2mqA/0e4P8tNzeIFd71okIqxcFO/vvpRCSHyK8rwteO/0OViWFNmww5KVmgSfTm+RJeVS6Anu7eRpXXicB4yC14XcGzYnj0cn987pg7MseC7040By2H1//ssNGS9kEz59+Du//PwPkgyqG3/9+MRB4nBDUmKcd2618Pnvz7z8+mB+fSAO1RdsvCFt4PUZTc6yJMQTo3cej8Hj9c7Hz9Eu8P2N0TtSUnif/YEUoDkjNQdNGMLc9OhXPJ6k46CUjemRqTpGXio+EwOJmQSAd6qCpoykSu93hMxBpwzj1+OBsjHMOIbRZeK7I78J9ekD5UlZa0ZP48vLL8hw2qd/Yz9/wf7bT7T+YC0bblGxDz9pRyMvNZTlqPg4WDWQDNk7r4+JWqbijNbBoyLzyz08qzNq/fOCrpaMeYDClypM5qWq5dckuFCSgzXGaAycUjdefnmwbs+QFp7XFcbkOEaIZmulPt+4HwfLh437MMbrV+bRmGlheX3ll9/e0Hzjh21hHQsDhVLYjsZvv/2C6xM/f/0FqYXzFPL4DUXh40dkLNSU2c83Hu2VUxXJkyWNICzo5HFO7HDyvLCWckSDv05G+M+gqt/dTWOcH6VWVuE8H5xn6My6O+InqST2M3G2yY0HW02YLvgUJhnpD5ZstHXl+dNfkTTIo3HrG9NgdKePKGWW7BiFIR8Qwrb+/tj5/PkHls3pj8Sv50EvKx8//pWyPVFUUIM2BFeYM3P78Hc+Pi/kcfJy/IpWsOFskiPrT0rJEnhkg5EqUzrVZmAt6w1NgtnvbqcxR1DWpWIpxQHRRB8jzEpRPFfgoD9gmGIOqYDYwLpRtFJLYclExpvBzi+MLMwJ99c7z39/5rW98eN2Y1yuJVtxlqpkAhFwzMk8G+fpbMvg9vEJ98Qb8LEK3g/6EF4tUZvylMNZYLjQOgxRFjHUw2pecqHUZ2rfsTk5emfOiRICRjYH85v4gnsMf7zgWi6HZWOrG3Rj9kegF2zCNRuYveOumCbOw7D+ynNWXnvg28ttYVkLokZNhS0pNU3cG12dsiY+fvrEOYwXg7MN+tlpbvz25QVdK5orZkayndQzS6n85cMnfv3lJ44X58PTM2u+0e8nbB9I/y60xxujDzLCWjOUiigc+85sd8YMIRvHeKoLQr60tr5dxINkM4Kue+gKG7g1msFoR+Ch1xtIYrZBXXJoUUjMCdwLqhveJjad2+a8tYWswqe0cvTJU1Zef/uZmSt5Wa9na6g61k/QlbsBNNbbjS+/DnT8xNY6dzN0hhPxOV4xMuv6TE6QrIVO7jQ2KpIyfh4X3tjBw6xTdXLs7YI5Jtas5CVkO/+0oCvDKFwSfjbos2E+UdFgm0jHxBDLJDFKSYwG3pWjH6RV6PfJkjWgIzbiAOeFpT7BcfDl5Wfy7hgr9vaV/9r/yXONIYJ5YcwUzgTHg3/+15/59acXPtTGD88fSfaR2xOk9oXzaIwXo1aY0jklMK/mhlAYeqOUhHkPO52aLyhNWE1/+LgyEcZhgYXVzDdIjFwQsFQKZiMcEzxSHk0FrsD09JRwN8wnxxxUr2xrxufJ2z7xdIOsvDxOqnaeNkWXxOP1zuOcjDaxPrAZE2+WjUql5hhA7Ocr9wOkPEPdWPMPpLSh01EVpFwg/h4Y0yVPkp0Mf+Hjp4WzT8qHxJolMtyirEtBDJpbCJDYxDPktDDag7ystB7TbICyKCkZzYw+jOyTvCSmXMFVldEPXAVNK2k4W46+fqmFXCqiCyoZvKM2qZKZ68r+aFR18vNG7W+Uz3/h9dHxmrlVZb0tSFLO0+gphlJyW0mPn5jzE6/3ztNT5hOdwwb3JrTR2dYBpAi03QLqmAJFIKoUjcNVlsqYd5rP6ONm4hIZAxUn5f/o/Nr6pGpFfLAtTxyt0XdHUmZbN8ycfkxsHsi6knLh3Hfejsbt8w/0BjkpZSrPH59Yl8KSKyMpiAU0PEOfiZLrpXgFkjL//Omf3MrK69E5G3QRpA0yGakrnoQxJ3om/svrr3yg8Gl9Yrav7C1TS2LJRuonzTvm4xrqFVo3zEMvWHKilsJpIddZ1so8Bj7692a/98Y8w2NOgOPo1JrwVHk7OkvOSK30PoIaDOAKmpCcEcLSXJNSc2L2UOurWbHDsJT4tBSGNI7lmSRGzjEzSXTKutHqRjPnaXHO7hz3N9YF/r4l/vHyhbx+Zu89SE7JSeaICrUW8pgxw9gKSSb348FIQvbA3GeM/QibLhJkcbLGtLRb+gPK6U8Ius/byqcPC6+PHUMRiaiuOeh+5zD2c/L0tEGDIol7MzBBCpxHI60blgoqxugjaKG1kkQYyfHHVw5z9vNgrZPb7RMgVBVyyrzdH9y/fqGdD2Yb/PjhI4tWPn36G0Li/PmFr/fjKo0O9tiViEPRsPKIqwNmP5k2eP7wkXaeLOVGorE8b+RlYe47WRWRSiKyWrgYaRMWKTRRtmI8zs6cARtaUr6gYjkQHgzcRmA7gZw2UokB0P10Pv/t35j3f2Lnnczg0+cb5Zg83g7OIwZlxSdPS0HLM2MkznaS9ManD8/cx6SKhkVV8quhb4h1imb0qbI8P7GVSR/w/PwBa2GW2NvOGwvpmihLu7zABFJOaH5CE6RspJyiqvlDpttatJZSqaQSMCLHKFmoTwsMwQa01sLSW5fIvgS8NXxOJA1SKqQs34edS1bS5428LRyPV0yuDElD2evo0L50bs8L24dM9wHt4CadXgpj7nxYnshMXufKy76Tk8T8YcwgJKTCnIQ6XHGGG70d7PvAgjqHzTAazDbBQrTa3GJ4giDyu7RjdmPsJyLKQ07eHidqkEOMGLsy5dkck0ReE8vTM2WZTHEGhqSV+qQ8Lwt7O+jnzrTBxLhX5Xa78eH5E1gYib7uLxyto+szL68NUmFIom5PiPWQ2VTFjsbxODlbYxN4+vFHij/x+nWnLhuPxwne6eZ8+PgB64M0B8mdmhaczuOSMSylMDURHoEnSqLP31XGTHJoe89+4eommrbQaZDAPkdbxtiPO1vJLHmLveXKNMdnBOScK19Hw5JgliAt5Az7PmhTqcsnzjHoR+N2W8lr5TSDGf52r/cHqWyYZlQGr/2G/fBEapNl7XA+4sgsK0MTs5+IGG6NNDqac8wERGOYOgbTgkwxZpzpNReWkhjNLnPX3/fE/3LQTclJqmypUpLSkrIfJ+1+Bk1SoNQCrtTyTGsnWHyBaWv0PUbHZ2deCuuiwmwnXTrPt4rUFbPOWhRNFTqUJVPLRmvK/jYje7BEwXnKmfX2zFs72Kazj0leE6TC19OwMSnZmO1APBTrReP2PWYMj8rs5OVGP51UCwMoCaRe7KzR8HSpiUHI0S2VoQkfndMm57kzTMg14Q4lJVwtdGYt2FxjDH790vn88YklL+QSg8Wsk0cpSJ/UlDhmYGHLsgDKYvHfu09mTqRy4XHPN357m8ye0NsHUpn47AwHxHkuC7fbxj6ionh9nNyWFWG9OPGXxYrCrVRK9kufwhitM0yoy0JNiXV9ZoyG0FmfbnzL+pdtY10rFh8aBAgD+rjYSMHY8xSykGKdUlZmnyTV71hQkQ5ama747LRzknOI5kstHC9vLHUh5YlrYcwKOWHN4MisGWzskBPTnE/PN5gxY7ilga0FsY7JSXs0pgtjK+CJkoJltpA5LtTG6C0unzagzdgTqlFBXPKNbhKGjNdyjSyw5AV3oZSKTyNrwn1e7DOllIKpBEFGwuJpiqAp5DDJlf3+YD9eebQ9dFsFlrWE5bsmtFZu20q36H+OZowJ8/hCLhWvwvPzM5oqb/c3zscLPoPgtFvmfn9B6SStnPsrj9cHT4vycVvAjEliiqEWAWdYYtkWeh883r7i7mRVUlmxMy6x75AxgJQRN+Y8MHPe7hNxJ5PohyOaAlHkxhCJMFULICRxIHM249EOxI0ujiRhKQuaBVJjMeV0ofcT88nLIyFDSEskdfd90obRHzuosm4Lv355xUvCdUGy8XF7Rs6TduwE/8Xp50FJk7kbL1S2onF+XZit0Y893ukM88vhTsNYSsU00fY/kRxRPJNmAOLNJtZDzCKlFFg+B/eEHZNH71hO4E7rwm1d0FRQCVrpdwiKBZW13hLdBmvRAJ/MwW27hcXJ0XmxL7SWaOdku91Y60esH8g8IU1Se+OxT9g+o3nyOAaaK2WrWB/Qo2yZHt5mLsJaaihhnYPbFgFt4IG5I37JYdFnvCj032IuwmTfX+P74JSaWVJG5qDNQd0WiiZcFUmVmipZlP3omDe6OdMqSPw+21owf2Y+DtIMM8dSNcTD+wBRSlpwXznOr0wXUl55fv6ITGMf0OdEklFzIiUJg7wR7Q8nbmww9v4g+WCMideNZVnxpHQNnG0WodRQ45Is0UaZ4fi7LBn/w01etJC1QA3MduhSgCSlXVmQ+CB5DhqxCTZ6aJG6hMnndGQKcqm7mRt2DHY3UjLGkck4oxuFQk49YExSKQ6pGzLjsCft/JgF5S1KRMk8+o7aAzWotQSz0IOEgTlmRgE8F4qALBvMk30/oYeehIgHMmNOUkrkpCH8M7+P7NG8krSQtNB6R91JOSgUjpJyDENVQ+rTzNnf3tCcuD92tCzI8xPZBmd7MFVwTdgY1JSoqeBTGMNZaxAEQh8opBNzStictLkzesX8jVoaeFQOfZyUknk83nh9Pfh4u3FbCi/T2KpEv1K5ECgOEhrARjwjEUVSoiwLWYRcV3IunHbHvh0MokKqNaGXxoRcVTES4vDdJKBZBBJjkng0g2HUmkhCVDQ26fudWpVbLkyBTQfpMsHV7cZxP5n0qz2UYRppTrDBcGO/9hsyme60aZxvTrkZSTpiBE49Z8oM4k5RQVG8VMoUlq3gYzLOg6M11MvlIehB6b5O1nACYud/orSjKAyfcShMybpQ1or5pPXGNGc/J7lkPE9GO1jWwqqVqqE3KeIh9+YTVycXpS6QkzNEUM20487T9kQaGmo+gB0HyeBDreSc6OfJfuwsyWKoRaJJxr3zOO7o9ikeDsGQGZIiG+sn4SyZQTPDIrh2c4IWXjATZgsLjud1C5FiEulqL5iF24ETBy+posuNOQJnGJ8ZOMWUCyUHyDwm23FxGIakiYsCivVOQli3G1KMcQxmH6QcfT4uaIrPBOk5aM4HuCmeE6WuqCXy9hSaCeKggqleWq+TXCo1Gb2d1JxZ8hOMhspEU4ZraOiSUA/RnmD4xneFibkwzwfferpZwozS+fY5l2+UR49rzm+DSIGc8BEDpJIkVNss1Oe+aVuId6ommodql1lHLiqpyAlUxhjUFL01mYnRE6oe4PVaGGNSeiGVSj8H0k+07SRN2DCyQ04JRRhmuME4WhBLTEE6SYWq8WxtzKA7j45qDscIBLngZt/izfPtxnE0wCIRMYsLzQylIk0jRl+EmTGd3jtVjKQZs8iCnU5dlmA/6UK6oFdzhOHiOCcPTranjdFOpsC+nwFBk8l2W2N/jMkxDtwvRcUhgSIZjTaM347O9nQhixIMM9IM/RSYzNHxEeSgORwn2Gieo8XjOH1OHGFb14v2CyUnIt+aIQuaCnINXJd14egTfGKzkxSmG1yB0a++sZvRe0Mx5vS4wFLh7A9EYVk3jmuPlppow5jjQFPCp0LquCij7cwRAjz2aNSlhuQqJ1IzwyuGX7BGZV0yKuWyG4pB/+gHGeijkyRjTFQuYkcU+JR0tR/dvgv//ClBd8zOmDGBd4uNl3CyCppDMzUr1FrZz4Npk6QLNmOi6XINd4gJY3IJ9ENv+DCGO1kMeqebMkajnw9KTSgp8Jwy6a2zH512xgSVW6XWjKkHcaOWS4RF6WNSSsVmxkaoAohOUipMB0lRrjdzlmswYmNCXdnqEtJ7Y/wHhUyRbwpa3zYfRIpw0q1T8hV3cGSE2HUqISCiAos+MefgMQYlL+S6MPdJVqOkhO2DYoJLYprF79Av5f28kPMTkgStifOYpJypS2HOdEn+Bh1VU9inJxU8VWQaR5+BhRSHLKw1cMXmjnxr99igjx6asXVh2kQk+rTik6K/Pw2/9ARCNCZaKKOPmFyLxJ8T91xOhQk8zs5wI5Xg50tKceF9679fVUXRcNztc+IaBphjRFCzAaRL1U4yuUYfHbe42Eu+1MtO1px4O512HOS0oLoinpAxkHnpu7pc6nnKo91JRmiM2IjL1SaqemWpoSam8AfxHyGnRErKtJCFxGdcOCkhIzaKeCh1qSSmOqdHIM5JgrE2B2UNR+XZw6XiPDuBeRVcnTKdeTTGMOY8mQS7E58Xbdcps9BxZu8xKCSxXntdXREf3Pcz0ANkKpMxDUmBqUb0O0lI/Pou7mG8iTNbQ1Nm2a6sl98ZaXoNej0ROFbke0XhRI97TEc1LicVQ+i4C6N3fCruEgJKotfeVMyE1ifbbWG44OKkJZMFxt5in14mkcfZ6NewMSWgDcyjSiiqpDFJtUbLWeICdZsxJM+JcYY1U05xY/m37ydKKuGpOBFUhXz1qLMS783+xJ5u75N0hHKYIhdNNjIZMweDmtM1JJvR/8JRDa2CMDUMxlXohgSNru2NJMZwYy3B7mr3nTEcZVKWGhP8MWjEoZvzOlypgGT2NjiHIwaLZpSMSsbdyElpqpjGS0lZLu1PxZjRT3Ml5SUoiAB2iftIWPW4hdke18NPITMU8oQemS2iwf5NobtgczL7ZCYjZ0EuOpf7dVLnZC1h2/w4EyWF35h/i+TmERCiGEdz+S4GPXHwjYWQokQCR/xNrEaTIBr0xJILWKGPIzZlDqZYEScvS1ir9PMqo6/y0omfJdSyHGcpIeMYEfLbsksURf8gZG3xIxoeYopfhIn4XPF+CSUR+doQ5AAADUZJREFUIjFiQNh0p5RIOVF8IhqHxCRzGjGUypOcLk82D+2DopG1mjl9OOlSC7N+RBC+CA0e4s8oGUb0rsUm0juaMj4EKdES8+nkHJ5wbn61JRx14u8ktDR+h0rFc0ql0HoI+UiKgaZdUER1C+hhSphAFefMF75VIzOM8vbGNKP3k/1xcJyDnNNFUjGmRyuvPd4uZtRESybJBHFmAx8tgmNvzAkqFSsVl3oFQsdH43wE6iI/hZX89Agk3/RUHL++76WRO+M9ukQwVjc0R1vj+1UcQtJxwYnCnLgHiqabk3ImMaKVhJB9IqS4XJtFv/tqBUK0IkyjPZiuqs8s+uDD4jLKKVxtXOLvOXqovvm8dFCu8wpOyoBHnFEPUof5dYGK00ZUq2IznnWkT1cQTlgqQR3/DlaPnrtIeEeO/6A3/T9e/7n2gmkIv2j6ziEHZ5ozR9xGKg42SZLIBTQFTc6mRUk2wbUwzRGPjFfc8Ez8v1fvsB8HQg4v+xZlbjuDYpmroqWSUvSPzODYT9xXGM5IiUyK23qGBYhd8A6RhGqKjEWFOSZ6ZSmaKzJ6IBtG52whbPFtaIL98WGGEWOpBZmhHVqLgl0b43pZXDe1WWjV+nT6CPnHnGtA1jzhjPi+8Q7xGThQN4vDnTO5LAwJ6bhaCt2UVIMcMQRSWSlaEP0Gw7mESUomTYG1AIrNM7KtlC8dCbmyuOuASZS5qkLvoUEBgVRISeI9/f4UApXhfmUDsQHDuNKCvYWjWVAznMmSwEUoJZMg5CGv51Nrpi4Vy1HOzWEkyRQgq5DFQ/1KDNA41A4+guvf1UGE8/G4YFZR4SSui0kEMb/2YwRU6yNYUyQ0yQXHiovDvDCnkfM1OJl2Df6ChWR/UJ4zuy6POZBcA/kyJ3QLMoVoZEsaAvc5CSWHTOR0j373dPBM71FWjzHQpBGoUvRd5zjJpQaN1VuQYBiRTBSY7U4bF2zJJ+Jxec64pUg+sRE6t7NN+vFg1BLQR5Rvxm9OaMWKO+n6/havNc4KYC0cE/4YaMzjuZKiteAIfBNGuvaHJqGkEMm3b0nGnNdlqqHhgf6hB35d0Oq4dURrDOp6J+EsS8ZcOCd0u4SURg8qOw45EpJpoDXwue5XNXOx6eRKxnoLNBAY7RxB/02wpQQuTIk22TeOamTq0Tcy9ys2/v+v/2RPN4JVt2g4J+V7hoFFuo9N3I1aFzRNcjX8IQhGvsgE5lfL7/qHUhUpGWVibTLODjOGBW/3NxogJV5syQXJ5fpdLsxwn8xeWJbt0sYsdHcmoYQ2JdhRKSWSKkkgqTA9/LtyKUiKrLbkFCLbM+h86okxLA71H56lIPHyUw7cpg6yKqc5NjrDTmoNyq6kBCld6IeOiFNKlMv741I5SzGEEmaooyn0IEyhV/YsRGnmKtS8kTEaJ3kplJQgbUHQIDagWwwqxww1uJwWxmhM66ScmAg+RvRwNWHe4vNTChdgrpveYnJ8tBZQsPKHif2VEduMdy8eKk4+BmJ2CT07NWcYRlky+BJIF4msatjAPZwnVAdJMikrczhx5U3WnAK+M05QLqH4kKNsNknX4Zx9Xtn6QV4Wco6gbMOjXE1+yQTEoMgc3JVpCpKZJGpJiEZpLlJQGm72HTL4rY/nV9b5fU+IhqzflYl+y4jDLRYQCUF3t1C6ypmSMs0mNgzRjFsEo+EjKLCipJQpOVNLCazsHOFPGAJeDB/4mHgqoddx3GNuMCc5F2rZEL1YdDOy6fM4aX1Gjxdoo5NziWpkdLpFDxsn8LPpqliulocK0Xv9HmT+WP3EpWLT43IUIsjZjPaGON2jUrExotXlUc+pBlIg9k7gdN0ulToJXd6aIjArTvLGUispCd0icBbJ5AT7EXovmIXsosZcR1JF/CDH8AVRieG+CCIS7VKLiya6lBVVo2ZoYzKHXd858PBJ5HKO8Kvl8ycGXZuGp+vluZE8PMT8ajGM3lCdiFpw1FNMnWWJWyVfN4JBKHDplfJroqYUjgqtkzxTa7re45U5CUgp5KUgCOOMbKNqICIQiz6dR0+lVv0m78qcIwZn7tGSyBlRxyYsyxZ4Q6KUzOpkmQyP4dmczrjwpN+fpUf/R1UZvTN6I2fHJfrVszVSyldf7LJoRsAHjocMXlIKxrhEj1ULygxqJUYuUD3Rh4D8zvSyJNT1hsmKurHUwtFbUJAlYQR5RPwqEQV6f8RBmHHQa34mY9z3Ryj6E7XVdT4iYwLGiMGZ+re2iiOasT8MCpywIvIZ7ZWkStWwjFG9dJe7kZJHYLgGiiqT0c8YzBBlsU2j7YaME1LFiHIt5chM5uwIg6T16t1FAHVPcajSRG1iahd9FaYE8qA3KCUzR/RVA2Mb72cmxTXTe0Dm0tWusQHjKtnFnZxLeJB6ZIRRRf/OjhCidSRX5oRHjzzw7OPax99+fkZA15iM93nAHDFUvsg252lkyczpoEYWoaaCSAioT4WlFDR3zCezHXhOVxCwwHKLUjalXJd2a53WT/oYvL49KDlTlsRwgVyirTEGvR2BBPCrV4+SXZmX5or7JCiEclUjvztEf+uMucXAWHH62TCT0KHVgHu6zcCHf+sFEzA0AxgTN6OIsZ87IjnE9i8/Nutn2PmokMnM3iIe5KhAtlwjBrgyADv2i8pfLluoSZEY5tvl8yfuyOWggg+wTM051BA9YNpJUwwnzUjiV6sl+rs4eA9X7D8t6PbWQ7CCyHD128YSruwR0NC6tR7WPmEIlWGMizoXWEdF6ZdGbQbchERFc1Ad970xZUKpNINCwiS0aP1sMIVlfQ7blyTkIpzDmfOk1sS0iqvhcga1sEbQwg0jBmklh4jJ7IZZ57BClbhlXVKI+ozQCI5J81V2uTNGQ5NjM7KtlMOUTi085EpdKEWvXtLE5h5wohoOAr1BzqAob/c7c0zKEt34GdMXbh8CR9qGYBfIvkkFhLoV5tGZNtCyYlKjLOuddYuB0Hn1AtdlY4wRfSti0jqnUEv4PgW7roIr1/aJDFdrDDZzwfrBVi+I23eYVGQHQRqIQYVcz0GyYj2ypaUkZDTQMOj03EIA3IzmRk5QUvQZxQZzaJSRbtyKQq303uJgkRFXbBpDFNcoXwNoGPRcb9EOmFRkhKOHaOF+nFEiEs9CZlRAEw0zRo0GzzBQT9R1xY+DcgtftJxrlJFXpjpGtC++n49h5Jw59p3WB+uycJ4D8xGAf5wUPRimO+djx1zp3TATkCDPPI6Ge4tMXzLuA8ywMejaSSWHIcs0phhbTkyb2AhZyqlrnLEcaCC9nk5vjdPHFeSEmiGVuDQXmRz3B2XZSHkDh2mNeVnNR+tZSaWSSeilgatVyKlyHGeIRBHolN47qhcGGmPYpKSMz4GrkPPVXswpynu+5ViX24ZG5ewWQ+SyhNvE0R1dP7Efd8q8RMwvBEVKgc6Yw5FaWWulHZ2lFPK20m2Qa+HcT0TLlZAEIiHw0pPhHi0xMfo02rXXRTPdrlwxlDgCzilytQSjwhP0O3TuTwm6L69vXIU1KkKfjT6CxYIKuRTKmtnPcZWxO9MyeKOPxtNaEbs6wR5BfPQj7Mxz4fnDB7wN1DvHvTPEaNaRstGlR6Z9bT66cZ6Tsj5hI4XluTlzQBtv1DUz2476gUlCR0zgRZwhSuqTPkIUnG8DHslMn2Sb9DkQGRGkZ6hEjRmiHQ70CdYHJSfmmPTxig/4+LwyXNiPxtkGtShJIoCoKsu6sWRlGrzcY2Bzvz8YPrnfJ7UuSFkoozGuTSBkai204extx1Mh9XCzOM8Tyxsudk1TE2M0UkqIdh77g9mUORpjGutaaI+rBL/6k+4nxUOAiCtrjSATYiO9nSSbLKnQZrRDvoXd47iz31859hZBNxWSBJSsHTtg9F2jT6qZffRrCt0Y4wQ1usaQTF2RvJJ1YPedVCqnQHtrtNFIJdpDZ1eaDSxXtMbFkpRgEvENmC58+Dg4TDj6pfJljcOdmqNHGmw0DwiYO66J+5xsS2Y0WGuJEnuOsHMZobTmc4bughnteFwXcQQ1FaW1zuOx05+eaWcLRSqLcjylQFj01qJvizJcsVwZPqB1Hv/4B56UmuPZOyE889ZeEf0a5BQRVA16IBHIJYq5cWIzMLJpGqLQjobTYj7SGznB29Hw6awpgxovbweaM8sIs4Gxn4zzQESoF/LGR8MsApWKYuMk58qjzngm34LuNPoliNXbRTRyp43GFKXdH9SaWYoy5mT0AxuhJfxtBqKaot/dQxrT+8k+jHx74uvbG36dx/0K7innS3wr1L/GGS0Amw4jECIu0Efj8TjIpVzV1gSP2DLNMVXGcOq6MWcLZl5JHPtg227YnIzzpCZlTseaY3qNus1JOGf7z4mYi/9PJm4i8j/+w/f1vt7X+3pf/5/Lv0OV/vv1n0Pzvq/39b7e1/v6U9b/NNN9X+/rfb2v9/XnrvdM9329r/f1vv6F6z3ovq/39b7e179wvQfd9/W+3tf7+heu96D7vt7X+3pf/8L1HnTf1/t6X+/rX7jeg+77el/v6339C9f/C3O97MLWf/koAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1338,7 +1333,7 @@ { "output_type": "display_data", "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAV0AAADeCAYAAACe29N1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAIN0lEQVR4nO3d/8uddR3H8es4qU5tTtMpzkqnW+XmJIRZ4liTHGE5Z6UGhpSyBLWw0lpmpaClGZVfEg2/BWISGuIPIRhlhuU3FGe2OYXccmp+ye92Wkyv/oLd70u49urcnMfj1/vFOZ9P6ZPrh/vyHrRt2wCQscP/+wAAk0R0AYJEFyBIdAGCRBcgSHQBgnac6oeDwcDvkwG8TW3bDrb1M0+6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQNOV/xLwvo9Eo8TW9Gg6HvXzOdLx700z2/Sf57k0z2ffv6+5T8aQLECS6AEGiCxAkugBBogsQJLoAQaILECS6AEGRlyO6uPjuJ8vN6R/Zudy8dddN5WbGipM6nSlpwQV/LDebX65/2fyBM5eVm4Vz3tPlSDG/fOif5eaqPz9Rbk48ZJ9ys/qgPbscKealNaeWm9fXbi43c79+ZLmZ8cmTO50p6b/Xn19uNn36jHKz6pr7y826b9b/biR40gUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AoLF5OeKYX9xTbtpzPlRu1h3143KzeDR+L0esXjqv3Hxr3y3l5vVrz62/bE39v1HSkR/ctdy81bbl5sO7vbuP40TN/sIx5WbzpaeVm/f9amUfx4nbcPIN5WbRA8vLze/XP9fDaTI86QIEiS5AkOgCBIkuQJDoAgSJLkCQ6AIEiS5A0Ni8HHHLKYeUm6/sNCg3C289s4/jxHV58eGR+avKza4rF5ebWZ1OlPPyxw4vN0ser3/5fc/Vh9ZfdtnVXY6Uc80b5WT3488rN7MuWltuXr9wvP5qRtM0zZxjD6pHW+q/mPK1wxeUm193OVCAJ12AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCBJdgKBBO8WfQRkMBvXfSOlgNKrfKBk3w+Gwl8+Zjndvmsm+/yTfvWkm+/593b1t222+PutJFyBIdAGCRBcgSHQBgkQXIEh0AYJEFyBIdAGCIi9HAEwSL0cAjAnRBQgSXYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AoB0TXzIajRJf06vhcNjL50zHuzfNZN9/ku/eNJN9/77uPhVPugBBogsQJLoAQaILECS6AEGiCxAkugBBogsQFHk5oosHn3mt3My79NvlZvPFfyg3i0frO50p6a/D/cvNe49YVG6e/vl15WbJ3FmdzpSyy3dvLzf3b3yx3Jzw0b3Lzd1fPaTTmVI2HH9juXnoO58oN8cOHi03Oyxa1ulMSW/efnW5WbfqJ+Vm/k+PKTfDU87rdKbtzZMuQJDoAgSJLkCQ6AIEiS5AkOgCBIkuQJDoAgSNzcsRtz32Qrk566QTy82br23p4zhxM2a9s9zMveyH5WbJVfeVm6fPqX/ZPunF81aUm/aJteXmL7Pn9HGcqPlzZpabve+9otz8/ZL6paD5D9/Z6UxJO6w4qdwc8MzK+oNm7tLDaTI86QIEiS5AkOgCBIkuQJDoAgSJLkCQ6AIEiS5A0Ni8HPG5K+8pN188+oBys+b7l5Sb3TqdKGv3jfeXm0/dWL8g0LZtH8eJev7LXyo3z95Qv/Sx4LLPl5t3rT63PlDQqcv3KzeXb11XbkaPP9fHceKuf7g+9/X3PVluls3/d7n53mHzOp1pe/OkCxAkugBBogsQJLoAQaILECS6AEGiCxAkugBBg6l+mX4wGPTym/aj0aiPj4kaDoe9fM50vHvTTPb9J/nuTTPZ9+/r7m3bDrb1M0+6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxAUeTkCYJJ4OQJgTIguQJDoAgSJLkCQ6AIEiS5AkOgCBIkuQJDoAgSJLkCQ6AIEiS5AkOgCBIkuQJDoAgSJLkCQ6AIE7Zj4ktFolPiaXg2Hw14+ZzrevWkm+/6TfPemmez793X3qXjSBQgSXYAg0QUIEl2AINEFCBJdgCDRBQgSXYCgyMsRXWy9+aJy87elp5abK+75R7m58uiFnc6U9OoPvlFu7jru7HLzn61vlZvP7j+n05lSLvjTxnKzcI+Z5WbJ2aeUm7k339TlSDFv/u7acrP+2J+Vm3bL1nKzeLS+05mSNi0/oty8eu/GcjPv/KPKzcwzftTlSNudJ12AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCBJdgKCxeSNt/QnXlZsDX6zfOHroyZf7OE7cpvNvKzdvfOascnPHYy+Um3F7I+2ODc+Xmw/sUv8ZlX/99pFyM7fTiXIunbmi3Bz26HHl5sCXHu7jOHm33lJO1m56pdyMdq3/+Ti404G2P0+6AEGiCxAkugBBogsQJLoAQaILECS6AEGiCxA0Ni9H7HXax8tN+9SGcrPm8AV9HCdu9qH7lZvD9tm53Mx6x4w+jhN1+vJ9y83S988uN68sm37/39/5WP1iyG8efKrcXLhyUblZ2ulEWfdufrXc3Lbu2fqDFu5RTg7ea6cuR9ruPOkCBIkuQJDoAgSJLkCQ6AIEiS5AkOgCBIkuQNCgbdtt/3Aw2PYP34bRaNTHx0QNh/V/ib6L6Xj3ppns+0/y3Ztmsu/f193bth1s62eedAGCRBcgSHQBgkQXIEh0AYJEFyBIdAGCRBcgKPJyBMAk8XIEwJgQXYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCBJdgCDRBQgSXYAg0QUIEl2AINEFCJryL0cA0C9PugBBogsQJLoAQaILECS6AEGiCxD0P6rDgX0S6lmJAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] From 6235a2f07303f984768909e02466c9f6b08e10c1 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 21 Dec 2020 19:44:03 -0700 Subject: [PATCH 51/76] Fix lint errors --- captum/optim/_core/output_hook.py | 8 ++++---- captum/optim/_utils/models.py | 3 +-- tests/optim/core/test_output_hook.py | 1 + 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/captum/optim/_core/output_hook.py b/captum/optim/_core/output_hook.py index c67d98d099..9f4db55031 100755 --- a/captum/optim/_core/output_hook.py +++ b/captum/optim/_core/output_hook.py @@ -1,10 +1,10 @@ -from typing import Iterable +from contextlib import suppress +from typing import Iterable, List, Union from warnings import warn import torch.nn as nn -# from clarity.pytorch import ModuleOutputMapping -from captum.optim._utils.typing import ModelInputType +from captum.optim._utils.typing import ModelInputType, ModuleOutputMapping class AbortForwardException(Exception): @@ -97,7 +97,7 @@ class ActivationFetcher: """ def __init__(self, model, targets: Union[nn.Module, List[nn.Module]]) -> None: - super(ActivationCatcher, self).__init__() + super(ActivationFetcher, self).__init__() self.model = model self.layers = ModuleOutputsHook(targets) diff --git a/captum/optim/_utils/models.py b/captum/optim/_utils/models.py index 82437fbb33..2926603a1a 100644 --- a/captum/optim/_utils/models.py +++ b/captum/optim/_utils/models.py @@ -1,5 +1,4 @@ import math -from contextlib import suppress from typing import List, Tuple, Union import torch @@ -234,6 +233,6 @@ def collect_activations( Collect target activations for a model. """ - catch_activ = ActivationCatcher(model, targets) + catch_activ = ActivationFetcher(model, targets) activ_out = catch_activ(model_input) return activ_out diff --git a/tests/optim/core/test_output_hook.py b/tests/optim/core/test_output_hook.py index e4c568c27e..6bf8e68bd3 100644 --- a/tests/optim/core/test_output_hook.py +++ b/tests/optim/core/test_output_hook.py @@ -4,6 +4,7 @@ import torch import captum.optim._core.output_hook as output_hook +from captum.optim._models.inception_v1 import googlenet from tests.helpers.basic import BaseTest From 2142dd7122420b0005968eadebb2e017728da5b0 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Mon, 21 Dec 2020 19:51:08 -0700 Subject: [PATCH 52/76] Fix test --- tests/optim/param/test_transforms.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index b7186e8b4d..e6243d263d 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -174,14 +174,14 @@ def test_center_crop_shape_tuple(self) -> None: x_out = transform.center_crop_shape(x, (5, 5)) - self.AssertEqual(list(x_out.shape), [32, 16, 5, 5]) + self.assertEqual(list(x_out.shape), [32, 16, 5, 5]) def test_center_crop_shape_int(self) -> None: x = torch.ones(32, 16, 28, 28) x_out = transform.center_crop_shape(x, 5) - self.AssertEqual(list(x_out.shape), [32, 16, 5, 5]) + self.assertEqual(list(x_out.shape), [32, 16, 5, 5]) class TestBlendAlpha(BaseTest): From c1a0b3decb948ca9778b0583e86f3e2f43e2b9f6 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 08:51:37 -0700 Subject: [PATCH 53/76] Second batch of changes based on feedback --- captum/optim/_utils/circuits.py | 17 ++++++++- tests/optim/core/test_output_hook.py | 15 ++++---- tests/optim/utils/test_model_utils.py | 17 ++++----- .../WeightVisualization_OptimViz.ipynb | 37 ++++++++++--------- 4 files changed, 50 insertions(+), 36 deletions(-) diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index 2735da05ed..ffe977e92a 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -5,7 +5,7 @@ from captum.optim._param.image.transform import center_crop_shape from captum.optim._utils.models import collect_activations -from captum.optim._utils.typing import TransformSize +from captum.optim._utils.typing import ModelInputType, TransformSize def get_expanded_weights( @@ -13,7 +13,7 @@ def get_expanded_weights( target1: nn.Module, target2: nn.Module, crop_shape: Optional[TransformSize] = None, - model_input: torch.Tensor = torch.zeros(1, 3, 224, 224), + model_input: ModelInputType = torch.zeros(1, 3, 224, 224), ) -> torch.Tensor: """ Extract meaningful weight interactions from between neurons which aren’t @@ -21,6 +21,19 @@ def get_expanded_weights( represented in a single weight tensor. Schubert, et al., "Visualizing Weights", Distill, 2020. See: https://distill.pub/2020/circuits/visualizing-weights/ + + Args: + model: PyTorch model instance. + target1 (nn.module): The starting target. Must be below the layer specified for target2. + target2 (nn.module): The end target. Must be above the layer specified for target1. + crop_shape (int or tuple of ints, optional): Specify the output weight + size to enter crop away padding. + model_input (tensor or tuple of tensors, optional): The input to use + with the specified model. + + Returns: + *tensor*: A tensor containing the expanded weights in the form of: + (output channels, input channels, y, x) """ activations = collect_activations(model, [target1, target2], model_input) diff --git a/tests/optim/core/test_output_hook.py b/tests/optim/core/test_output_hook.py index 6bf8e68bd3..1524c25871 100644 --- a/tests/optim/core/test_output_hook.py +++ b/tests/optim/core/test_output_hook.py @@ -15,14 +15,13 @@ def test_activation_fetcher(self) -> None: "Skipping ActivationFetcher test due to insufficient Torch version." ) model = googlenet(pretrained=True) - try: - catch_activ = output_hook.ActivationFetcher(model, targets=[model.mixed4d]) - activ_out = catch_activ(torch.zeros(1, 3, 224, 224)) - self.assertIsInstance(activ_out, dict) - test = True - except Exception: - test = False - self.assertTrue(test) + + catch_activ = output_hook.ActivationFetcher(model, targets=[model.mixed4d]) + activ_out = catch_activ(torch.zeros(1, 3, 224, 224)) + + self.assertIsInstance(activ_out, dict) + m4d_activ = activ_out[model.mixed4d] + self.assertEqual(list(m4d_activ.shape), [1, 528, 14, 14]) if __name__ == "__main__": diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index 83e63d9559..26552caeee 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -341,15 +341,14 @@ def test_collect_activations(self) -> None: "Skipping collect_activations test due to insufficient Torch version." ) model = googlenet(pretrained=True) - try: - activ_out = model_utils.collect_activations( - model, [model.mixed4d], torch.zeros(1, 3, 224, 224) - ) - self.assertIsInstance(activ_out, dict) - test = True - except Exception: - test = False - self.assertTrue(test) + + activ_out = model_utils.collect_activations( + model, [model.mixed4d], torch.zeros(1, 3, 224, 224) + ) + + self.assertIsInstance(activ_out, dict) + m4d_activ = activ_out[model.mixed4d] + self.assertEqual(list(m4d_activ.shape), [1, 528, 14, 14]) if __name__ == "__main__": diff --git a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb index f4fd67ce8e..a5f2992edb 100644 --- a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb +++ b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb @@ -820,7 +820,7 @@ " colors=[\"0571b0\", \"92c5de\", \"f7f7f7\", \"f4a582\", \"ca0020\"],\r\n", ") -> torch.Tensor:\r\n", " \"\"\"\r\n", - " Create a color heatmap of an input tensor\r\n", + " Create a color heatmap of an input tensor.\r\n", " \"\"\"\r\n", "\r\n", " assert len(colors) == 5\r\n", @@ -872,18 +872,15 @@ " image().show()\r\n", "\r\n", "\r\n", - "def vis_multi(model, target, channel, vec=None) -> None:\r\n", + "def vis_multi(model, target, channel) -> None:\r\n", " image = optimviz.images.NaturalImage((60,60)).to(device)\r\n", - " if vec is not None:\r\n", - " loss_fn = optimviz.loss.Direction(target, vec)\r\n", - " else:\r\n", - " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", + " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", " transforms = torch.nn.Sequential(optimviz.transform.RandomSpatialJitter(1)) \r\n", " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", " history = obj.optimize(optimviz.objectives.n_steps(128, False))\r\n", " return image()._t" ], - "execution_count": 75, + "execution_count": null, "outputs": [] }, { @@ -894,7 +891,7 @@ "source": [ "## Extracting expanded weights\r\n", "\r\n", - "We can extract expanded weights with Captum.optim's get_expanded_weights function.\r\n", + "We can extract expanded weights with Captum.optim's `get_expanded_weights` function.\r\n", "\r\n", "Below we extract the 5 by 5 expanded weights from between the mixed3a and mixed3b layers. The output tensor is in the form of / has a shape of: `[output channels, input channels, y, x]`" ] @@ -918,7 +915,9 @@ "source": [ "# Visualizing expanded weights\r\n", "\r\n", - "We can visualize our newly collected expanded weights for channel 147 of mixed3a and channel 379 of mixed3b like so:" + "To make it easier to understand what we are seeing, we can create a heatmap where the color red is used to show excitatory parts of the weights, and blue is used to show inhibitory parts of the weights.\r\n", + "\r\n", + "By using our heatmap, we can visualize our newly collected expanded weights for channel 147 of mixed3a and channel 379 of mixed3b like so:" ] }, { @@ -935,7 +934,7 @@ "W_3a_3b_hm = tensor_heatmap(W_3a_3b[379, 147, ...] / W_3a_3b[379, ...].max())\r\n", "show(W_3a_3b_hm)" ], - "execution_count": 9, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -958,7 +957,7 @@ "id": "mYPv8ncH1V8x" }, "source": [ - "By looking at the weights above, we can see how the the following two curve dectector neurons are connected to each other." + "By looking at the weights above, we can see how the the following two curve detector neurons are connected to each other." ] }, { @@ -1077,7 +1076,7 @@ "source": [ "# NMF Visualizations of expanded weights\r\n", "\r\n", - "NMF and other dimensionality reduction alorgrithms can reveal the spaital structure of weights." + "Non-negative matrix factorization (NMF) and other dimensionality reduction algorithms can be used to reveal the spaital structure of weights. Below we use onesided NMF dimensionality reduction to collapse the input channels down to 3 dimensions so that we can view them as an RGB image. To make the NMF dimensionality reduction be one-sided, we apply Captum.optim's `posneg` function to make all values in the input positive." ] }, { @@ -1093,13 +1092,14 @@ "source": [ "reducer = optimviz.reducer.ChannelReducer(3, \"NMF\")\r\n", "\r\n", + "# Make the input positive for one-side NMF\r\n", "W_3a_3b_posneg = optimviz.reducer.posneg(W_3a_3b, dim=1)\r\n", "\r\n", "W_nmf = reducer.fit_transform(W_3a_3b_posneg[320, ...])\r\n", "W_nmf = W_nmf / W_nmf.max()\r\n", "show(W_nmf)" ], - "execution_count": 26, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -1227,7 +1227,7 @@ "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", "show(grid_img)" ], - "execution_count": 27, + "execution_count": null, "outputs": [ { "output_type": "display_data", @@ -1263,7 +1263,7 @@ "id": "CgumXN3krbpu" }, "source": [ - "NMF can also be used to describe multiple related neurons with a small number of factors. Below we demonstrate this with high-low frequency detectors. The weights have one side corrresponding to high frequency and another to low." + "One-sided NMF dimensionality reduction can also be used to describe multiple related neurons with a small number of factors. Below we demonstrate this with high-low frequency detectors. The weights have one side corrresponding to high frequency and another to low." ] }, { @@ -1290,11 +1290,14 @@ "source": [ "highlow_units = [110, 180, 153, 106, 112, 186, 132, 136, 117, 113, 108, 70, 86, 88, 160]\r\n", "\r\n", + "# Extract the units that we want to view\r\n", "W_hl = W_p2_3a[highlow_units, ...]\r\n", + "\r\n", + "# Make the input positive for one-side NMF\r\n", "W_posneg = optimviz.reducer.posneg(W_hl, dim=0)\r\n", "\r\n", "reducer = optimviz.reducer.ChannelReducer(2, \"NMF\")\r\n", - "W_nmf = reducer.fit_transform(W_posneg, reshape=True)\r\n", + "W_nmf = reducer.fit_transform(W_posneg)\r\n", "\r\n", "W_nmf = W_nmf / W_nmf.max()\r\n", "W_nmf = W_nmf[:len(highlow_units)] - W_nmf[len(highlow_units):]\r\n", @@ -1315,7 +1318,7 @@ "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", "show(grid_img)" ], - "execution_count": 77, + "execution_count": null, "outputs": [ { "output_type": "display_data", From eae361df99c710ae8a73efb55d50f3179dae6a5f Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 08:59:39 -0700 Subject: [PATCH 54/76] Fix flake8 error --- captum/optim/_utils/circuits.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index ffe977e92a..9c9fd6cdcf 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -24,13 +24,14 @@ def get_expanded_weights( Args: model: PyTorch model instance. - target1 (nn.module): The starting target. Must be below the layer specified for target2. - target2 (nn.module): The end target. Must be above the layer specified for target1. + target1 (nn.module): The starting target layer. Must be below the layer + specified for target2. + target2 (nn.module): The end target layer. Must be above the layer + specified for target1. crop_shape (int or tuple of ints, optional): Specify the output weight size to enter crop away padding. model_input (tensor or tuple of tensors, optional): The input to use with the specified model. - Returns: *tensor*: A tensor containing the expanded weights in the form of: (output channels, input channels, y, x) From 51886e1805925717c0515e37b18a547f8abdd99d Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 09:16:06 -0700 Subject: [PATCH 55/76] Cast outputs to avoid Mypy error --- tests/optim/core/test_output_hook.py | 3 ++- tests/optim/utils/test_model_utils.py | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/tests/optim/core/test_output_hook.py b/tests/optim/core/test_output_hook.py index 1524c25871..ad289172fa 100644 --- a/tests/optim/core/test_output_hook.py +++ b/tests/optim/core/test_output_hook.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 import unittest +from typing import cast import torch @@ -21,7 +22,7 @@ def test_activation_fetcher(self) -> None: self.assertIsInstance(activ_out, dict) m4d_activ = activ_out[model.mixed4d] - self.assertEqual(list(m4d_activ.shape), [1, 528, 14, 14]) + self.assertEqual(list(cast(torch.Tensor, m4d_activ).shape), [1, 528, 14, 14]) if __name__ == "__main__": diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index 26552caeee..dc8025e5c9 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 import unittest +from typing import cast import numpy as np import torch @@ -348,7 +349,7 @@ def test_collect_activations(self) -> None: self.assertIsInstance(activ_out, dict) m4d_activ = activ_out[model.mixed4d] - self.assertEqual(list(m4d_activ.shape), [1, 528, 14, 14]) + self.assertEqual(list(cast(torch.Tensor, m4d_activ).shape), [1, 528, 14, 14]) if __name__ == "__main__": From b828cbcbf877ffe5da9e091a381650720f6d9a0b Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 11:18:50 -0700 Subject: [PATCH 56/76] Third batch of changes based on feedback --- captum/optim/_utils/circuits.py | 48 ++++++++++++++++- tests/optim/helpers/numpy_circuits.py | 45 ++++++++++++++++ tests/optim/utils/test_circuits.py | 44 ++++++++++++++- .../WeightVisualization_OptimViz.ipynb | 54 +++---------------- 4 files changed, 141 insertions(+), 50 deletions(-) create mode 100644 tests/optim/helpers/numpy_circuits.py diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index 9c9fd6cdcf..b104c7a1f0 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -1,4 +1,4 @@ -from typing import Optional +from typing import List, Optional import torch import torch.nn as nn @@ -34,7 +34,7 @@ def get_expanded_weights( with the specified model. Returns: *tensor*: A tensor containing the expanded weights in the form of: - (output channels, input channels, y, x) + (target2 output channels, target1 output channels, y, x) """ activations = collect_activations(model, [target1, target2], model_input) @@ -61,3 +61,47 @@ def get_expanded_weights( if crop_shape is not None: exapnded_weights = center_crop_shape(exapnded_weights, crop_shape) return exapnded_weights + + +def tensor_heatmap( + tensor: torch.Tensor, + colors: List[str] = ["0571b0", "92c5de", "f7f7f7", "f4a582", "ca0020"], +) -> torch.Tensor: + """ + Create a color heatmap of an input weight tensor. + By default red represents excitatory values, + blue represents inhibitory values, and white represents + no excitation or inhibition. + """ + + assert tensor.dim() == 2 + assert len(colors) == 5 + + def get_color(x: str) -> torch.Tensor: + def hex2base10(x: str) -> float: + return int(x, 16) / 255.0 + + return torch.tensor( + [hex2base10(x[0:2]), hex2base10(x[2:4]), hex2base10(x[4:6])] + ) + + def color_scale(x: torch.Tensor) -> torch.Tensor: + if x < 0: + x = -x + if x < 0.5: + x = x * 2 + return (1 - x) * get_color(colors[2]) + x * get_color(colors[1]) + else: + x = (x - 0.5) * 2 + return (1 - x) * get_color(colors[1]) + x * get_color(colors[0]) + else: + if x < 0.5: + x = x * 2 + return (1 - x) * get_color(colors[2]) + x * get_color(colors[3]) + else: + x = (x - 0.5) * 2 + return (1 - x) * get_color(colors[3]) + x * get_color(colors[4]) + + return torch.stack( + [torch.stack([color_scale(x) for x in t]) for t in tensor] + ).permute(2, 0, 1) diff --git a/tests/optim/helpers/numpy_circuits.py b/tests/optim/helpers/numpy_circuits.py new file mode 100644 index 0000000000..225dccc1e6 --- /dev/null +++ b/tests/optim/helpers/numpy_circuits.py @@ -0,0 +1,45 @@ +from typing import List + +import numpy as np + + +def array_heatmap( + array: np.ndarray, + colors: List[str] = ["0571b0", "92c5de", "f7f7f7", "f4a582", "ca0020"], +) -> np.ndarray: + """ + Create a color heatmap of an input weight array. + By default red represents excitatory values, + blue represents inhibitory values, and white represents + no excitation or inhibition. + """ + + assert array.ndim == 2 + assert len(colors) == 5 + + def get_color(x: str) -> np.ndarray: + def hex2base10(x: str) -> float: + return int(x, 16) / 255.0 + + return np.array([hex2base10(x[0:2]), hex2base10(x[2:4]), hex2base10(x[4:6])]) + + def color_scale(x: np.ndarray) -> np.ndarray: + if x < 0: + x = -x + if x < 0.5: + x = x * 2 + return (1 - x) * get_color(colors[2]) + x * get_color(colors[1]) + else: + x = (x - 0.5) * 2 + return (1 - x) * get_color(colors[1]) + x * get_color(colors[0]) + else: + if x < 0.5: + x = x * 2 + return (1 - x) * get_color(colors[2]) + x * get_color(colors[3]) + else: + x = (x - 0.5) * 2 + return (1 - x) * get_color(colors[3]) + x * get_color(colors[4]) + + return np.stack([np.stack([color_scale(x) for x in a]) for a in array]).transpose( + 2, 0, 1 + ) diff --git a/tests/optim/utils/test_circuits.py b/tests/optim/utils/test_circuits.py index aef375e52d..dccdbbd8e8 100644 --- a/tests/optim/utils/test_circuits.py +++ b/tests/optim/utils/test_circuits.py @@ -5,7 +5,8 @@ import captum.optim._utils.circuits as circuits from captum.optim._models.inception_v1 import googlenet -from tests.helpers.basic import BaseTest +from tests.helpers.basic import BaseTest, assertTensorAlmostEqual +from tests.optim.helpers import numpy_circuits class TestGetExpandedWeights(BaseTest): @@ -16,9 +17,48 @@ def test_get_expanded_weights(self) -> None: ) model = googlenet(pretrained=True) output_tensor = circuits.get_expanded_weights( - model, model.mixed4c, model.mixed4d + model, model.mixed3a, model.mixed3b ) self.assertTrue(torch.is_tensor(output_tensor)) + self.assertEqual(list(output_tensor.shape), [480, 256, 28, 28]) + + def test_get_expanded_weights_crop_int(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping get_expanded_weights crop test due to insufficient Torch" + + " version." + ) + model = googlenet(pretrained=True) + output_tensor = circuits.get_expanded_weights( + model, model.mixed3a, model.mixed3b, 5 + ) + self.assertEqual(list(output_tensor.shape), [480, 256, 5, 5]) + + def test_get_expanded_weights_crop_two_int(self) -> None: + if torch.__version__ == "1.2.0": + raise unittest.SkipTest( + "Skipping get_expanded_weights two int crop test due to insufficient" + + " Torch version." + ) + model = googlenet(pretrained=True) + output_tensor = circuits.get_expanded_weights( + model, model.mixed3a, model.mixed3b, (5, 5) + ) + self.assertEqual(list(output_tensor.shape), [480, 256, 5, 5]) + + +class TestHeatMap(BaseTest): + def test_heatmap(self) -> None: + x = torch.ones(5, 4) + x[0:1, 0:4] = 0.2 + x[1:2, 0:4] = 0.8 + x[2:3, 0:4] = 0.0 + x[3:4, 0:4] = -0.2 + x[4:5, 0:4] = -0.8 + + x_out = circuits.tensor_heatmap(x) + x_out_np = numpy_circuits.array_heatmap(x.numpy()) + assertTensorAlmostEqual(self, x_out, torch.as_tensor(x_out_np)) if __name__ == "__main__": diff --git a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb index a5f2992edb..f00dd35bd5 100644 --- a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb +++ b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb @@ -815,44 +815,6 @@ " plt.show()\r\n", "\r\n", "\r\n", - "def tensor_heatmap(\r\n", - " tensor: torch.Tensor,\r\n", - " colors=[\"0571b0\", \"92c5de\", \"f7f7f7\", \"f4a582\", \"ca0020\"],\r\n", - ") -> torch.Tensor:\r\n", - " \"\"\"\r\n", - " Create a color heatmap of an input tensor.\r\n", - " \"\"\"\r\n", - "\r\n", - " assert len(colors) == 5\r\n", - "\r\n", - " def get_color(x: str) -> torch.Tensor:\r\n", - " def hex2base10(x: str) -> float:\r\n", - " return int(x, 16) / 255.0\r\n", - "\r\n", - " return torch.tensor(\r\n", - " [hex2base10(x[0:2]), hex2base10(x[2:4]), hex2base10(x[4:6])]\r\n", - " )\r\n", - "\r\n", - " def color_scale(x: torch.Tensor) -> torch.Tensor:\r\n", - " if x < 0:\r\n", - " x = -x\r\n", - " if x < 0.5:\r\n", - " x = x * 2\r\n", - " return (1 - x) * get_color(colors[2]) + x * get_color(colors[1])\r\n", - " else:\r\n", - " x = (x - 0.5) * 2\r\n", - " return (1 - x) * get_color(colors[1]) + x * get_color(colors[0])\r\n", - " else:\r\n", - " if x < 0.5:\r\n", - " x = x * 2\r\n", - " return (1 - x) * get_color(colors[2]) + x * get_color(colors[3])\r\n", - " else:\r\n", - " x = (x - 0.5) * 2\r\n", - " return (1 - x) * get_color(colors[3]) + x * get_color(colors[4])\r\n", - "\r\n", - " return torch.stack([torch.stack([color_scale(x) for x in t]) for t in tensor]).permute(2, 0, 1)\r\n", - "\r\n", - "\r\n", "def visualize_activations(model, target, channel: int, neuron=True) -> None:\r\n", " image = optimviz.images.NaturalImage((224, 224)).to(device)\r\n", " transforms = torch.nn.Sequential(\r\n", @@ -872,7 +834,7 @@ " image().show()\r\n", "\r\n", "\r\n", - "def vis_multi(model, target, channel) -> None:\r\n", + "def vis_multi(model, target, channel: int) -> None:\r\n", " image = optimviz.images.NaturalImage((60,60)).to(device)\r\n", " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", " transforms = torch.nn.Sequential(optimviz.transform.RandomSpatialJitter(1)) \r\n", @@ -893,7 +855,7 @@ "\r\n", "We can extract expanded weights with Captum.optim's `get_expanded_weights` function.\r\n", "\r\n", - "Below we extract the 5 by 5 expanded weights from between the mixed3a and mixed3b layers. The output tensor is in the form of / has a shape of: `[output channels, input channels, y, x]`" + "Below we extract the 5 by 5 expanded weights from between the mixed3a and mixed3b layers. The output tensor is in the form of / has a shape of: `[target2 output channels, target1 output channels, y, x]`" ] }, { @@ -915,7 +877,7 @@ "source": [ "# Visualizing expanded weights\r\n", "\r\n", - "To make it easier to understand what we are seeing, we can create a heatmap where the color red is used to show excitatory parts of the weights, and blue is used to show inhibitory parts of the weights.\r\n", + "To make it easier to understand what we are seeing, we can create a heatmap using Captum.optim's `tensor_heatmap` function. The `tensor_heatmap` function will by default use the color red to show excitatory parts of the weights, blue for inhibitory parts of the weights, and white for no excitation or inhibition.\r\n", "\r\n", "By using our heatmap, we can visualize our newly collected expanded weights for channel 147 of mixed3a and channel 379 of mixed3b like so:" ] @@ -931,7 +893,7 @@ "outputId": "ac0bee4a-7bbd-423d-dd92-279a13af4b05" }, "source": [ - "W_3a_3b_hm = tensor_heatmap(W_3a_3b[379, 147, ...] / W_3a_3b[379, ...].max())\r\n", + "W_3a_3b_hm = optimviz.circuits.tensor_heatmap(W_3a_3b[379, 147, ...] / W_3a_3b[379, ...].max())\r\n", "show(W_3a_3b_hm)" ], "execution_count": null, @@ -1076,7 +1038,7 @@ "source": [ "# NMF Visualizations of expanded weights\r\n", "\r\n", - "Non-negative matrix factorization (NMF) and other dimensionality reduction algorithms can be used to reveal the spaital structure of weights. Below we use onesided NMF dimensionality reduction to collapse the input channels down to 3 dimensions so that we can view them as an RGB image. To make the NMF dimensionality reduction be one-sided, we apply Captum.optim's `posneg` function to make all values in the input positive." + "Non-negative matrix factorization (NMF) and other dimensionality reduction algorithms can be used to reveal the spaital structure of weights. Below we use one-sided NMF dimensionality reduction to collapse the input channels down to 3 dimensions so that we can view them as an RGB image. To make the NMF dimensionality reduction be one-sided, we apply Captum.optim's `posneg` function to make all values in the input positive." ] }, { @@ -1092,7 +1054,7 @@ "source": [ "reducer = optimviz.reducer.ChannelReducer(3, \"NMF\")\r\n", "\r\n", - "# Make the input positive for one-side NMF\r\n", + "# Make the input positive for one-sided NMF\r\n", "W_3a_3b_posneg = optimviz.reducer.posneg(W_3a_3b, dim=1)\r\n", "\r\n", "W_nmf = reducer.fit_transform(W_3a_3b_posneg[320, ...])\r\n", @@ -1293,7 +1255,7 @@ "# Extract the units that we want to view\r\n", "W_hl = W_p2_3a[highlow_units, ...]\r\n", "\r\n", - "# Make the input positive for one-side NMF\r\n", + "# Make the input positive for one-sided NMF\r\n", "W_posneg = optimviz.reducer.posneg(W_hl, dim=0)\r\n", "\r\n", "reducer = optimviz.reducer.ChannelReducer(2, \"NMF\")\r\n", @@ -1312,7 +1274,7 @@ "\r\n", "A = []\r\n", "for i in range(len(highlow_units)):\r\n", - " W_x = tensor_heatmap(W_nmf[i, 0, ...] / W_nmf[i, 0, ...].max())\r\n", + " W_x = optimviz.circuits.tensor_heatmap(W_nmf[i, 0, ...] / W_nmf[i, 0, ...].max())\r\n", " A.append(W_x)\r\n", "\r\n", "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", From 123e70a73a3616c6b258c58fc5fc24db60a2e9e2 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 11:36:57 -0700 Subject: [PATCH 57/76] Fix lint & test errors --- captum/optim/_utils/circuits.py | 4 ++-- tests/optim/utils/test_circuits.py | 12 ++++++------ 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index b104c7a1f0..3a7e481b01 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -1,4 +1,4 @@ -from typing import List, Optional +from typing import List, Optional, Tuple, Union import torch import torch.nn as nn @@ -12,7 +12,7 @@ def get_expanded_weights( model, target1: nn.Module, target2: nn.Module, - crop_shape: Optional[TransformSize] = None, + crop_shape: Optional[Union[Tuple[int, int], TransformSize]] = None, model_input: ModelInputType = torch.zeros(1, 3, 224, 224), ) -> torch.Tensor: """ diff --git a/tests/optim/utils/test_circuits.py b/tests/optim/utils/test_circuits.py index dccdbbd8e8..efd2f1db6f 100644 --- a/tests/optim/utils/test_circuits.py +++ b/tests/optim/utils/test_circuits.py @@ -50,15 +50,15 @@ def test_get_expanded_weights_crop_two_int(self) -> None: class TestHeatMap(BaseTest): def test_heatmap(self) -> None: x = torch.ones(5, 4) - x[0:1, 0:4] = 0.2 - x[1:2, 0:4] = 0.8 - x[2:3, 0:4] = 0.0 - x[3:4, 0:4] = -0.2 - x[4:5, 0:4] = -0.8 + x[0:1, 0:4] = x[0:1, 0:4] * 0.2 + x[1:2, 0:4] = x[1:2, 0:4] * 0.8 + x[2:3, 0:4] = x[2:3, 0:4] * 0.0 + x[3:4, 0:4] = x[3:4, 0:4] * -0.2 + x[4:5, 0:4] = x[4:5, 0:4] * -0.8 x_out = circuits.tensor_heatmap(x) x_out_np = numpy_circuits.array_heatmap(x.numpy()) - assertTensorAlmostEqual(self, x_out, torch.as_tensor(x_out_np)) + assertTensorAlmostEqual(self, x_out, torch.as_tensor(x_out_np).float()) if __name__ == "__main__": From edeba3bc257c6eaaf0f750e2cb83b7aa70b1b0bf Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 13:52:06 -0700 Subject: [PATCH 58/76] Remove 'object' reference from ChannelReducer --- captum/optim/_utils/reducer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index eeba19a09d..a89400bb66 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -14,7 +14,7 @@ import torch -class ChannelReducer(object): +class ChannelReducer: """ Dimensionality reduction for the channel dimension of an input. From 859e6c47ea13d8eb9a0674fe8cfbad5919b91260 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 15:45:19 -0700 Subject: [PATCH 59/76] Replace 4D reflect pad with NumPy symmetric pad + autograd --- captum/optim/_param/image/images.py | 14 +++--- captum/optim/_param/image/transform.py | 29 +++++++++++ captum/optim/_utils/models.py | 68 -------------------------- tests/optim/param/test_transforms.py | 15 ++++++ tests/optim/utils/test_model_utils.py | 34 ------------- 5 files changed, 50 insertions(+), 110 deletions(-) diff --git a/captum/optim/_param/image/images.py b/captum/optim/_param/image/images.py index b9bab2ff1c..0cb1123b45 100755 --- a/captum/optim/_param/image/images.py +++ b/captum/optim/_param/image/images.py @@ -12,8 +12,7 @@ except (ImportError, AssertionError): print("The Pillow/PIL library is required to use Captum's Optim library") -from captum.optim._param.image.transform import ToRGB -from captum.optim._utils.models import pad_reflective_a4d +from captum.optim._param.image.transform import SymmetricPadding, ToRGB from captum.optim._utils.typing import InitSize, SquashFunc @@ -407,14 +406,13 @@ def apply_offset(self, x_list: List[torch.Tensor]) -> List[torch.Tensor]: size = list(x.size()) offset_pad = ( - [abs(offset[0])] * 2 - + [abs(offset[1])] * 2 - + [abs(offset[2])] * 2 - + [abs(offset[3])] * 2 + [[abs(offset[0])] * 2] + + [[abs(offset[1])] * 2] + + [[abs(offset[2])] * 2] + + [[abs(offset[3])] * 2] ) - offset_pad.reverse() - x = pad_reflective_a4d(x, offset_pad) + x = SymmetricPadding.apply(x, offset_pad) for o, s in zip(offset, range(x.dim())): x = torch.roll(x, shifts=o, dims=s) diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index abab122d25..ee27d36eb0 100644 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -2,6 +2,7 @@ import numbers from typing import List, Optional, Sequence, Union +import numpy as np import torch import torch.nn as nn import torch.nn.functional as F @@ -367,3 +368,31 @@ def forward(self, input: torch.Tensor) -> torch.Tensor: filtered (torch.Tensor): Filtered output. """ return self.conv(input, weight=self.weight, groups=self.groups) + + +class SymmetricPadding(torch.autograd.Function): + """ + Autograd compatible symmetric padding that uses NumPy's pad function. + """ + + @staticmethod + def forward(self, x: torch.Tensor, padding) -> torch.Tensor: + self.padding = padding + x_device = x.device + x = x.cpu() + x.data = torch.as_tensor( + np.pad(x.data.numpy(), pad_width=padding, mode="symmetric") + ) + x = x.to(x_device) + return x + + @staticmethod + def backward(self, grad_output: torch.Tensor): + grad_input = grad_output.clone() + B, C, H, W = grad_input.size() + b1, b2 = self.padding[0] + c1, c2 = self.padding[1] + h1, h2 = self.padding[2] + w1, w2 = self.padding[3] + grad_input = grad_input[b1 : B - b2, c1 : C - c2, h1 : H - h2, w1 : W - w2] + return grad_input, None diff --git a/captum/optim/_utils/models.py b/captum/optim/_utils/models.py index 2926603a1a..bd5c175b75 100644 --- a/captum/optim/_utils/models.py +++ b/captum/optim/_utils/models.py @@ -156,74 +156,6 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: ) -def pad_reflective_a4d(x: torch.Tensor, padding: List[int]) -> torch.Tensor: - """ - Reflective padding for all 4 dimensions of an NCHW tensor - """ - - assert x.dim() == 4 - assert len(padding) == 8 - - if x.size(0) == 2: - assert sum(padding[6:]) == 0 - if x.size(1) == 2: - assert sum(padding[4:6]) == 0 - - # Pad batch - if x.size(0) > 2: - if padding[6] != 0: - x = torch.cat([x, x.flip([0])[1 : (padding[6] + 1)]], dim=0) - if padding[7] != 0: - x = torch.cat([x.flip([0])[-(padding[7] + 1) : -1], x], dim=0) - - elif x.size(0) == 1: - P = [] - if padding[6] != 0: - P.append( - torch.cat( - [x if (i + 1) % 2 == 0 else x.flip([0]) for i in range(padding[6])] - ) - ) - P.append(x) - if padding[7] != 0: - P.append( - torch.cat( - [x if (i + 1) % 2 == 0 else x.flip([0]) for i in range(padding[7])] - ) - ) - x = torch.cat(P) - - # Pad channels - if x.size(1) > 2: - if padding[4] != 0: - x = torch.cat([x, x.flip([1])[:, 1 : (padding[4] + 1)]], dim=1) - if padding[5] != 0: - x = torch.cat([x.flip([1])[:, -(padding[5] + 1) : -1], x], dim=1) - - elif x.size(1) == 1: - P = [] - if padding[4] != 0: - P.append( - torch.cat( - [x if (i + 1) % 2 == 0 else x.flip([1]) for i in range(padding[4])], - dim=1, - ) - ) - P.append(x) - if padding[5] != 0: - P.append( - torch.cat( - [x if (i + 1) % 2 == 0 else x.flip([1]) for i in range(padding[5])], - dim=1, - ) - ) - x = torch.cat(P, dim=1) - - # Pad height and width - x = torch.nn.functional.pad(x, padding[:4], "reflect") - return x - - def collect_activations( model, targets: Union[nn.Module, List[nn.Module]], diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index e6243d263d..9e1bb5ae6f 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -377,5 +377,20 @@ def test_rgb_to_bgr(self) -> None: assertTensorAlmostEqual(self, output_tensor, expected_x) +class TestSymmetricPadding(BaseTest): + def test_symmetric_padding(self) -> None: + b = 2 + c = 3 + x = torch.arange(0, b * c * 4 * 4).view(b, c, 4, 4).float() + offset_pad = [[3, 3], [4, 4], [2, 2], [5, 5]] + + x_pt = torch.nn.Parameter(x) + x_out = transform.SymmetricPadding.apply(x_pt, offset_pad) + x_out_np = torch.as_tensor( + np.pad(x.detach().numpy(), pad_width=offset_pad, mode="symmetric") + ) + assertTensorAlmostEqual(self, x_out, x_out_np) + + if __name__ == "__main__": unittest.main() diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index dc8025e5c9..fe6069a688 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -11,40 +11,6 @@ from tests.helpers.basic import BaseTest, assertTensorAlmostEqual -class TestPadReflectiveA4D(BaseTest): - def test_pad_reflective_a4d_b1_c1(self) -> None: - b = 1 - c = 1 - x = torch.arange(0, b * c * 4 * 4).view(b, c, 4, 4).float() - padding = [2] * 8 - - x_out = model_utils.pad_reflective_a4d(x, padding) - x_out_np = torch.as_tensor(np.pad(x.numpy(), (2), mode="reflect")) - - assertTensorAlmostEqual(self, x_out, x_out_np) - - def test_pad_reflective_a4d_b3_c3(self) -> None: - b = 3 - c = 3 - x = torch.arange(0, b * c * 4 * 4).view(b, c, 4, 4).float() - padding = [2] * 8 - - x_out = model_utils.pad_reflective_a4d(x, padding) - x_out_np = torch.as_tensor(np.pad(x.numpy(), (2), mode="reflect")) - - assertTensorAlmostEqual(self, x_out, x_out_np) - - def test_pad_reflective_a4d_zeros(self) -> None: - b = 1 - c = 3 - x = torch.arange(0, b * c * 4 * 4).view(b, c, 4, 4).float() - padding = [0] * 8 - - x_out = model_utils.pad_reflective_a4d(x, padding) - - assertTensorAlmostEqual(self, x_out, x) - - class TestConv2dSame(BaseTest): def test_conv2d_same(self) -> None: x = torch.ones(64, 32, 100, 20) From c3dafad00bdd72ac53c4dbb24bdc6297c814f1cc Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 15:49:42 -0700 Subject: [PATCH 60/76] Remove NumPy import --- tests/optim/utils/test_model_utils.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/optim/utils/test_model_utils.py b/tests/optim/utils/test_model_utils.py index fe6069a688..1290de9d29 100644 --- a/tests/optim/utils/test_model_utils.py +++ b/tests/optim/utils/test_model_utils.py @@ -2,7 +2,6 @@ import unittest from typing import cast -import numpy as np import torch import torch.nn.functional as F From ff63e1d4a703554e0e3ff8ad54bf24f73142e479 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 15:54:32 -0700 Subject: [PATCH 61/76] Remove old function import --- tests/optim/param/test_images.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/optim/param/test_images.py b/tests/optim/param/test_images.py index c8b9984aac..f2d1ee1cac 100644 --- a/tests/optim/param/test_images.py +++ b/tests/optim/param/test_images.py @@ -6,7 +6,6 @@ import torch from captum.optim._param.image import images -from captum.optim._utils.models import pad_reflective_a4d from tests.helpers.basic import ( BaseTest, assertArraysAlmostEqual, From 80c0e8f61309aef241a22819824b6e5a2ba021e7 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 15:57:10 -0700 Subject: [PATCH 62/76] Update offset test code --- tests/optim/param/test_images.py | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/tests/optim/param/test_images.py b/tests/optim/param/test_images.py index f2d1ee1cac..15d70eb978 100644 --- a/tests/optim/param/test_images.py +++ b/tests/optim/param/test_images.py @@ -6,6 +6,7 @@ import torch from captum.optim._param.image import images +from captum.optim._param.image.transform import SymmetricPadding from tests.helpers.basic import ( BaseTest, assertArraysAlmostEqual, @@ -336,16 +337,17 @@ def apply_offset_compare( ) -> List[torch.Tensor]: A = [] for x, offset in zip(x_list, offset_list): + assert x.dim() == 4 size = list(x.size()) + offset_pad = ( - [abs(offset[0])] * 2 - + [abs(offset[1])] * 2 - + [abs(offset[2])] * 2 - + [abs(offset[3])] * 2 + [[abs(offset[0])] * 2] + + [[abs(offset[1])] * 2] + + [[abs(offset[2])] * 2] + + [[abs(offset[3])] * 2] ) - offset_pad.reverse() - x = pad_reflective_a4d(x, offset_pad) + x = SymmetricPadding.apply(x, offset_pad) for o, s in zip(offset, range(x.dim())): x = torch.roll(x, shifts=o, dims=s) From c8c10dcacb970f60789afc10aa8b31d101748b82 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 18:00:49 -0700 Subject: [PATCH 63/76] Reorganize utils --- captum/optim/_core/loss.py | 2 +- captum/optim/_utils/circuits.py | 46 +------ captum/optim/_utils/image/__init__.py | 1 + captum/optim/_utils/image/common.py | 124 ++++++++++++++++++ .../{image_dataset.py => image/dataset.py} | 0 captum/optim/_utils/images.py | 18 --- captum/optim/_utils/reducer.py | 61 --------- .../{numpy_circuits.py => numpy_common.py} | 0 tests/optim/utils/image/__init__.py | 1 + tests/optim/utils/image/common.py | 68 ++++++++++ .../dataset.py} | 2 +- tests/optim/utils/test_circuits.py | 17 +-- tests/optim/utils/test_images_utils.py | 38 ------ tests/optim/utils/test_reducer.py | 12 -- 14 files changed, 198 insertions(+), 192 deletions(-) create mode 100644 captum/optim/_utils/image/__init__.py create mode 100644 captum/optim/_utils/image/common.py rename captum/optim/_utils/{image_dataset.py => image/dataset.py} (100%) delete mode 100644 captum/optim/_utils/images.py rename tests/optim/helpers/{numpy_circuits.py => numpy_common.py} (100%) create mode 100644 tests/optim/utils/image/__init__.py create mode 100644 tests/optim/utils/image/common.py rename tests/optim/utils/{test_image_dataset_utils.py => image/dataset.py} (95%) delete mode 100644 tests/optim/utils/test_images_utils.py diff --git a/captum/optim/_core/loss.py b/captum/optim/_core/loss.py index 281e50fe43..138a6da15c 100644 --- a/captum/optim/_core/loss.py +++ b/captum/optim/_core/loss.py @@ -4,7 +4,7 @@ import torch import torch.nn as nn -from captum.optim._utils.images import get_neuron_pos +from captum.optim._utils.image.common import get_neuron_pos from captum.optim._utils.typing import ModuleOutputMapping diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index 3a7e481b01..9e7fa2244a 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -1,4 +1,4 @@ -from typing import List, Optional, Tuple, Union +from typing import Optional, Tuple, Union import torch import torch.nn as nn @@ -61,47 +61,3 @@ def get_expanded_weights( if crop_shape is not None: exapnded_weights = center_crop_shape(exapnded_weights, crop_shape) return exapnded_weights - - -def tensor_heatmap( - tensor: torch.Tensor, - colors: List[str] = ["0571b0", "92c5de", "f7f7f7", "f4a582", "ca0020"], -) -> torch.Tensor: - """ - Create a color heatmap of an input weight tensor. - By default red represents excitatory values, - blue represents inhibitory values, and white represents - no excitation or inhibition. - """ - - assert tensor.dim() == 2 - assert len(colors) == 5 - - def get_color(x: str) -> torch.Tensor: - def hex2base10(x: str) -> float: - return int(x, 16) / 255.0 - - return torch.tensor( - [hex2base10(x[0:2]), hex2base10(x[2:4]), hex2base10(x[4:6])] - ) - - def color_scale(x: torch.Tensor) -> torch.Tensor: - if x < 0: - x = -x - if x < 0.5: - x = x * 2 - return (1 - x) * get_color(colors[2]) + x * get_color(colors[1]) - else: - x = (x - 0.5) * 2 - return (1 - x) * get_color(colors[1]) + x * get_color(colors[0]) - else: - if x < 0.5: - x = x * 2 - return (1 - x) * get_color(colors[2]) + x * get_color(colors[3]) - else: - x = (x - 0.5) * 2 - return (1 - x) * get_color(colors[3]) + x * get_color(colors[4]) - - return torch.stack( - [torch.stack([color_scale(x) for x in t]) for t in tensor] - ).permute(2, 0, 1) diff --git a/captum/optim/_utils/image/__init__.py b/captum/optim/_utils/image/__init__.py new file mode 100644 index 0000000000..902f5cb2bd --- /dev/null +++ b/captum/optim/_utils/image/__init__.py @@ -0,0 +1 @@ +# Image utils diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py new file mode 100644 index 0000000000..16baff2ef0 --- /dev/null +++ b/captum/optim/_utils/image/common.py @@ -0,0 +1,124 @@ +from typing import List, Optional, Tuple + +import torch + +def get_neuron_pos( + H: int, W: int, x: Optional[int] = None, y: Optional[int] = None +) -> Tuple[int, int]: + if x is None: + _x = W // 2 + else: + assert x < W + _x = x + + if y is None: + _y = H // 2 + else: + assert y < H + _y = y + return _x, _y + + +def nchannels_to_rgb(x: torch.Tensor, warp: bool = True) -> torch.Tensor: + """ + Convert an NCHW image with n channels into a 3 channel RGB image. + + Args: + x (torch.Tensor): Image tensor to transform into RGB image. + warp (bool, optional): Whether or not to make colors more distinguishable. + Default: True + Returns: + *tensor* RGB image + """ + + def hue_to_rgb(angle: float) -> torch.Tensor: + """ + Create an RGB unit vector based on a hue of the input angle. + """ + + angle = angle - 360 * (angle // 360) + colors = torch.tensor( + [ + [1.0, 0.0, 0.0], + [0.7071, 0.7071, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.7071, 0.7071], + [0.0, 0.0, 1.0], + [0.7071, 0.0, 0.7071], + ] + ) + + idx = math.floor(angle / 60) + d = (angle - idx * 60) / 60 + + if warp: + + def adj(x: float) -> float: + return math.sin(x * math.pi / 2) + + d = adj(d) if idx % 2 == 0 else 1 - adj(1 - d) + + vec = (1 - d) * colors[idx] + d * colors[(idx + 1) % 6] + return vec / torch.norm(vec) + + assert x.dim() == 4 + + if (x < 0).any(): + x = posneg(x.permute(0, 2, 3, 1), -1).permute(0, 3, 1, 2) + + rgb = torch.zeros(1, 3, x.size(2), x.size(3), device=x.device) + nc = x.size(1) + for i in range(nc): + rgb = rgb + x[:, i][:, None, :, :] + rgb = rgb * hue_to_rgb(360 * i / nc).to(device=x.device)[None, :, None, None] + + rgb = rgb + torch.ones(x.size(2), x.size(3))[None, None, :, :] * ( + torch.sum(x, 1)[:, None] - torch.max(x, 1)[0][:, None] + ) + return (rgb / (1e-4 + torch.norm(rgb, dim=1, keepdim=True))) * torch.norm( + x, dim=1, keepdim=True + ) + + +def tensor_heatmap( + tensor: torch.Tensor, + colors: List[str] = ["0571b0", "92c5de", "f7f7f7", "f4a582", "ca0020"], +) -> torch.Tensor: + """ + Create a color heatmap of an input weight tensor. + By default red represents excitatory values, + blue represents inhibitory values, and white represents + no excitation or inhibition. + """ + + assert tensor.dim() == 2 + assert len(colors) == 5 + + def get_color(x: str) -> torch.Tensor: + def hex2base10(x: str) -> float: + return int(x, 16) / 255.0 + + return torch.tensor( + [hex2base10(x[0:2]), hex2base10(x[2:4]), hex2base10(x[4:6])] + ) + + def color_scale(x: torch.Tensor) -> torch.Tensor: + if x < 0: + x = -x + if x < 0.5: + x = x * 2 + return (1 - x) * get_color(colors[2]) + x * get_color(colors[1]) + else: + x = (x - 0.5) * 2 + return (1 - x) * get_color(colors[1]) + x * get_color(colors[0]) + else: + if x < 0.5: + x = x * 2 + return (1 - x) * get_color(colors[2]) + x * get_color(colors[3]) + else: + x = (x - 0.5) * 2 + return (1 - x) * get_color(colors[3]) + x * get_color(colors[4]) + + return torch.stack( + [torch.stack([color_scale(x) for x in t]) for t in tensor] + ).permute(2, 0, 1) diff --git a/captum/optim/_utils/image_dataset.py b/captum/optim/_utils/image/dataset.py similarity index 100% rename from captum/optim/_utils/image_dataset.py rename to captum/optim/_utils/image/dataset.py diff --git a/captum/optim/_utils/images.py b/captum/optim/_utils/images.py deleted file mode 100644 index d785f53990..0000000000 --- a/captum/optim/_utils/images.py +++ /dev/null @@ -1,18 +0,0 @@ -from typing import Optional, Tuple - - -def get_neuron_pos( - H: int, W: int, x: Optional[int] = None, y: Optional[int] = None -) -> Tuple[int, int]: - if x is None: - _x = W // 2 - else: - assert x < W - _x = x - - if y is None: - _y = H // 2 - else: - assert y < H - _y = y - return _x, _y diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index a89400bb66..9b86f00e9c 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -129,64 +129,3 @@ def posneg(x: torch.Tensor, dim: int = 0) -> torch.Tensor: [torch.max(x, torch.full_like(x, 0)), torch.max(-x, torch.full_like(x, 0))], dim=dim, ) - - -def nchannels_to_rgb(x: torch.Tensor, warp: bool = True) -> torch.Tensor: - """ - Convert an NCHW image with n channels into a 3 channel RGB image. - - Args: - x (torch.Tensor): Image tensor to transform into RGB image. - warp (bool, optional): Whether or not to make colors more distinguishable. - Default: True - Returns: - *tensor* RGB image - """ - - def hue_to_rgb(angle: float) -> torch.Tensor: - """ - Create an RGB unit vector based on a hue of the input angle. - """ - - angle = angle - 360 * (angle // 360) - colors = torch.tensor( - [ - [1.0, 0.0, 0.0], - [0.7071, 0.7071, 0.0], - [0.0, 1.0, 0.0], - [0.0, 0.7071, 0.7071], - [0.0, 0.0, 1.0], - [0.7071, 0.0, 0.7071], - ] - ) - - idx = math.floor(angle / 60) - d = (angle - idx * 60) / 60 - - if warp: - - def adj(x: float) -> float: - return math.sin(x * math.pi / 2) - - d = adj(d) if idx % 2 == 0 else 1 - adj(1 - d) - - vec = (1 - d) * colors[idx] + d * colors[(idx + 1) % 6] - return vec / torch.norm(vec) - - assert x.dim() == 4 - - if (x < 0).any(): - x = posneg(x.permute(0, 2, 3, 1), -1).permute(0, 3, 1, 2) - - rgb = torch.zeros(1, 3, x.size(2), x.size(3), device=x.device) - nc = x.size(1) - for i in range(nc): - rgb = rgb + x[:, i][:, None, :, :] - rgb = rgb * hue_to_rgb(360 * i / nc).to(device=x.device)[None, :, None, None] - - rgb = rgb + torch.ones(x.size(2), x.size(3))[None, None, :, :] * ( - torch.sum(x, 1)[:, None] - torch.max(x, 1)[0][:, None] - ) - return (rgb / (1e-4 + torch.norm(rgb, dim=1, keepdim=True))) * torch.norm( - x, dim=1, keepdim=True - ) diff --git a/tests/optim/helpers/numpy_circuits.py b/tests/optim/helpers/numpy_common.py similarity index 100% rename from tests/optim/helpers/numpy_circuits.py rename to tests/optim/helpers/numpy_common.py diff --git a/tests/optim/utils/image/__init__.py b/tests/optim/utils/image/__init__.py new file mode 100644 index 0000000000..0e2d9a3a8e --- /dev/null +++ b/tests/optim/utils/image/__init__.py @@ -0,0 +1 @@ +# Image utils tests diff --git a/tests/optim/utils/image/common.py b/tests/optim/utils/image/common.py new file mode 100644 index 0000000000..abb0d44402 --- /dev/null +++ b/tests/optim/utils/image/common.py @@ -0,0 +1,68 @@ +#!/usr/bin/env python3 +import unittest + +import torch + +import captum.optim._utils.image.common as common +from tests.helpers.basic import BaseTest, assertTensorAlmostEqual +from tests.optim.helpers import numpy_common + + +class TestGetNeuronPos(unittest.TestCase): + def test_get_neuron_pos_hw(self) -> None: + W, H = 128, 128 + x, y = common.get_neuron_pos(H, W) + + self.assertEqual(x, W // 2) + self.assertEqual(y, H // 2) + + def test_get_neuron_pos_xy(self) -> None: + W, H = 128, 128 + x, y = common.get_neuron_pos(H, W, 5, 5) + + self.assertEqual(x, 5) + self.assertEqual(y, 5) + + def test_get_neuron_pos_x_none(self) -> None: + W, H = 128, 128 + x, y = common.get_neuron_pos(H, W, 5, None) + + self.assertEqual(x, 5) + self.assertEqual(y, H // 2) + + def test_get_neuron_pos_none_y(self) -> None: + W, H = 128, 128 + x, y = common.get_neuron_pos(H, W, None, 5) + + self.assertEqual(x, W // 2) + self.assertEqual(y, 5) + + +class TestNChannelsToRGB(BaseTest): + def test_nchannels_to_rgb_collapse(self) -> None: + test_input = torch.randn(1, 6, 224, 224) + test_output = common.nchannels_to_rgb(test_input) + self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) + + def test_nchannels_to_rgb_increase(self) -> None: + test_input = torch.randn(1, 2, 224, 224) + test_output = common.nchannels_to_rgb(test_input) + self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) + + +class TestHeatMap(BaseTest): + def test_heatmap(self) -> None: + x = torch.ones(5, 4) + x[0:1, 0:4] = x[0:1, 0:4] * 0.2 + x[1:2, 0:4] = x[1:2, 0:4] * 0.8 + x[2:3, 0:4] = x[2:3, 0:4] * 0.0 + x[3:4, 0:4] = x[3:4, 0:4] * -0.2 + x[4:5, 0:4] = x[4:5, 0:4] * -0.8 + + x_out = common.tensor_heatmap(x) + x_out_np = numpy_common.array_heatmap(x.numpy()) + assertTensorAlmostEqual(self, x_out, torch.as_tensor(x_out_np).float()) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/optim/utils/test_image_dataset_utils.py b/tests/optim/utils/image/dataset.py similarity index 95% rename from tests/optim/utils/test_image_dataset_utils.py rename to tests/optim/utils/image/dataset.py index 10386f2aef..d4e6f5a8ac 100644 --- a/tests/optim/utils/test_image_dataset_utils.py +++ b/tests/optim/utils/image/dataset.py @@ -3,7 +3,7 @@ import torch -import captum.optim._utils.image_dataset as dataset_utils +import captum.optim._utils.image.dataset as dataset_utils from tests.helpers.basic import ( BaseTest, assertArraysAlmostEqual, diff --git a/tests/optim/utils/test_circuits.py b/tests/optim/utils/test_circuits.py index efd2f1db6f..5e26214ea8 100644 --- a/tests/optim/utils/test_circuits.py +++ b/tests/optim/utils/test_circuits.py @@ -5,8 +5,7 @@ import captum.optim._utils.circuits as circuits from captum.optim._models.inception_v1 import googlenet -from tests.helpers.basic import BaseTest, assertTensorAlmostEqual -from tests.optim.helpers import numpy_circuits +from tests.helpers.basic import BaseTest class TestGetExpandedWeights(BaseTest): @@ -47,19 +46,5 @@ def test_get_expanded_weights_crop_two_int(self) -> None: self.assertEqual(list(output_tensor.shape), [480, 256, 5, 5]) -class TestHeatMap(BaseTest): - def test_heatmap(self) -> None: - x = torch.ones(5, 4) - x[0:1, 0:4] = x[0:1, 0:4] * 0.2 - x[1:2, 0:4] = x[1:2, 0:4] * 0.8 - x[2:3, 0:4] = x[2:3, 0:4] * 0.0 - x[3:4, 0:4] = x[3:4, 0:4] * -0.2 - x[4:5, 0:4] = x[4:5, 0:4] * -0.8 - - x_out = circuits.tensor_heatmap(x) - x_out_np = numpy_circuits.array_heatmap(x.numpy()) - assertTensorAlmostEqual(self, x_out, torch.as_tensor(x_out_np).float()) - - if __name__ == "__main__": unittest.main() diff --git a/tests/optim/utils/test_images_utils.py b/tests/optim/utils/test_images_utils.py deleted file mode 100644 index cc40b7b853..0000000000 --- a/tests/optim/utils/test_images_utils.py +++ /dev/null @@ -1,38 +0,0 @@ -#!/usr/bin/env python3 -import unittest - -from captum.optim._utils.images import get_neuron_pos - - -class TestGetNeuronPos(unittest.TestCase): - def test_get_neuron_pos_hw(self) -> None: - W, H = 128, 128 - x, y = get_neuron_pos(H, W) - - self.assertEqual(x, W // 2) - self.assertEqual(y, H // 2) - - def test_get_neuron_pos_xy(self) -> None: - W, H = 128, 128 - x, y = get_neuron_pos(H, W, 5, 5) - - self.assertEqual(x, 5) - self.assertEqual(y, 5) - - def test_get_neuron_pos_x_none(self) -> None: - W, H = 128, 128 - x, y = get_neuron_pos(H, W, 5, None) - - self.assertEqual(x, 5) - self.assertEqual(y, H // 2) - - def test_get_neuron_pos_none_y(self) -> None: - W, H = 128, 128 - x, y = get_neuron_pos(H, W, None, 5) - - self.assertEqual(x, W // 2) - self.assertEqual(y, 5) - - -if __name__ == "__main__": - unittest.main() diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py index 4cc9f5211b..c2429b46a0 100644 --- a/tests/optim/utils/test_reducer.py +++ b/tests/optim/utils/test_reducer.py @@ -144,17 +144,5 @@ def test_posneg(self) -> None: ) -class TestNChannelsToRGB(BaseTest): - def test_nchannels_to_rgb_collapse(self) -> None: - test_input = torch.randn(1, 6, 224, 224) - test_output = reducer.nchannels_to_rgb(test_input) - self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) - - def test_nchannels_to_rgb_increase(self) -> None: - test_input = torch.randn(1, 2, 224, 224) - test_output = reducer.nchannels_to_rgb(test_input) - self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) - - if __name__ == "__main__": unittest.main() From 58cefae8f44925efec4c3121dde2dc4a49a16263 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 19:05:16 -0700 Subject: [PATCH 64/76] Update transform.py --- captum/optim/_param/image/transform.py | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index ee27d36eb0..b5afcabbc2 100644 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -7,6 +7,7 @@ import torch.nn as nn import torch.nn.functional as F +from captum.optim._utils.image.common import nchannels_to_rgb from captum.optim._utils.typing import TransformSize, TransformVal, TransformValList device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") @@ -396,3 +397,17 @@ def backward(self, grad_output: torch.Tensor): w1, w2 = self.padding[3] grad_input = grad_input[b1 : B - b2, c1 : C - c2, h1 : H - h2, w1 : W - w2] return grad_input, None + + +class NChannelsToRGB(nn.Module): + """ + Convert an NCHW image with n channels into a 3 channel RGB image. + """ + + def __init__(self, warp: bool = False) -> None: + super().__init__() + self.warp = warp + + def forward(self, x: torch.Tensor) -> torch.Tensor: + assert x.dim() == 4 + return nchannels_to_rgb(x, self.warp) From dd3fd43b3dd61293eb5bf7cb13c2d9ec7d878dde Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 19:12:02 -0700 Subject: [PATCH 65/76] Update test_transforms.py --- tests/optim/param/test_transforms.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index 9e1bb5ae6f..50b0edc5a7 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -392,5 +392,19 @@ def test_symmetric_padding(self) -> None: assertTensorAlmostEqual(self, x_out, x_out_np) +class TestNChannelsToRGB(BaseTest): + def test_nchannels_to_rgb_collapse(self) -> None: + test_input = torch.randn(1, 6, 224, 224) + nchannels_to_rgb = transform.NChannelsToRGB() + test_output = nchannels_to_rgb(test_input) + self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) + + def test_nchannels_to_rgb_increase(self) -> None: + test_input = torch.randn(1, 2, 224, 224) + nchannels_to_rgb = transform.NChannelsToRGB() + test_output = nchannels_to_rgb(test_input) + self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) + + if __name__ == "__main__": unittest.main() From fb82ac4c82bb6f0897892ea7fbe154dec3e33acd Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 19:13:07 -0700 Subject: [PATCH 66/76] Changes based on feedback --- captum/optim/__init__.py | 4 + captum/optim/_utils/image/common.py | 3 + captum/optim/_utils/reducer.py | 87 ++++++++----------- tests/optim/utils/test_reducer.py | 79 +++++++++-------- .../WeightVisualization_OptimViz.ipynb | 4 +- 5 files changed, 83 insertions(+), 94 deletions(-) diff --git a/captum/optim/__init__.py b/captum/optim/__init__.py index 9d8a589fea..b8488ef462 100755 --- a/captum/optim/__init__.py +++ b/captum/optim/__init__.py @@ -7,3 +7,7 @@ from captum.optim._param.image import transform # noqa: F401 from captum.optim._param.image.images import ImageTensor # noqa: F401 from captum.optim._utils import circuits, models, reducer # noqa: F401 +from captum.optim._utils.image.common import ( # noqa: F401 + nchannels_to_rgb, # noqa: F401 + tensor_heatmap, # noqa: F401 +) diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py index 16baff2ef0..0ad8dfa579 100644 --- a/captum/optim/_utils/image/common.py +++ b/captum/optim/_utils/image/common.py @@ -1,7 +1,10 @@ +import math from typing import List, Optional, Tuple import torch +from captum.optim._utils.reducer import posneg + def get_neuron_pos( H: int, W: int, x: Optional[int] = None, y: Optional[int] = None ) -> Tuple[int, int]: diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index 9b86f00e9c..e4206c79d4 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -1,4 +1,3 @@ -import math from typing import Any, Callable, List, Union import numpy as np @@ -25,74 +24,58 @@ class ChannelReducer: def __init__( self, n_components: int = 3, reduction_alg: Any = "NMF", **kwargs ) -> None: - if not callable(reduction_alg): - algorithm_map = {} - for name in dir(sklearn.decomposition): - obj = sklearn.decomposition.__getattribute__(name) - if isinstance(obj, type) and issubclass(obj, BaseEstimator): - algorithm_map[name] = obj - if isinstance(reduction_alg, str): - if reduction_alg in algorithm_map: - reduction_alg = algorithm_map[reduction_alg] - else: - raise ValueError( - "Unknown sklearn dimensionality reduction method '%s'." - % reduction_alg - ) + if isinstance(reduction_alg, str): + reduction_alg = self._get_reduction_algo_instance(reduction_alg) + if reduction_alg is None: + raise ValueError( + "Unknown sklearn dimensionality reduction method '%s'." + % reduction_alg + ) self.n_components = n_components self._reducer = reduction_alg(n_components=n_components, **kwargs) + def _get_reduction_algo_instance(self, name: str) -> Union[None, Callable]: + if hasattr(sklearn.decomposition, name): + obj = sklearn.decomposition.__getattribute__(name) + if issubclass(obj, BaseEstimator): + return obj + return None + @classmethod def _apply_flat(cls, func: Callable, x: torch.Tensor) -> torch.Tensor: orig_shape = x.shape return func(x.reshape([-1, x.shape[-1]])).reshape(list(orig_shape[:-1]) + [-1]) def fit_transform( - self, x: Union[torch.Tensor, np.ndarray], reshape: bool = True - ) -> Union[torch.Tensor, np.ndarray]: + self, x: torch.Tensor, swap_2nd_and_last_dims: bool = True + ) -> torch.Tensor: """ Perform dimensionality reduction on an input tensor or NumPy array. + + If swap_2nd_and_last_dims is true, input channels are expected to be in the + second dimension unless the input tensor has a shape of CHW. """ - is_tensor = torch.is_tensor(x) - - if is_tensor: - if x.dim() == 3 and reshape: - x = x.permute(2, 1, 0) - elif x.dim() > 3 and reshape: - permute_vals = [0] + list(range(x.dim()))[2:] + [1] - x = x.permute(*permute_vals) - else: - if x.ndim == 3 and reshape: - x = x.transpose(2, 1, 0) - elif x.ndim > 3 and reshape: - permute_vals = [0] + list(range(x.ndim))[2:] + [1] - x = x.transpose(*permute_vals) + if x.dim() == 3 and swap_2nd_and_last_dims: + x = x.permute(2, 1, 0) + elif x.dim() > 3 and swap_2nd_and_last_dims: + permute_vals = [0] + list(range(x.dim()))[2:] + [1] + x = x.permute(*permute_vals) x_out = ChannelReducer._apply_flat(self._reducer.fit_transform, x) - if is_tensor: - x_out = torch.as_tensor(x_out, device=x.device) - if x.dim() == 3 and reshape: - x_out = x_out.permute(2, 1, 0) - elif x.dim() > 3 and reshape: - permute_vals = ( - [0] - + [x.dim() - 1] - + list(range(x.dim()))[1 : len(list(range(x.dim()))) - 1] - ) - x_out = x_out.permute(*permute_vals) - else: - if x.ndim == 3 and reshape: - x_out = x_out.permute(2, 1, 0) - elif x.ndim > 3 and reshape: - permute_vals = ( - [0] - + [x.ndim - 1] - + list(range(x.ndim))[1 : len(list(range(x.ndim))) - 1] - ) - x_out = x_out.transpose(*permute_vals) + x_out = torch.as_tensor(x_out, device=x.device) + + if x.dim() == 3 and swap_2nd_and_last_dims: + x_out = x_out.permute(2, 1, 0) + elif x.dim() > 3 and swap_2nd_and_last_dims: + permute_vals = ( + [0] + + [x.dim() - 1] + + list(range(x.dim()))[1 : len(list(range(x.dim()))) - 1] + ) + x_out = x_out.permute(*permute_vals) return x_out diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py index c2429b46a0..824f9da405 100644 --- a/tests/optim/utils/test_reducer.py +++ b/tests/optim/utils/test_reducer.py @@ -18,9 +18,9 @@ def __init__(self, n_components=3, **kwargs) -> None: self.n_components = n_components self.components_ = np.ones((2, 64)) - def fit_transform(self, x: Union[torch.Tensor, np.ndarray]) -> np.ndarray: + def fit_transform(self, x: torch.Tensor) -> np.ndarray: x = x.numpy() if torch.is_tensor(x) else x - return x[..., 0:3] + return x[:, 0:3, ...] class TestChannelReducer(BaseTest): @@ -31,13 +31,33 @@ def test_channelreducer_pytorch(self) -> None: except (ImportError, AssertionError): raise unittest.SkipTest( "Module sklearn not found, skipping ChannelReducer" - + " PyTorch reshape test" + + " PyTorch swap_2nd_and_last_dims test" ) test_input = torch.randn(1, 32, 224, 224).abs() c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) - test_output = c_reducer.fit_transform(test_input, reshape=True) + test_output = c_reducer.fit_transform(test_input) + self.assertEquals(test_output.size(0), 1) self.assertEquals(test_output.size(1), 3) + self.assertEquals(test_output.size(2), 224) + self.assertEquals(test_output.size(3), 224) + + def test_channelreducer_pytorch_dim_three(self) -> None: + try: + import sklearn # noqa: F401 + + except (ImportError, AssertionError): + raise unittest.SkipTest( + "Module sklearn not found, skipping ChannelReducer" + + " PyTorch swap_2nd_and_last_dims test" + ) + + test_input = torch.randn(32, 224, 224).abs() + c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) + test_output = c_reducer.fit_transform(test_input) + self.assertEquals(test_output.size(0), 3) + self.assertEquals(test_output.size(1), 224) + self.assertEquals(test_output.size(2), 224) def test_channelreducer_pytorch_pca(self) -> None: try: @@ -46,15 +66,18 @@ def test_channelreducer_pytorch_pca(self) -> None: except (ImportError, AssertionError): raise unittest.SkipTest( "Module sklearn not found, skipping ChannelReducer" - + " PyTorch reshape PCA test" + + " PyTorch swap_2nd_and_last_dims PCA test" ) test_input = torch.randn(1, 32, 224, 224).abs() c_reducer = reducer.ChannelReducer( n_components=3, reduction_alg="PCA", max_iter=100 ) - test_output = c_reducer.fit_transform(test_input, reshape=True) + test_output = c_reducer.fit_transform(test_input) + self.assertEquals(test_output.size(0), 1) self.assertEquals(test_output.size(1), 3) + self.assertEquals(test_output.size(2), 224) + self.assertEquals(test_output.size(3), 224) def test_channelreducer_pytorch_custom_alg(self) -> None: test_input = torch.randn(1, 32, 224, 224).abs() @@ -62,8 +85,11 @@ def test_channelreducer_pytorch_custom_alg(self) -> None: c_reducer = reducer.ChannelReducer( n_components=3, reduction_alg=reduction_alg, max_iter=100 ) - test_output = c_reducer.fit_transform(test_input, reshape=True) + test_output = c_reducer.fit_transform(test_input) + self.assertEquals(test_output.size(0), 1) self.assertEquals(test_output.size(1), 3) + self.assertEquals(test_output.size(2), 224) + self.assertEquals(test_output.size(3), 224) def test_channelreducer_pytorch_custom_alg_components(self) -> None: reduction_alg = FakeReductionAlgorithm @@ -80,31 +106,16 @@ def test_channelreducer_pytorch_components(self) -> None: except (ImportError, AssertionError): raise unittest.SkipTest( "Module sklearn not found, skipping ChannelReducer" - + " PyTorch reshape test" + + " PyTorch swap_2nd_and_last_dims test" ) test_input = torch.randn(1, 32, 224, 224).abs() c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) - test_output = c_reducer.fit_transform(test_input, reshape=True) + test_output = c_reducer.fit_transform(test_input) components = c_reducer.components self.assertTrue(torch.is_tensor(components)) self.assertTrue(torch.is_tensor(test_output)) - def test_channelreducer_numpy(self) -> None: - try: - import sklearn # noqa: F401 - - except (ImportError, AssertionError): - raise unittest.SkipTest( - "Module sklearn not found, skipping ChannelReducer" - + " NumPy reshape test" - ) - - test_input = torch.randn(1, 32, 224, 224).abs().numpy() - c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) - test_output = c_reducer.fit_transform(test_input, reshape=True) - self.assertEquals(test_output.shape[1], 3) - def test_channelreducer_noreshape_pytorch(self) -> None: try: import sklearn # noqa: F401 @@ -117,24 +128,12 @@ def test_channelreducer_noreshape_pytorch(self) -> None: test_input = torch.randn(1, 224, 224, 32).abs() c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) - test_output = c_reducer.fit_transform(test_input, reshape=False) + test_output = c_reducer.fit_transform(test_input, swap_2nd_and_last_dims=False) + self.assertEquals(test_output.size(0), 1) + self.assertEquals(test_output.size(1), 224) + self.assertEquals(test_output.size(2), 224) self.assertEquals(test_output.size(3), 3) - def test_channelreducer_noreshape_numpy(self) -> None: - try: - import sklearn # noqa: F401 - - except (ImportError, AssertionError): - raise unittest.SkipTest( - "Module sklearn not found, skipping ChannelReducer" - + " NumPy no reshape test" - ) - - test_input = torch.randn(1, 224, 224, 32).abs().numpy() - c_reducer = reducer.ChannelReducer(n_components=3, max_iter=100) - test_output = c_reducer.fit_transform(test_input, reshape=False) - self.assertEquals(test_output.shape[3], 3) - class TestPosNeg(BaseTest): def test_posneg(self) -> None: diff --git a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb index f00dd35bd5..2924927602 100644 --- a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb +++ b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb @@ -893,7 +893,7 @@ "outputId": "ac0bee4a-7bbd-423d-dd92-279a13af4b05" }, "source": [ - "W_3a_3b_hm = optimviz.circuits.tensor_heatmap(W_3a_3b[379, 147, ...] / W_3a_3b[379, ...].max())\r\n", + "W_3a_3b_hm = optimviz.tensor_heatmap(W_3a_3b[379, 147, ...] / W_3a_3b[379, ...].max())\r\n", "show(W_3a_3b_hm)" ], "execution_count": null, @@ -1274,7 +1274,7 @@ "\r\n", "A = []\r\n", "for i in range(len(highlow_units)):\r\n", - " W_x = optimviz.circuits.tensor_heatmap(W_nmf[i, 0, ...] / W_nmf[i, 0, ...].max())\r\n", + " W_x = optimviz.tensor_heatmap(W_nmf[i, 0, ...] / W_nmf[i, 0, ...].max())\r\n", " A.append(W_x)\r\n", "\r\n", "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", From 52466c9566c1c30582af802cc0fc365472ab7204 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 19:20:28 -0700 Subject: [PATCH 67/76] Fix lint errors --- captum/optim/_utils/image/common.py | 1 + tests/optim/utils/test_reducer.py | 1 - 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py index 0ad8dfa579..1e7a000f74 100644 --- a/captum/optim/_utils/image/common.py +++ b/captum/optim/_utils/image/common.py @@ -5,6 +5,7 @@ from captum.optim._utils.reducer import posneg + def get_neuron_pos( H: int, W: int, x: Optional[int] = None, y: Optional[int] = None ) -> Tuple[int, int]: diff --git a/tests/optim/utils/test_reducer.py b/tests/optim/utils/test_reducer.py index 824f9da405..87dcecfb02 100644 --- a/tests/optim/utils/test_reducer.py +++ b/tests/optim/utils/test_reducer.py @@ -1,6 +1,5 @@ #!/usr/bin/env python3 import unittest -from typing import Union import numpy as np import torch From 7f0f4b5658e223e3f3fbf285013bdbe2c31645a0 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Tue, 22 Dec 2020 19:27:31 -0700 Subject: [PATCH 68/76] Fix imports --- captum/optim/__init__.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/captum/optim/__init__.py b/captum/optim/__init__.py index b8488ef462..9691465544 100755 --- a/captum/optim/__init__.py +++ b/captum/optim/__init__.py @@ -7,7 +7,5 @@ from captum.optim._param.image import transform # noqa: F401 from captum.optim._param.image.images import ImageTensor # noqa: F401 from captum.optim._utils import circuits, models, reducer # noqa: F401 -from captum.optim._utils.image.common import ( # noqa: F401 - nchannels_to_rgb, # noqa: F401 - tensor_heatmap, # noqa: F401 -) +from captum.optim._utils.image.common import nchannels_to_rgb # noqa: F401 +from captum.optim._utils.image.common import tensor_heatmap # noqa: F401 From fe44e4965ff275e2eb31a2d2ecdbe20f9ed5d32e Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 23 Dec 2020 09:45:13 -0700 Subject: [PATCH 69/76] Remove unused code from weight-viz tutorial --- .../optimviz/WeightVisualization_OptimViz.ipynb | 17 ++++++----------- 1 file changed, 6 insertions(+), 11 deletions(-) diff --git a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb index 2924927602..4ed7c30b48 100644 --- a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb +++ b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb @@ -805,17 +805,15 @@ "\r\n", "\r\n", "def show(x: np.ndarray, scale: float = 255.0) -> None:\r\n", - " assert len(x.shape) == 3\r\n", - " x = x.permute(1,2,0).numpy() if torch.is_tensor(x) else x\r\n", - " if x.shape[2] == 1:\r\n", - " x = np.concatenate([x, x, x], 2)\r\n", - " x = x * scale\r\n", - " plt.imshow(x.astype(np.uint8))\r\n", + " assert x.dim() == 3 or x.dim() == 4\r\n", + " x = x[0] if x.dim() == 4 else x\r\n", + " x = x.cpu().permute(1,2,0) * scale\r\n", + " plt.imshow(x.numpy().astype(np.uint8))\r\n", " plt.axis(\"off\")\r\n", " plt.show()\r\n", "\r\n", "\r\n", - "def visualize_activations(model, target, channel: int, neuron=True) -> None:\r\n", + "def visualize_activations(model, target, channel: int) -> None:\r\n", " image = optimviz.images.NaturalImage((224, 224)).to(device)\r\n", " transforms = torch.nn.Sequential(\r\n", " torch.nn.ReflectionPad2d(16),\r\n", @@ -825,10 +823,7 @@ " optimviz.transform.RandomSpatialJitter(8),\r\n", " optimviz.transform.CenterCrop(16),\r\n", " )\r\n", - " if neuron:\r\n", - " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", - " else:\r\n", - " loss_fn = optimviz.loss.ChannelActivation(target, channel)\r\n", + " loss_fn = optimviz.loss.NeuronActivation(target, channel)\r\n", " obj = optimviz.InputOptimization(model, image, transforms, [target], loss_fn)\r\n", " history = obj.optimize(optimviz.objectives.n_steps(128))\r\n", " image().show()\r\n", From 596b5f646b1c73be94e32013d7f977bf6d1ae4b5 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 23 Dec 2020 11:03:55 -0700 Subject: [PATCH 70/76] Make posneg function use F.relu --- captum/optim/_utils/reducer.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index e4206c79d4..cbb0a8e49e 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -1,6 +1,7 @@ from typing import Any, Callable, List, Union import numpy as np +import torch.nn.functional as F try: import sklearn.decomposition @@ -108,7 +109,4 @@ def posneg(x: torch.Tensor, dim: int = 0) -> torch.Tensor: one-sided NMF with regular NMF """ - return torch.cat( - [torch.max(x, torch.full_like(x, 0)), torch.max(-x, torch.full_like(x, 0))], - dim=dim, - ) + return torch.cat([F.relu(x), F.relu(-x)], dim=dim) From 17d751670ac74e1345b541a8f84092673be9cadb Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 23 Dec 2020 13:42:59 -0700 Subject: [PATCH 71/76] Changes based on feedback --- captum/optim/_param/image/transform.py | 14 +++++----- captum/optim/_utils/circuits.py | 2 +- captum/optim/_utils/image/common.py | 11 ++++++-- captum/optim/_utils/reducer.py | 2 +- tests/optim/helpers/numpy_common.py | 2 +- tests/optim/param/test_transforms.py | 26 +++++++++++++++++++ tests/optim/utils/image/common.py | 8 +++--- .../WeightVisualization_OptimViz.ipynb | 6 ++--- 8 files changed, 52 insertions(+), 19 deletions(-) diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index b5afcabbc2..443f5466e4 100644 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -377,8 +377,8 @@ class SymmetricPadding(torch.autograd.Function): """ @staticmethod - def forward(self, x: torch.Tensor, padding) -> torch.Tensor: - self.padding = padding + def forward(ctx, x: torch.Tensor, padding: List[List[int]]) -> torch.Tensor: + ctx.padding = padding x_device = x.device x = x.cpu() x.data = torch.as_tensor( @@ -388,13 +388,13 @@ def forward(self, x: torch.Tensor, padding) -> torch.Tensor: return x @staticmethod - def backward(self, grad_output: torch.Tensor): + def backward(ctx, grad_output: torch.Tensor) -> Tuple[torch.Tensor, None]: grad_input = grad_output.clone() B, C, H, W = grad_input.size() - b1, b2 = self.padding[0] - c1, c2 = self.padding[1] - h1, h2 = self.padding[2] - w1, w2 = self.padding[3] + b1, b2 = ctx.padding[0] + c1, c2 = ctx.padding[1] + h1, h2 = ctx.padding[2] + w1, w2 = ctx.padding[3] grad_input = grad_input[b1 : B - b2, c1 : C - c2, h1 : H - h2, w1 : W - w2] return grad_input, None diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index 9e7fa2244a..4ef8621ea2 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -23,7 +23,7 @@ def get_expanded_weights( See: https://distill.pub/2020/circuits/visualizing-weights/ Args: - model: PyTorch model instance. + model (nn.Module): The reference to PyTorch model instance. target1 (nn.module): The starting target layer. Must be below the layer specified for target2. target2 (nn.module): The end target layer. Must be above the layer diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py index 1e7a000f74..e310068a13 100644 --- a/captum/optim/_utils/image/common.py +++ b/captum/optim/_utils/image/common.py @@ -84,8 +84,8 @@ def adj(x: float) -> float: ) -def tensor_heatmap( - tensor: torch.Tensor, +def weights_to_heatmap_2d( + weight: torch.Tensor, colors: List[str] = ["0571b0", "92c5de", "f7f7f7", "f4a582", "ca0020"], ) -> torch.Tensor: """ @@ -93,6 +93,13 @@ def tensor_heatmap( By default red represents excitatory values, blue represents inhibitory values, and white represents no excitation or inhibition. + + Args: + weight (torch.Tensor): A 2d tensor to create the heatmap from. + colors (List of strings): A list of strings containing color + hex values to use for coloring the heatmap. + Returns: + *tensor*: A weight heatmap. """ assert tensor.dim() == 2 diff --git a/captum/optim/_utils/reducer.py b/captum/optim/_utils/reducer.py index cbb0a8e49e..ccc4079df8 100644 --- a/captum/optim/_utils/reducer.py +++ b/captum/optim/_utils/reducer.py @@ -52,7 +52,7 @@ def fit_transform( self, x: torch.Tensor, swap_2nd_and_last_dims: bool = True ) -> torch.Tensor: """ - Perform dimensionality reduction on an input tensor or NumPy array. + Perform dimensionality reduction on an input tensor. If swap_2nd_and_last_dims is true, input channels are expected to be in the second dimension unless the input tensor has a shape of CHW. diff --git a/tests/optim/helpers/numpy_common.py b/tests/optim/helpers/numpy_common.py index 225dccc1e6..6013600eb7 100644 --- a/tests/optim/helpers/numpy_common.py +++ b/tests/optim/helpers/numpy_common.py @@ -3,7 +3,7 @@ import numpy as np -def array_heatmap( +def weights_to_heatmap_2d( array: np.ndarray, colors: List[str] = ["0571b0", "92c5de", "f7f7f7", "f4a582", "ca0020"], ) -> np.ndarray: diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index 50b0edc5a7..bb4048247b 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -391,6 +391,32 @@ def test_symmetric_padding(self) -> None: ) assertTensorAlmostEqual(self, x_out, x_out_np) + def test_symmetric_padding_backward(self) -> None: + b = 2 + c = 3 + x = torch.arange(0, b * c * 4 * 4).view(b, c, 4, 4).float() + offset_pad = [[3, 3], [4, 4], [2, 2], [5, 5]] + + x_pt = torch.nn.Parameter(x) * 1 + + t_grad_input = [] + + def check_grad(self, grad_input, grad_output): + t_grad_input.append(grad_input[0].clone().detach()) + + class SymmetricPaddingLayer(torch.nn.Module): + def forward( + self, x: torch.Tensor, padding: List[List[int]] + ) -> torch.Tensor: + return transform.SymmetricPadding.apply(x_pt, padding) + + sym_pad = SymmetricPaddingLayer() + sym_pad.register_backward_hook(check_grad) + x_out = sym_pad(x_pt, offset_pad) + (x_out.sum() * 1).backward() + + assertTensorAlmostEqual(self, x, t_grad_input[0]) + class TestNChannelsToRGB(BaseTest): def test_nchannels_to_rgb_collapse(self) -> None: diff --git a/tests/optim/utils/image/common.py b/tests/optim/utils/image/common.py index abb0d44402..7bc267d616 100644 --- a/tests/optim/utils/image/common.py +++ b/tests/optim/utils/image/common.py @@ -50,8 +50,8 @@ def test_nchannels_to_rgb_increase(self) -> None: self.assertEqual(list(test_output.size()), [1, 3, 224, 224]) -class TestHeatMap(BaseTest): - def test_heatmap(self) -> None: +class TestWeightsToHeatmap2D(BaseTest): + def test_weights_to_heatmap_2d(self) -> None: x = torch.ones(5, 4) x[0:1, 0:4] = x[0:1, 0:4] * 0.2 x[1:2, 0:4] = x[1:2, 0:4] * 0.8 @@ -59,8 +59,8 @@ def test_heatmap(self) -> None: x[3:4, 0:4] = x[3:4, 0:4] * -0.2 x[4:5, 0:4] = x[4:5, 0:4] * -0.8 - x_out = common.tensor_heatmap(x) - x_out_np = numpy_common.array_heatmap(x.numpy()) + x_out = common.weights_to_heatmap_2d(x) + x_out_np = numpy_common.weights_to_heatmap_2d(x.numpy()) assertTensorAlmostEqual(self, x_out, torch.as_tensor(x_out_np).float()) diff --git a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb index 4ed7c30b48..a923fea790 100644 --- a/tutorials/optimviz/WeightVisualization_OptimViz.ipynb +++ b/tutorials/optimviz/WeightVisualization_OptimViz.ipynb @@ -872,7 +872,7 @@ "source": [ "# Visualizing expanded weights\r\n", "\r\n", - "To make it easier to understand what we are seeing, we can create a heatmap using Captum.optim's `tensor_heatmap` function. The `tensor_heatmap` function will by default use the color red to show excitatory parts of the weights, blue for inhibitory parts of the weights, and white for no excitation or inhibition.\r\n", + "To make it easier to understand what we are seeing, we can create a heatmap using Captum.optim's `weights_to_heatmap_2d` function. The `weights_to_heatmap_2d` function will by default use the color red to show excitatory parts of the weights, blue for inhibitory parts of the weights, and white for no excitation or inhibition.\r\n", "\r\n", "By using our heatmap, we can visualize our newly collected expanded weights for channel 147 of mixed3a and channel 379 of mixed3b like so:" ] @@ -888,7 +888,7 @@ "outputId": "ac0bee4a-7bbd-423d-dd92-279a13af4b05" }, "source": [ - "W_3a_3b_hm = optimviz.tensor_heatmap(W_3a_3b[379, 147, ...] / W_3a_3b[379, ...].max())\r\n", + "W_3a_3b_hm = optimviz.weights_to_heatmap_2d(W_3a_3b[379, 147, ...] / W_3a_3b[379, ...].max())\r\n", "show(W_3a_3b_hm)" ], "execution_count": null, @@ -1269,7 +1269,7 @@ "\r\n", "A = []\r\n", "for i in range(len(highlow_units)):\r\n", - " W_x = optimviz.tensor_heatmap(W_nmf[i, 0, ...] / W_nmf[i, 0, ...].max())\r\n", + " W_x = optimviz.weights_to_heatmap_2d(W_nmf[i, 0, ...] / W_nmf[i, 0, ...].max())\r\n", " A.append(W_x)\r\n", "\r\n", "grid_img = torchvision.utils.make_grid(torch.stack(A), nrow=5)\r\n", From 9b095bd6289e648bcf470d4c9aee6e40ef9075c9 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 23 Dec 2020 13:52:35 -0700 Subject: [PATCH 72/76] Fix lint errors --- captum/optim/_param/image/transform.py | 2 +- captum/optim/_utils/image/common.py | 4 ++-- tests/optim/param/test_transforms.py | 1 + 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/captum/optim/_param/image/transform.py b/captum/optim/_param/image/transform.py index 443f5466e4..a4b9c1d98d 100644 --- a/captum/optim/_param/image/transform.py +++ b/captum/optim/_param/image/transform.py @@ -1,6 +1,6 @@ import math import numbers -from typing import List, Optional, Sequence, Union +from typing import List, Optional, Sequence, Tuple, Union import numpy as np import torch diff --git a/captum/optim/_utils/image/common.py b/captum/optim/_utils/image/common.py index e310068a13..e7939a6207 100644 --- a/captum/optim/_utils/image/common.py +++ b/captum/optim/_utils/image/common.py @@ -102,7 +102,7 @@ def weights_to_heatmap_2d( *tensor*: A weight heatmap. """ - assert tensor.dim() == 2 + assert weight.dim() == 2 assert len(colors) == 5 def get_color(x: str) -> torch.Tensor: @@ -131,5 +131,5 @@ def color_scale(x: torch.Tensor) -> torch.Tensor: return (1 - x) * get_color(colors[3]) + x * get_color(colors[4]) return torch.stack( - [torch.stack([color_scale(x) for x in t]) for t in tensor] + [torch.stack([color_scale(x) for x in t]) for t in weight] ).permute(2, 0, 1) diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index bb4048247b..b0d8364ada 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -1,5 +1,6 @@ #!/usr/bin/env python3 import unittest +from typing import List import numpy as np import torch From 987e28e7422b867be1536c9af3145ba543ca7899 Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 23 Dec 2020 14:11:43 -0700 Subject: [PATCH 73/76] More changes based on feedback --- captum/optim/__init__.py | 2 +- captum/optim/_utils/circuits.py | 2 +- tests/optim/param/test_transforms.py | 8 +++++++- 3 files changed, 9 insertions(+), 3 deletions(-) diff --git a/captum/optim/__init__.py b/captum/optim/__init__.py index 9691465544..5d1b90f76a 100755 --- a/captum/optim/__init__.py +++ b/captum/optim/__init__.py @@ -8,4 +8,4 @@ from captum.optim._param.image.images import ImageTensor # noqa: F401 from captum.optim._utils import circuits, models, reducer # noqa: F401 from captum.optim._utils.image.common import nchannels_to_rgb # noqa: F401 -from captum.optim._utils.image.common import tensor_heatmap # noqa: F401 +from captum.optim._utils.image.common import weights_to_heatmap_2d # noqa: F401 diff --git a/captum/optim/_utils/circuits.py b/captum/optim/_utils/circuits.py index 4ef8621ea2..c882607570 100644 --- a/captum/optim/_utils/circuits.py +++ b/captum/optim/_utils/circuits.py @@ -26,7 +26,7 @@ def get_expanded_weights( model (nn.Module): The reference to PyTorch model instance. target1 (nn.module): The starting target layer. Must be below the layer specified for target2. - target2 (nn.module): The end target layer. Must be above the layer + target2 (nn.Module): The end target layer. Must be above the layer specified for target1. crop_shape (int or tuple of ints, optional): Specify the output weight size to enter crop away padding. diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index b0d8364ada..cc211ef08d 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -400,10 +400,11 @@ def test_symmetric_padding_backward(self) -> None: x_pt = torch.nn.Parameter(x) * 1 - t_grad_input = [] + t_grad_input, t_grad_output = [], [] def check_grad(self, grad_input, grad_output): t_grad_input.append(grad_input[0].clone().detach()) + t_grad_output.append(grad_output[0].clone().detach()) class SymmetricPaddingLayer(torch.nn.Module): def forward( @@ -418,6 +419,11 @@ def forward( assertTensorAlmostEqual(self, x, t_grad_input[0]) + x_out_np = torch.as_tensor( + np.pad(x.detach().numpy(), pad_width=offset_pad, mode="symmetric") + ) + assertTensorAlmostEqual(self, x_out_np, t_grad_output[0]) + class TestNChannelsToRGB(BaseTest): def test_nchannels_to_rgb_collapse(self) -> None: From 7b345177423a04ba3a02895f4ac3f891848ec0cc Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 23 Dec 2020 14:22:46 -0700 Subject: [PATCH 74/76] Update test_transforms.py (#144) Fix backwards padding test --- tests/optim/param/test_transforms.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index cc211ef08d..ff1074eba5 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -417,12 +417,12 @@ def forward( x_out = sym_pad(x_pt, offset_pad) (x_out.sum() * 1).backward() - assertTensorAlmostEqual(self, x, t_grad_input[0]) + self.assertEqual(self, x.shape, t_grad_input[0].shape) x_out_np = torch.as_tensor( np.pad(x.detach().numpy(), pad_width=offset_pad, mode="symmetric") ) - assertTensorAlmostEqual(self, x_out_np, t_grad_output[0]) + aelf.assertEqual(self, x_out_np.shape, t_grad_output[0].shape) class TestNChannelsToRGB(BaseTest): From 5e07a8f74d27491678257716db3c1a2c1f22530b Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 23 Dec 2020 14:27:57 -0700 Subject: [PATCH 75/76] Fix asserts --- tests/optim/param/test_transforms.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index ff1074eba5..79100ddc8a 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -417,12 +417,12 @@ def forward( x_out = sym_pad(x_pt, offset_pad) (x_out.sum() * 1).backward() - self.assertEqual(self, x.shape, t_grad_input[0].shape) + self.assertEqual(x.shape, t_grad_input[0].shape) x_out_np = torch.as_tensor( np.pad(x.detach().numpy(), pad_width=offset_pad, mode="symmetric") ) - aelf.assertEqual(self, x_out_np.shape, t_grad_output[0].shape) + aelf.assertEqual(x_out_np.shape, t_grad_output[0].shape) class TestNChannelsToRGB(BaseTest): From c8d90b44b1f23c5033586bf4574e5bb76cb0bc0a Mon Sep 17 00:00:00 2001 From: ProGamerGov Date: Wed, 23 Dec 2020 14:33:18 -0700 Subject: [PATCH 76/76] Oops: aelf -> self --- tests/optim/param/test_transforms.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/optim/param/test_transforms.py b/tests/optim/param/test_transforms.py index 79100ddc8a..b6216825ca 100644 --- a/tests/optim/param/test_transforms.py +++ b/tests/optim/param/test_transforms.py @@ -422,7 +422,7 @@ def forward( x_out_np = torch.as_tensor( np.pad(x.detach().numpy(), pad_width=offset_pad, mode="symmetric") ) - aelf.assertEqual(x_out_np.shape, t_grad_output[0].shape) + self.assertEqual(x_out_np.shape, t_grad_output[0].shape) class TestNChannelsToRGB(BaseTest):