diff --git a/generative/inferers/inferer.py b/generative/inferers/inferer.py index 37229b49..1d1c3a9c 100644 --- a/generative/inferers/inferer.py +++ b/generative/inferers/inferer.py @@ -18,11 +18,14 @@ import torch.nn as nn import torch.nn.functional as F from monai.inferers import Inferer +from monai.transforms import CenterSpatialCrop, SpatialPad from monai.utils import optional_import -from monai.transforms import SpatialPad, CenterSpatialCrop + +from generative.networks.nets import SPADEAutoencoderKL, SPADEDiffusionModelUNet tqdm, has_tqdm = optional_import("tqdm", name="tqdm") + class DiffusionInferer(Inferer): """ DiffusionInferer takes a trained diffusion model and a scheduler and can be used to perform a signal forward pass @@ -45,6 +48,7 @@ def __call__( timesteps: torch.Tensor, condition: torch.Tensor | None = None, mode: str = "crossattn", + seg: torch.Tensor | None = None, ) -> torch.Tensor: """ Implements the forward pass for a supervised training iteration. @@ -56,6 +60,8 @@ def __call__( timesteps: random timesteps. condition: Conditioning for network input. mode: Conditioning mode for the network. + seg: if model is instance of SPADEDiffusionModelUnet, segmentation must be + provided on the forward (for SPADE-like AE or SPADE-like DM) """ if mode not in ["crossattn", "concat"]: raise NotImplementedError(f"{mode} condition is not supported") @@ -64,7 +70,10 @@ def __call__( if mode == "concat": noisy_image = torch.cat([noisy_image, condition], dim=1) condition = None - prediction = diffusion_model(x=noisy_image, timesteps=timesteps, context=condition) + if isinstance(diffusion_model, SPADEDiffusionModelUNet): + prediction = diffusion_model(x=noisy_image, timesteps=timesteps, context=condition, seg=seg) + else: + prediction = diffusion_model(x=noisy_image, timesteps=timesteps, context=condition) return prediction @@ -79,6 +88,7 @@ def sample( conditioning: torch.Tensor | None = None, mode: str = "crossattn", verbose: bool = True, + seg: torch.Tensor | None = None, ) -> torch.Tensor | tuple[torch.Tensor, list[torch.Tensor]]: """ Args: @@ -90,6 +100,7 @@ def sample( conditioning: Conditioning for network input. mode: Conditioning mode for the network. verbose: if true, prints the progression bar of the sampling process. + seg: if diffusion model is instance of SPADEDiffusionModel, segmentation must be provided. """ if mode not in ["crossattn", "concat"]: raise NotImplementedError(f"{mode} condition is not supported") @@ -106,13 +117,23 @@ def sample( # 1. predict noise model_output if mode == "concat": model_input = torch.cat([image, conditioning], dim=1) - model_output = diffusion_model( - model_input, timesteps=torch.Tensor((t,)).to(input_noise.device), context=None - ) + if isinstance(diffusion_model, SPADEDiffusionModelUNet): + model_output = diffusion_model( + model_input, timesteps=torch.Tensor((t,)).to(input_noise.device), context=None, seg=seg + ) + else: + model_output = diffusion_model( + model_input, timesteps=torch.Tensor((t,)).to(input_noise.device), context=None + ) else: - model_output = diffusion_model( - image, timesteps=torch.Tensor((t,)).to(input_noise.device), context=conditioning - ) + if isinstance(diffusion_model, SPADEDiffusionModelUNet): + model_output = diffusion_model( + image, timesteps=torch.Tensor((t,)).to(input_noise.device), context=conditioning, seg=seg + ) + else: + model_output = diffusion_model( + image, timesteps=torch.Tensor((t,)).to(input_noise.device), context=conditioning + ) # 2. compute previous image: x_t -> x_t-1 image, _ = scheduler.step(model_output, t, image) @@ -135,6 +156,7 @@ def get_likelihood( original_input_range: tuple | None = (0, 255), scaled_input_range: tuple | None = (0, 1), verbose: bool = True, + seg: torch.Tensor | None = None, ) -> torch.Tensor | tuple[torch.Tensor, list[torch.Tensor]]: """ Computes the log-likelihoods for an input. @@ -149,6 +171,7 @@ def get_likelihood( original_input_range: the [min,max] intensity range of the input data before any scaling was applied. scaled_input_range: the [min,max] intensity range of the input data after scaling. verbose: if true, prints the progression bar of the sampling process. + seg: if diffusion model is instance of SPADEDiffusionModel, segmentation must be provided. """ if not scheduler: @@ -172,9 +195,15 @@ def get_likelihood( noisy_image = self.scheduler.add_noise(original_samples=inputs, noise=noise, timesteps=timesteps) if mode == "concat": noisy_image = torch.cat([noisy_image, conditioning], dim=1) - model_output = diffusion_model(noisy_image, timesteps=timesteps, context=None) + if isinstance(diffusion_model, SPADEDiffusionModelUNet): + model_output = diffusion_model(noisy_image, timesteps=timesteps, context=None, seg=seg) + else: + model_output = diffusion_model(noisy_image, timesteps=timesteps, context=None) else: - model_output = diffusion_model(x=noisy_image, timesteps=timesteps, context=conditioning) + if isinstance(diffusion_model, SPADEDiffusionModelUNet): + model_output = diffusion_model(x=noisy_image, timesteps=timesteps, context=conditioning, seg=seg) + else: + model_output = diffusion_model(x=noisy_image, timesteps=timesteps, context=conditioning) # get the model's predicted mean, and variance if it is predicted if model_output.shape[1] == inputs.shape[1] * 2 and scheduler.variance_type in ["learned", "learned_range"]: model_output, predicted_variance = torch.split(model_output, inputs.shape[1], dim=1) @@ -293,6 +322,7 @@ def _get_decoder_log_likelihood( assert log_probs.shape == inputs.shape return log_probs + class LatentDiffusionInferer(DiffusionInferer): """ LatentDiffusionInferer takes a stage 1 model (VQVAE or AutoencoderKL), diffusion model, and a scheduler, and can @@ -303,23 +333,26 @@ class LatentDiffusionInferer(DiffusionInferer): scale_factor: scale factor to multiply the values of the latent representation before processing it by the second stage. ldm_latent_shape: desired spatial latent space shape. Used if there is a difference in the autoencoder model's latent shape. - autoencoder_latent_shape: autoencoder_latent_shape: autoencoder spatial latent space shape. Used if there is a difference between the autoencoder's latent shape and the DM shape. + autoencoder_latent_shape: autoencoder_latent_shape: autoencoder spatial latent space shape. Used if there is a + difference between the autoencoder's latent shape and the DM shape. """ - def __init__(self, scheduler: nn.Module, scale_factor: float = 1.0, - ldm_latent_shape: list | None = None, - autoencoder_latent_shape: list | None = None) -> None: - + def __init__( + self, + scheduler: nn.Module, + scale_factor: float = 1.0, + ldm_latent_shape: list | None = None, + autoencoder_latent_shape: list | None = None, + ) -> None: super().__init__(scheduler=scheduler) self.scale_factor = scale_factor if (ldm_latent_shape is None) ^ (autoencoder_latent_shape is None): - raise ValueError("If ldm_latent_shape is None, autoencoder_latent_shape must be None" - "and vice versa.") + raise ValueError("If ldm_latent_shape is None, autoencoder_latent_shape must be None" "and vice versa.") self.ldm_latent_shape = ldm_latent_shape self.autoencoder_latent_shape = autoencoder_latent_shape if self.ldm_latent_shape is not None: - self.ldm_resizer = SpatialPad(spatial_size=[-1,]+self.ldm_latent_shape) - self.autoencoder_resizer = CenterSpatialCrop(roi_size=[-1,]+self.autoencoder_latent_shape) + self.ldm_resizer = SpatialPad(spatial_size=[-1] + self.ldm_latent_shape) + self.autoencoder_resizer = CenterSpatialCrop(roi_size=[-1] + self.autoencoder_latent_shape) def __call__( self, @@ -330,6 +363,7 @@ def __call__( timesteps: torch.Tensor, condition: torch.Tensor | None = None, mode: str = "crossattn", + seg: torch.Tensor | None = None, ) -> torch.Tensor: """ Implements the forward pass for a supervised training iteration. @@ -342,6 +376,7 @@ def __call__( timesteps: random timesteps. condition: conditioning for network input. mode: Conditioning mode for the network. + seg: if diffusion model is instance of SPADEDiffusionModel, segmentation must be provided. """ with torch.no_grad(): latent = autoencoder_model.encode_stage_2_inputs(inputs) * self.scale_factor @@ -349,14 +384,25 @@ def __call__( if self.ldm_latent_shape is not None: latent = self.ldm_resizer(latent) - prediction = super().__call__( - inputs=latent, - diffusion_model=diffusion_model, - noise=noise, - timesteps=timesteps, - condition=condition, - mode=mode, - ) + if isinstance(diffusion_model, SPADEDiffusionModelUNet): + prediction = super().__call__( + inputs=latent, + diffusion_model=diffusion_model, + noise=noise, + timesteps=timesteps, + condition=condition, + mode=mode, + seg=seg, + ) + else: + prediction = super().__call__( + inputs=latent, + diffusion_model=diffusion_model, + noise=noise, + timesteps=timesteps, + condition=condition, + mode=mode, + ) return prediction @@ -372,6 +418,7 @@ def sample( conditioning: torch.Tensor | None = None, mode: str = "crossattn", verbose: bool = True, + seg: torch.Tensor | None = None, ) -> torch.Tensor | tuple[torch.Tensor, list[torch.Tensor]]: """ Args: @@ -384,17 +431,43 @@ def sample( conditioning: Conditioning for network input. mode: Conditioning mode for the network. verbose: if true, prints the progression bar of the sampling process. + seg: if diffusion model is instance of SPADEDiffusionModel, or autoencoder_model + is instance of SPADEAutoencoderKL, segmentation must be provided. """ - outputs = super().sample( - input_noise=input_noise, - diffusion_model=diffusion_model, - scheduler=scheduler, - save_intermediates=save_intermediates, - intermediate_steps=intermediate_steps, - conditioning=conditioning, - mode=mode, - verbose=verbose, - ) + + if ( + isinstance(autoencoder_model, SPADEAutoencoderKL) + and isinstance(diffusion_model, SPADEDiffusionModelUNet) + and autoencoder_model.decoder.label_nc != diffusion_model.label_nc + ): + raise ValueError( + "If both autoencoder_model and diffusion_model implement SPADE, the number of semantic" + "labels for each must be compatible. " + ) + + if isinstance(diffusion_model, SPADEDiffusionModelUNet): + outputs = super().sample( + input_noise=input_noise, + diffusion_model=diffusion_model, + scheduler=scheduler, + save_intermediates=save_intermediates, + intermediate_steps=intermediate_steps, + conditioning=conditioning, + mode=mode, + verbose=verbose, + seg=seg, + ) + else: + outputs = super().sample( + input_noise=input_noise, + diffusion_model=diffusion_model, + scheduler=scheduler, + save_intermediates=save_intermediates, + intermediate_steps=intermediate_steps, + conditioning=conditioning, + mode=mode, + verbose=verbose, + ) if save_intermediates: latent, latent_intermediates = outputs @@ -410,7 +483,14 @@ def sample( if save_intermediates: intermediates = [] for latent_intermediate in latent_intermediates: - intermediates.append(autoencoder_model.decode_stage_2_outputs(latent_intermediate / self.scale_factor)) + if isinstance(autoencoder_model, SPADEAutoencoderKL): + intermediates.append( + autoencoder_model.decode_stage_2_outputs(latent_intermediate / self.scale_factor), seg=seg + ) + else: + intermediates.append( + autoencoder_model.decode_stage_2_outputs(latent_intermediate / self.scale_factor) + ) return image, intermediates else: @@ -431,6 +511,7 @@ def get_likelihood( verbose: bool = True, resample_latent_likelihoods: bool = False, resample_interpolation_mode: str = "nearest", + seg: torch.Tensor | None = None, ) -> torch.Tensor | tuple[torch.Tensor, list[torch.Tensor]]: """ Computes the log-likelihoods of the latent representations of the input. @@ -450,6 +531,8 @@ def get_likelihood( dimension as the input images. resample_interpolation_mode: if use resample_latent_likelihoods, select interpolation 'nearest', 'bilinear', or 'trilinear; + seg: if diffusion model is instance of SPADEDiffusionModel, or autoencoder_model + is instance of SPADEAutoencoderKL, segmentation must be provided. """ if resample_latent_likelihoods and resample_interpolation_mode not in ("nearest", "bilinear", "trilinear"): raise ValueError( @@ -460,15 +543,27 @@ def get_likelihood( if self.ldm_latent_shape is not None: latents = self.ldm_resizer(latents) - outputs = super().get_likelihood( - inputs=latents, - diffusion_model=diffusion_model, - scheduler=scheduler, - save_intermediates=save_intermediates, - conditioning=conditioning, - mode=mode, - verbose=verbose, - ) + if isinstance(diffusion_model, SPADEDiffusionModelUNet): + outputs = super().get_likelihood( + inputs=latents, + diffusion_model=diffusion_model, + scheduler=scheduler, + save_intermediates=save_intermediates, + conditioning=conditioning, + mode=mode, + verbose=verbose, + seg=seg, + ) + else: + outputs = super().get_likelihood( + inputs=latents, + diffusion_model=diffusion_model, + scheduler=scheduler, + save_intermediates=save_intermediates, + conditioning=conditioning, + mode=mode, + verbose=verbose, + ) if save_intermediates and resample_latent_likelihoods: intermediates = outputs[1] resizer = nn.Upsample(size=inputs.shape[2:], mode=resample_interpolation_mode) @@ -476,6 +571,7 @@ def get_likelihood( outputs = (outputs[0], intermediates) return outputs + class VQVAETransformerInferer(Inferer): """ Class to perform inference with a VQVAE + Transformer model. diff --git a/generative/networks/nets/__init__.py b/generative/networks/nets/__init__.py index ed4b172b..5514dd5d 100644 --- a/generative/networks/nets/__init__.py +++ b/generative/networks/nets/__init__.py @@ -15,5 +15,8 @@ from .controlnet import ControlNet from .diffusion_model_unet import DiffusionModelUNet from .patchgan_discriminator import MultiScalePatchDiscriminator, PatchDiscriminator +from .spade_autoencoderkl import SPADEAutoencoderKL +from .spade_diffusion_model_unet import SPADEDiffusionModelUNet +from .spade_network import SPADENet from .transformer import DecoderOnlyTransformer from .vqvae import VQVAE diff --git a/generative/networks/nets/diffusion_model_unet.py b/generative/networks/nets/diffusion_model_unet.py index 2de6705d..58a9f1f5 100644 --- a/generative/networks/nets/diffusion_model_unet.py +++ b/generative/networks/nets/diffusion_model_unet.py @@ -931,7 +931,7 @@ def __init__( cross_attention_dim: int | None = None, upcast_attention: bool = False, use_flash_attention: bool = False, - dropout_cattn: float = 0.0 + dropout_cattn: float = 0.0, ) -> None: super().__init__() self.resblock_updown = resblock_updown @@ -964,7 +964,7 @@ def __init__( cross_attention_dim=cross_attention_dim, upcast_attention=upcast_attention, use_flash_attention=use_flash_attention, - dropout=dropout_cattn + dropout=dropout_cattn, ) ) @@ -1103,7 +1103,7 @@ def __init__( cross_attention_dim: int | None = None, upcast_attention: bool = False, use_flash_attention: bool = False, - dropout_cattn: float = 0.0 + dropout_cattn: float = 0.0, ) -> None: super().__init__() self.attention = None @@ -1127,7 +1127,7 @@ def __init__( cross_attention_dim=cross_attention_dim, upcast_attention=upcast_attention, use_flash_attention=use_flash_attention, - dropout=dropout_cattn + dropout=dropout_cattn, ) self.resnet_2 = ResnetBlock( spatial_dims=spatial_dims, @@ -1271,7 +1271,7 @@ def __init__( add_upsample: bool = True, resblock_updown: bool = False, num_head_channels: int = 1, - use_flash_attention: bool = False + use_flash_attention: bool = False, ) -> None: super().__init__() self.resblock_updown = resblock_updown @@ -1388,7 +1388,7 @@ def __init__( cross_attention_dim: int | None = None, upcast_attention: bool = False, use_flash_attention: bool = False, - dropout_cattn: float = 0.0 + dropout_cattn: float = 0.0, ) -> None: super().__init__() self.resblock_updown = resblock_updown @@ -1422,7 +1422,7 @@ def __init__( cross_attention_dim=cross_attention_dim, upcast_attention=upcast_attention, use_flash_attention=use_flash_attention, - dropout=dropout_cattn + dropout=dropout_cattn, ) ) @@ -1486,7 +1486,7 @@ def get_down_block( cross_attention_dim: int | None, upcast_attention: bool = False, use_flash_attention: bool = False, - dropout_cattn: float = 0.0 + dropout_cattn: float = 0.0, ) -> nn.Module: if with_attn: return AttnDownBlock( @@ -1518,7 +1518,7 @@ def get_down_block( cross_attention_dim=cross_attention_dim, upcast_attention=upcast_attention, use_flash_attention=use_flash_attention, - dropout_cattn=dropout_cattn + dropout_cattn=dropout_cattn, ) else: return DownBlock( @@ -1546,7 +1546,7 @@ def get_mid_block( cross_attention_dim: int | None, upcast_attention: bool = False, use_flash_attention: bool = False, - dropout_cattn: float = 0.0 + dropout_cattn: float = 0.0, ) -> nn.Module: if with_conditioning: return CrossAttnMidBlock( @@ -1560,7 +1560,7 @@ def get_mid_block( cross_attention_dim=cross_attention_dim, upcast_attention=upcast_attention, use_flash_attention=use_flash_attention, - dropout_cattn=dropout_cattn + dropout_cattn=dropout_cattn, ) else: return AttnMidBlock( @@ -1592,7 +1592,7 @@ def get_up_block( cross_attention_dim: int | None, upcast_attention: bool = False, use_flash_attention: bool = False, - dropout_cattn: float = 0.0 + dropout_cattn: float = 0.0, ) -> nn.Module: if with_attn: return AttnUpBlock( @@ -1626,7 +1626,7 @@ def get_up_block( cross_attention_dim=cross_attention_dim, upcast_attention=upcast_attention, use_flash_attention=use_flash_attention, - dropout_cattn=dropout_cattn + dropout_cattn=dropout_cattn, ) else: return UpBlock( @@ -1688,7 +1688,7 @@ def __init__( num_class_embeds: int | None = None, upcast_attention: bool = False, use_flash_attention: bool = False, - dropout_cattn: float = 0.0 + dropout_cattn: float = 0.0, ) -> None: super().__init__() if with_conditioning is True and cross_attention_dim is None: @@ -1701,9 +1701,7 @@ def __init__( "DiffusionModelUNet expects with_conditioning=True when specifying the cross_attention_dim." ) if dropout_cattn > 1.0 or dropout_cattn < 0.0: - raise ValueError( - "Dropout cannot be negative or >1.0!" - ) + raise ValueError("Dropout cannot be negative or >1.0!") # All number of channels should be multiple of num_groups if any((out_channel % norm_num_groups) != 0 for out_channel in num_channels): @@ -1793,7 +1791,7 @@ def __init__( cross_attention_dim=cross_attention_dim, upcast_attention=upcast_attention, use_flash_attention=use_flash_attention, - dropout_cattn=dropout_cattn + dropout_cattn=dropout_cattn, ) self.down_blocks.append(down_block) @@ -1811,7 +1809,7 @@ def __init__( cross_attention_dim=cross_attention_dim, upcast_attention=upcast_attention, use_flash_attention=use_flash_attention, - dropout_cattn=dropout_cattn + dropout_cattn=dropout_cattn, ) # up @@ -1846,7 +1844,7 @@ def __init__( cross_attention_dim=cross_attention_dim, upcast_attention=upcast_attention, use_flash_attention=use_flash_attention, - dropout_cattn=dropout_cattn + dropout_cattn=dropout_cattn, ) self.up_blocks.append(up_block) diff --git a/generative/networks/nets/spade_autoencoderkl.py b/generative/networks/nets/spade_autoencoderkl.py new file mode 100644 index 00000000..a8706315 --- /dev/null +++ b/generative/networks/nets/spade_autoencoderkl.py @@ -0,0 +1,484 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +import importlib.util +from collections.abc import Sequence + +import torch +import torch.nn as nn +import torch.nn.functional as F +from monai.networks.blocks import Convolution +from monai.utils import ensure_tuple_rep + +from generative.networks.blocks.spade_norm import SPADE +from generative.networks.nets.autoencoderkl import AttentionBlock, Encoder, Upsample + +# To install xformers, use pip install xformers==0.0.16rc401 +if importlib.util.find_spec("xformers") is not None: + import xformers + + has_xformers = True +else: + xformers = None + has_xformers = False + +# TODO: Use MONAI's optional_import +# from monai.utils import optional_import +# xformers, has_xformers = optional_import("xformers.ops", name="xformers") + +__all__ = ["SPADEAutoencoderKL"] + + +class SPADEResBlock(nn.Module): + """ + Residual block consisting of a cascade of 2 convolutions + activation + normalisation block, and a + residual connection between input and output. + Enables SPADE normalisation for semantic conditioning (Park et. al (2019): https://github.com/NVlabs/SPADE) + + Args: + spatial_dims: number of spatial dimensions (1D, 2D, 3D). + in_channels: input channels to the layer. + norm_num_groups: number of groups involved for the group normalisation layer. Ensure that your number of + channels is divisible by this number. + norm_eps: epsilon for the normalisation. + out_channels: number of output channels. + label_nc: number of semantic channels for SPADE normalisation + spade_intermediate_channels: number of intermediate channels for SPADE block layer + """ + + def __init__( + self, + spatial_dims: int, + in_channels: int, + norm_num_groups: int, + norm_eps: float, + out_channels: int, + label_nc: int, + spade_intermediate_channels: int = 128, + ) -> None: + super().__init__() + self.in_channels = in_channels + self.out_channels = in_channels if out_channels is None else out_channels + self.norm1 = SPADE( + label_nc=label_nc, + norm_nc=in_channels, + norm="GROUP", + norm_params={"num_groups": norm_num_groups, "affine": False}, + hidden_channels=spade_intermediate_channels, + kernel_size=3, + spatial_dims=spatial_dims, + ) + self.conv1 = Convolution( + spatial_dims=spatial_dims, + in_channels=self.in_channels, + out_channels=self.out_channels, + strides=1, + kernel_size=3, + padding=1, + conv_only=True, + ) + self.norm2 = SPADE( + label_nc=label_nc, + norm_nc=out_channels, + norm="GROUP", + norm_params={"num_groups": norm_num_groups, "affine": False}, + hidden_channels=spade_intermediate_channels, + kernel_size=3, + spatial_dims=spatial_dims, + ) + self.conv2 = Convolution( + spatial_dims=spatial_dims, + in_channels=self.out_channels, + out_channels=self.out_channels, + strides=1, + kernel_size=3, + padding=1, + conv_only=True, + ) + + if self.in_channels != self.out_channels: + self.nin_shortcut = Convolution( + spatial_dims=spatial_dims, + in_channels=self.in_channels, + out_channels=self.out_channels, + strides=1, + kernel_size=1, + padding=0, + conv_only=True, + ) + else: + self.nin_shortcut = nn.Identity() + + def forward(self, x: torch.Tensor, seg: torch.Tensor) -> torch.Tensor: + h = x + h = self.norm1(h, seg) + h = F.silu(h) + h = self.conv1(h) + h = self.norm2(h, seg) + h = F.silu(h) + h = self.conv2(h) + + if self.in_channels != self.out_channels: + x = self.nin_shortcut(x) + + return x + h + + +class SPADEDecoder(nn.Module): + """ + Convolutional cascade upsampling from a spatial latent space into an image space. + Enables SPADE normalisation for semantic conditioning (Park et. al (2019): https://github.com/NVlabs/SPADE) + Args: + spatial_dims: number of spatial dimensions (1D, 2D, 3D). + num_channels: sequence of block output channels. + in_channels: number of channels in the bottom layer (latent space) of the autoencoder. + out_channels: number of output channels. + num_res_blocks: number of residual blocks (see ResBlock) per level. + norm_num_groups: number of groups for the GroupNorm layers, num_channels must be divisible by this number. + norm_eps: epsilon for the normalization. + attention_levels: indicate which level from num_channels contain an attention block. + label_nc: number of semantic channels for SPADE normalisation. + with_nonlocal_attn: if True use non-local attention block. + use_flash_attention: if True, use flash attention for a memory efficient attention mechanism. + spade_intermediate_channels: number of intermediate channels for SPADE block layer. + """ + + def __init__( + self, + spatial_dims: int, + num_channels: Sequence[int], + in_channels: int, + out_channels: int, + num_res_blocks: Sequence[int], + norm_num_groups: int, + norm_eps: float, + attention_levels: Sequence[bool], + label_nc: int, + with_nonlocal_attn: bool = True, + use_flash_attention: bool = False, + spade_intermediate_channels: int = None, + ) -> None: + super().__init__() + self.spatial_dims = spatial_dims + self.num_channels = num_channels + self.in_channels = in_channels + self.out_channels = out_channels + self.num_res_blocks = num_res_blocks + self.norm_num_groups = norm_num_groups + self.norm_eps = norm_eps + self.attention_levels = attention_levels + self.label_nc = label_nc + + reversed_block_out_channels = list(reversed(num_channels)) + + blocks = [] + # Initial convolution + blocks.append( + Convolution( + spatial_dims=spatial_dims, + in_channels=in_channels, + out_channels=reversed_block_out_channels[0], + strides=1, + kernel_size=3, + padding=1, + conv_only=True, + ) + ) + + # Non-local attention block + if with_nonlocal_attn is True: + blocks.append( + SPADEResBlock( + spatial_dims=spatial_dims, + in_channels=reversed_block_out_channels[0], + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + out_channels=reversed_block_out_channels[0], + label_nc=label_nc, + spade_intermediate_channels=spade_intermediate_channels, + ) + ) + blocks.append( + AttentionBlock( + spatial_dims=spatial_dims, + num_channels=reversed_block_out_channels[0], + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + use_flash_attention=use_flash_attention, + ) + ) + blocks.append( + SPADEResBlock( + spatial_dims=spatial_dims, + in_channels=reversed_block_out_channels[0], + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + out_channels=reversed_block_out_channels[0], + label_nc=label_nc, + spade_intermediate_channels=spade_intermediate_channels, + ) + ) + + reversed_attention_levels = list(reversed(attention_levels)) + reversed_num_res_blocks = list(reversed(num_res_blocks)) + block_out_ch = reversed_block_out_channels[0] + for i in range(len(reversed_block_out_channels)): + block_in_ch = block_out_ch + block_out_ch = reversed_block_out_channels[i] + is_final_block = i == len(num_channels) - 1 + + for _ in range(reversed_num_res_blocks[i]): + blocks.append( + SPADEResBlock( + spatial_dims=spatial_dims, + in_channels=block_in_ch, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + out_channels=block_out_ch, + label_nc=label_nc, + spade_intermediate_channels=spade_intermediate_channels, + ) + ) + block_in_ch = block_out_ch + + if reversed_attention_levels[i]: + blocks.append( + AttentionBlock( + spatial_dims=spatial_dims, + num_channels=block_in_ch, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + use_flash_attention=use_flash_attention, + ) + ) + + if not is_final_block: + blocks.append(Upsample(spatial_dims=spatial_dims, in_channels=block_in_ch, use_convtranspose=False)) + + blocks.append(nn.GroupNorm(num_groups=norm_num_groups, num_channels=block_in_ch, eps=norm_eps, affine=True)) + blocks.append( + Convolution( + spatial_dims=spatial_dims, + in_channels=block_in_ch, + out_channels=out_channels, + strides=1, + kernel_size=3, + padding=1, + conv_only=True, + ) + ) + + self.blocks = nn.ModuleList(blocks) + + def forward(self, x: torch.Tensor, seg: torch.Tensor) -> torch.Tensor: + for block in self.blocks: + if isinstance(block, SPADEResBlock): + x = block(x, seg) + else: + x = block(x) + return x + + +class SPADEAutoencoderKL(nn.Module): + """ + Autoencoder model with KL-regularized latent space based on + Rombach et al. "High-Resolution Image Synthesis with Latent Diffusion Models" https://arxiv.org/abs/2112.10752 + and Pinaya et al. "Brain Imaging Generation with Latent Diffusion Models" https://arxiv.org/abs/2209.07162 + Enables SPADE normalisation for semantic conditioning (Park et. al (2019): https://github.com/NVlabs/SPADE) + Args: + spatial_dims: number of spatial dimensions (1D, 2D, 3D). + label_nc: number of semantic channels for SPADE normalisation. + in_channels: number of input channels. + out_channels: number of output channels. + num_res_blocks: number of residual blocks (see ResBlock) per level. + num_channels: sequence of block output channels. + attention_levels: sequence of levels to add attention. + latent_channels: latent embedding dimension. + norm_num_groups: number of groups for the GroupNorm layers, num_channels must be divisible by this number. + norm_eps: epsilon for the normalization. + with_encoder_nonlocal_attn: if True use non-local attention block in the encoder. + with_decoder_nonlocal_attn: if True use non-local attention block in the decoder. + use_flash_attention: if True, use flash attention for a memory efficient attention mechanism. + spade_intermediate_channels: number of intermediate channels for SPADE block layer. + """ + + def __init__( + self, + spatial_dims: int, + label_nc: int, + in_channels: int = 1, + out_channels: int = 1, + num_res_blocks: Sequence[int] | int = (2, 2, 2, 2), + num_channels: Sequence[int] = (32, 64, 64, 64), + attention_levels: Sequence[bool] = (False, False, True, True), + latent_channels: int = 3, + norm_num_groups: int = 32, + norm_eps: float = 1e-6, + with_encoder_nonlocal_attn: bool = True, + with_decoder_nonlocal_attn: bool = True, + use_flash_attention: bool = False, + spade_intermediate_channels: int = 128, + ) -> None: + super().__init__() + + # All number of channels should be multiple of num_groups + if any((out_channel % norm_num_groups) != 0 for out_channel in num_channels): + raise ValueError("SPADEAutoencoderKL expects all num_channels being multiple of norm_num_groups") + + if len(num_channels) != len(attention_levels): + raise ValueError("SPADEAutoencoderKL expects num_channels being same size of attention_levels") + + if isinstance(num_res_blocks, int): + num_res_blocks = ensure_tuple_rep(num_res_blocks, len(num_channels)) + + if len(num_res_blocks) != len(num_channels): + raise ValueError( + "`num_res_blocks` should be a single integer or a tuple of integers with the same length as " + "`num_channels`." + ) + + if use_flash_attention is True and not torch.cuda.is_available(): + raise ValueError( + "torch.cuda.is_available() should be True but is False. Flash attention is only available for GPU." + ) + + self.encoder = Encoder( + spatial_dims=spatial_dims, + in_channels=in_channels, + num_channels=num_channels, + out_channels=latent_channels, + num_res_blocks=num_res_blocks, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + attention_levels=attention_levels, + with_nonlocal_attn=with_encoder_nonlocal_attn, + use_flash_attention=use_flash_attention, + ) + self.decoder = SPADEDecoder( + spatial_dims=spatial_dims, + num_channels=num_channels, + in_channels=latent_channels, + out_channels=out_channels, + num_res_blocks=num_res_blocks, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + attention_levels=attention_levels, + label_nc=label_nc, + with_nonlocal_attn=with_decoder_nonlocal_attn, + use_flash_attention=use_flash_attention, + spade_intermediate_channels=spade_intermediate_channels, + ) + self.quant_conv_mu = Convolution( + spatial_dims=spatial_dims, + in_channels=latent_channels, + out_channels=latent_channels, + strides=1, + kernel_size=1, + padding=0, + conv_only=True, + ) + self.quant_conv_log_sigma = Convolution( + spatial_dims=spatial_dims, + in_channels=latent_channels, + out_channels=latent_channels, + strides=1, + kernel_size=1, + padding=0, + conv_only=True, + ) + self.post_quant_conv = Convolution( + spatial_dims=spatial_dims, + in_channels=latent_channels, + out_channels=latent_channels, + strides=1, + kernel_size=1, + padding=0, + conv_only=True, + ) + self.latent_channels = latent_channels + + def encode(self, x: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]: + """ + Forwards an image through the spatial encoder, obtaining the latent mean and sigma representations. + + Args: + x: BxCx[SPATIAL DIMS] tensor + + """ + h = self.encoder(x) + z_mu = self.quant_conv_mu(h) + z_log_var = self.quant_conv_log_sigma(h) + z_log_var = torch.clamp(z_log_var, -30.0, 20.0) + z_sigma = torch.exp(z_log_var / 2) + + return z_mu, z_sigma + + def sampling(self, z_mu: torch.Tensor, z_sigma: torch.Tensor) -> torch.Tensor: + """ + From the mean and sigma representations resulting of encoding an image through the latent space, + obtains a noise sample resulting from sampling gaussian noise, multiplying by the variance (sigma) and + adding the mean. + + Args: + z_mu: Bx[Z_CHANNELS]x[LATENT SPACE SIZE] mean vector obtained by the encoder when you encode an image + z_sigma: Bx[Z_CHANNELS]x[LATENT SPACE SIZE] variance vector obtained by the encoder when you encode an image + + Returns: + sample of shape Bx[Z_CHANNELS]x[LATENT SPACE SIZE] + """ + eps = torch.randn_like(z_sigma) + z_vae = z_mu + eps * z_sigma + return z_vae + + def reconstruct(self, x: torch.Tensor, seg: torch.Tensor) -> torch.Tensor: + """ + Encodes and decodes an input image. + + Args: + x: BxCx[SPATIAL DIMENSIONS] tensor. + seg: Bx[LABEL_NC]x[SPATIAL DIMENSIONS] tensor of segmentations for SPADE norm. + Returns: + reconstructed image, of the same shape as input + """ + z_mu, _ = self.encode(x) + reconstruction = self.decode(z_mu, seg) + return reconstruction + + def decode(self, z: torch.Tensor, seg: torch.Tensor) -> torch.Tensor: + """ + Based on a latent space sample, forwards it through the Decoder. + + Args: + z: Bx[Z_CHANNELS]x[LATENT SPACE SHAPE] + seg: Bx[LABEL_NC]x[SPATIAL DIMENSIONS] tensor of segmentations for SPADE norm. + Returns: + decoded image tensor + """ + z = self.post_quant_conv(z) + dec = self.decoder(z, seg) + return dec + + def forward(self, x: torch.Tensor, seg: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor]: + z_mu, z_sigma = self.encode(x) + z = self.sampling(z_mu, z_sigma) + reconstruction = self.decode(z, seg) + return reconstruction, z_mu, z_sigma + + def encode_stage_2_inputs(self, x: torch.Tensor) -> torch.Tensor: + z_mu, z_sigma = self.encode(x) + z = self.sampling(z_mu, z_sigma) + return z + + def decode_stage_2_outputs(self, z: torch.Tensor, seg: torch.Tensor) -> torch.Tensor: + image = self.decode(z, seg) + return image diff --git a/generative/networks/nets/spade_diffusion_model_unet.py b/generative/networks/nets/spade_diffusion_model_unet.py new file mode 100644 index 00000000..7e2b01d5 --- /dev/null +++ b/generative/networks/nets/spade_diffusion_model_unet.py @@ -0,0 +1,912 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +# ========================================================================= +# Adapted from https://github.com/huggingface/diffusers +# which has the following license: +# https://github.com/huggingface/diffusers/blob/main/LICENSE +# +# Copyright 2022 UC Berkeley Team and The HuggingFace Team. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# ========================================================================= + +from __future__ import annotations + +import importlib.util +from collections.abc import Sequence + +import torch +from monai.networks.blocks import Convolution +from monai.utils import ensure_tuple_rep +from torch import nn + +from generative.networks.blocks.spade_norm import SPADE +from generative.networks.nets.diffusion_model_unet import ( + AttentionBlock, + Downsample, + ResnetBlock, + SpatialTransformer, + Upsample, + get_down_block, + get_mid_block, + get_timestep_embedding, + zero_module, +) + +# To install xformers, use pip install xformers==0.0.16rc401 +if importlib.util.find_spec("xformers") is not None: + import xformers + + has_xformers = True +else: + xformers = None + has_xformers = False + + +# TODO: Use MONAI's optional_import +# from monai.utils import optional_import +# xformers, has_xformers = optional_import("xformers.ops", name="xformers") + +__all__ = ["SPADEDiffusionModelUNet"] + + +class SPADEResnetBlock(nn.Module): + """ + Residual block with timestep conditioning and SPADE norm. + Enables SPADE normalisation for semantic conditioning (Park et. al (2019): https://github.com/NVlabs/SPADE) + Args: + spatial_dims: The number of spatial dimensions. + in_channels: number of input channels. + temb_channels: number of timestep embedding channels. + label_nc: number of semantic channels for SPADE normalisation. + out_channels: number of output channels. + up: if True, performs upsampling. + down: if True, performs downsampling. + norm_num_groups: number of groups for the group normalization. + norm_eps: epsilon for the group normalization. + spade_intermediate_channels: number of intermediate channels for SPADE block layer + """ + + def __init__( + self, + spatial_dims: int, + in_channels: int, + temb_channels: int, + label_nc: int, + out_channels: int | None = None, + up: bool = False, + down: bool = False, + norm_num_groups: int = 32, + norm_eps: float = 1e-6, + spade_intermediate_channels: int = 128, + ) -> None: + super().__init__() + self.spatial_dims = spatial_dims + self.channels = in_channels + self.emb_channels = temb_channels + self.out_channels = out_channels or in_channels + self.up = up + self.down = down + + self.norm1 = SPADE( + label_nc=label_nc, + norm_nc=in_channels, + norm="GROUP", + norm_params={"num_groups": norm_num_groups, "eps": norm_eps, "affine": True}, + hidden_channels=spade_intermediate_channels, + kernel_size=3, + spatial_dims=spatial_dims, + ) + + self.nonlinearity = nn.SiLU() + self.conv1 = Convolution( + spatial_dims=spatial_dims, + in_channels=in_channels, + out_channels=self.out_channels, + strides=1, + kernel_size=3, + padding=1, + conv_only=True, + ) + + self.upsample = self.downsample = None + if self.up: + self.upsample = Upsample(spatial_dims, in_channels, use_conv=False) + elif down: + self.downsample = Downsample(spatial_dims, in_channels, use_conv=False) + + self.time_emb_proj = nn.Linear(temb_channels, self.out_channels) + + self.norm2 = SPADE( + label_nc=label_nc, + norm_nc=self.out_channels, + norm="GROUP", + norm_params={"num_groups": norm_num_groups, "eps": norm_eps, "affine": True}, + hidden_channels=spade_intermediate_channels, + kernel_size=3, + spatial_dims=spatial_dims, + ) + self.conv2 = zero_module( + Convolution( + spatial_dims=spatial_dims, + in_channels=self.out_channels, + out_channels=self.out_channels, + strides=1, + kernel_size=3, + padding=1, + conv_only=True, + ) + ) + + if self.out_channels == in_channels: + self.skip_connection = nn.Identity() + else: + self.skip_connection = Convolution( + spatial_dims=spatial_dims, + in_channels=in_channels, + out_channels=self.out_channels, + strides=1, + kernel_size=1, + padding=0, + conv_only=True, + ) + + def forward(self, x: torch.Tensor, emb: torch.Tensor, seg: torch.Tensor) -> torch.Tensor: + h = x + h = self.norm1(h, seg) + h = self.nonlinearity(h) + + if self.upsample is not None: + if h.shape[0] >= 64: + x = x.contiguous() + h = h.contiguous() + x = self.upsample(x) + h = self.upsample(h) + elif self.downsample is not None: + x = self.downsample(x) + h = self.downsample(h) + + h = self.conv1(h) + + if self.spatial_dims == 2: + temb = self.time_emb_proj(self.nonlinearity(emb))[:, :, None, None] + else: + temb = self.time_emb_proj(self.nonlinearity(emb))[:, :, None, None, None] + h = h + temb + + h = self.norm2(h, seg) + h = self.nonlinearity(h) + h = self.conv2(h) + + return self.skip_connection(x) + h + + +class SPADEUpBlock(nn.Module): + """ + Unet's up block containing resnet and upsamplers blocks. + Enables SPADE normalisation for semantic conditioning (Park et. al (2019): https://github.com/NVlabs/SPADE) + Args: + spatial_dims: The number of spatial dimensions. + in_channels: number of input channels. + prev_output_channel: number of channels from residual connection. + out_channels: number of output channels. + temb_channels: number of timestep embedding channels. + label_nc: number of semantic channels for SPADE normalisation. + num_res_blocks: number of residual blocks. + norm_num_groups: number of groups for the group normalization. + norm_eps: epsilon for the group normalization. + add_upsample: if True add downsample block. + resblock_updown: if True use residual blocks for upsampling. + spade_intermediate_channels: number of intermediate channels for SPADE block layer. + """ + + def __init__( + self, + spatial_dims: int, + in_channels: int, + prev_output_channel: int, + out_channels: int, + temb_channels: int, + label_nc: int, + num_res_blocks: int = 1, + norm_num_groups: int = 32, + norm_eps: float = 1e-6, + add_upsample: bool = True, + resblock_updown: bool = False, + spade_intermediate_channels: int = 128, + ) -> None: + super().__init__() + self.resblock_updown = resblock_updown + resnets = [] + + for i in range(num_res_blocks): + res_skip_channels = in_channels if (i == num_res_blocks - 1) else out_channels + resnet_in_channels = prev_output_channel if i == 0 else out_channels + + resnets.append( + SPADEResnetBlock( + spatial_dims=spatial_dims, + in_channels=resnet_in_channels + res_skip_channels, + out_channels=out_channels, + temb_channels=temb_channels, + label_nc=label_nc, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + spade_intermediate_channels=spade_intermediate_channels, + ) + ) + + self.resnets = nn.ModuleList(resnets) + + if add_upsample: + if resblock_updown: + self.upsampler = ResnetBlock( + spatial_dims=spatial_dims, + in_channels=out_channels, + out_channels=out_channels, + temb_channels=temb_channels, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + up=True, + ) + else: + self.upsampler = Upsample( + spatial_dims=spatial_dims, num_channels=out_channels, use_conv=True, out_channels=out_channels + ) + else: + self.upsampler = None + + def forward( + self, + hidden_states: torch.Tensor, + res_hidden_states_list: list[torch.Tensor], + temb: torch.Tensor, + seg: torch.Tensor, + context: torch.Tensor | None = None, + ) -> torch.Tensor: + del context + for resnet in self.resnets: + # pop res hidden states + res_hidden_states = res_hidden_states_list[-1] + res_hidden_states_list = res_hidden_states_list[:-1] + hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1) + hidden_states = resnet(hidden_states, temb, seg) + + if self.upsampler is not None: + hidden_states = self.upsampler(hidden_states, temb) + + return hidden_states + + +class SPADEAttnUpBlock(nn.Module): + """ + Unet's up block containing resnet, upsamplers, and self-attention blocks. + Enables SPADE normalisation for semantic conditioning (Park et. al (2019): https://github.com/NVlabs/SPADE) + Args: + spatial_dims: The number of spatial dimensions. + in_channels: number of input channels. + prev_output_channel: number of channels from residual connection. + out_channels: number of output channels. + temb_channels: number of timestep embedding channels. + label_nc: number of semantic channels for SPADE normalisation + num_res_blocks: number of residual blocks. + norm_num_groups: number of groups for the group normalization. + norm_eps: epsilon for the group normalization. + add_upsample: if True add downsample block. + resblock_updown: if True use residual blocks for upsampling. + num_head_channels: number of channels in each attention head. + use_flash_attention: if True, use flash attention for a memory efficient attention mechanism. + spade_intermediate_channels: number of intermediate channels for SPADE block layer + """ + + def __init__( + self, + spatial_dims: int, + in_channels: int, + prev_output_channel: int, + out_channels: int, + temb_channels: int, + label_nc: int, + num_res_blocks: int = 1, + norm_num_groups: int = 32, + norm_eps: float = 1e-6, + add_upsample: bool = True, + resblock_updown: bool = False, + num_head_channels: int = 1, + use_flash_attention: bool = False, + spade_intermediate_channels: int = 128, + ) -> None: + super().__init__() + self.resblock_updown = resblock_updown + resnets = [] + attentions = [] + + for i in range(num_res_blocks): + res_skip_channels = in_channels if (i == num_res_blocks - 1) else out_channels + resnet_in_channels = prev_output_channel if i == 0 else out_channels + + resnets.append( + SPADEResnetBlock( + spatial_dims=spatial_dims, + in_channels=resnet_in_channels + res_skip_channels, + out_channels=out_channels, + temb_channels=temb_channels, + label_nc=label_nc, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + spade_intermediate_channels=spade_intermediate_channels, + ) + ) + attentions.append( + AttentionBlock( + spatial_dims=spatial_dims, + num_channels=out_channels, + num_head_channels=num_head_channels, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + use_flash_attention=use_flash_attention, + ) + ) + + self.resnets = nn.ModuleList(resnets) + self.attentions = nn.ModuleList(attentions) + + if add_upsample: + if resblock_updown: + self.upsampler = ResnetBlock( + spatial_dims=spatial_dims, + in_channels=out_channels, + out_channels=out_channels, + temb_channels=temb_channels, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + up=True, + ) + else: + self.upsampler = Upsample( + spatial_dims=spatial_dims, num_channels=out_channels, use_conv=True, out_channels=out_channels + ) + else: + self.upsampler = None + + def forward( + self, + hidden_states: torch.Tensor, + res_hidden_states_list: list[torch.Tensor], + temb: torch.Tensor, + seg: torch.Tensor, + context: torch.Tensor | None = None, + ) -> torch.Tensor: + del context + for resnet, attn in zip(self.resnets, self.attentions): + # pop res hidden states + res_hidden_states = res_hidden_states_list[-1] + res_hidden_states_list = res_hidden_states_list[:-1] + hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1) + hidden_states = resnet(hidden_states, temb, seg) + hidden_states = attn(hidden_states) + + if self.upsampler is not None: + hidden_states = self.upsampler(hidden_states, temb) + + return hidden_states + + +class SPADECrossAttnUpBlock(nn.Module): + """ + Unet's up block containing resnet, upsamplers, and self-attention blocks. + Enables SPADE normalisation for semantic conditioning (Park et. al (2019): https://github.com/NVlabs/SPADE) + Args: + spatial_dims: The number of spatial dimensions. + in_channels: number of input channels. + prev_output_channel: number of channels from residual connection. + out_channels: number of output channels. + temb_channels: number of timestep embedding channels. + num_res_blocks: number of residual blocks. + norm_num_groups: number of groups for the group normalization. + norm_eps: epsilon for the group normalization. + add_upsample: if True add downsample block. + resblock_updown: if True use residual blocks for upsampling. + num_head_channels: number of channels in each attention head. + transformer_num_layers: number of layers of Transformer blocks to use. + cross_attention_dim: number of context dimensions to use. + upcast_attention: if True, upcast attention operations to full precision. + use_flash_attention: if True, use flash attention for a memory efficient attention mechanism. + label_nc: number of semantic channels for SPADE normalisation. + spade_intermediate_channels: number of intermediate channels for SPADE block layer. + """ + + def __init__( + self, + spatial_dims: int, + in_channels: int, + prev_output_channel: int, + out_channels: int, + temb_channels: int, + num_res_blocks: int = 1, + norm_num_groups: int = 32, + norm_eps: float = 1e-6, + add_upsample: bool = True, + resblock_updown: bool = False, + num_head_channels: int = 1, + transformer_num_layers: int = 1, + cross_attention_dim: int | None = None, + upcast_attention: bool = False, + use_flash_attention: bool = False, + label_nc: int | None = None, + spade_intermediate_channels: int = 128, + ) -> None: + super().__init__() + self.resblock_updown = resblock_updown + resnets = [] + attentions = [] + + for i in range(num_res_blocks): + res_skip_channels = in_channels if (i == num_res_blocks - 1) else out_channels + resnet_in_channels = prev_output_channel if i == 0 else out_channels + + resnets.append( + SPADEResnetBlock( + spatial_dims=spatial_dims, + in_channels=resnet_in_channels + res_skip_channels, + out_channels=out_channels, + temb_channels=temb_channels, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + label_nc=label_nc, + spade_intermediate_channels=spade_intermediate_channels, + ) + ) + attentions.append( + SpatialTransformer( + spatial_dims=spatial_dims, + in_channels=out_channels, + num_attention_heads=out_channels // num_head_channels, + num_head_channels=num_head_channels, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + num_layers=transformer_num_layers, + cross_attention_dim=cross_attention_dim, + upcast_attention=upcast_attention, + use_flash_attention=use_flash_attention, + ) + ) + + self.attentions = nn.ModuleList(attentions) + self.resnets = nn.ModuleList(resnets) + + if add_upsample: + if resblock_updown: + self.upsampler = ResnetBlock( + spatial_dims=spatial_dims, + in_channels=out_channels, + out_channels=out_channels, + temb_channels=temb_channels, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + up=True, + ) + else: + self.upsampler = Upsample( + spatial_dims=spatial_dims, num_channels=out_channels, use_conv=True, out_channels=out_channels + ) + else: + self.upsampler = None + + def forward( + self, + hidden_states: torch.Tensor, + res_hidden_states_list: list[torch.Tensor], + temb: torch.Tensor, + seg: torch.Tensor | None = None, + context: torch.Tensor | None = None, + ) -> torch.Tensor: + for resnet, attn in zip(self.resnets, self.attentions): + # pop res hidden states + res_hidden_states = res_hidden_states_list[-1] + res_hidden_states_list = res_hidden_states_list[:-1] + hidden_states = torch.cat([hidden_states, res_hidden_states], dim=1) + hidden_states = resnet(hidden_states, temb, seg) + hidden_states = attn(hidden_states, context=context) + + if self.upsampler is not None: + hidden_states = self.upsampler(hidden_states, temb) + + return hidden_states + + +def get_spade_up_block( + spatial_dims: int, + in_channels: int, + prev_output_channel: int, + out_channels: int, + temb_channels: int, + num_res_blocks: int, + norm_num_groups: int, + norm_eps: float, + add_upsample: bool, + resblock_updown: bool, + with_attn: bool, + with_cross_attn: bool, + num_head_channels: int, + transformer_num_layers: int, + label_nc: int, + cross_attention_dim: int | None, + upcast_attention: bool = False, + use_flash_attention: bool = False, + spade_intermediate_channels: int = 128, +) -> nn.Module: + if with_attn: + return SPADEAttnUpBlock( + spatial_dims=spatial_dims, + in_channels=in_channels, + prev_output_channel=prev_output_channel, + out_channels=out_channels, + temb_channels=temb_channels, + label_nc=label_nc, + num_res_blocks=num_res_blocks, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + add_upsample=add_upsample, + resblock_updown=resblock_updown, + num_head_channels=num_head_channels, + use_flash_attention=use_flash_attention, + spade_intermediate_channels=spade_intermediate_channels, + ) + elif with_cross_attn: + return SPADECrossAttnUpBlock( + spatial_dims=spatial_dims, + in_channels=in_channels, + prev_output_channel=prev_output_channel, + out_channels=out_channels, + temb_channels=temb_channels, + label_nc=label_nc, + num_res_blocks=num_res_blocks, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + add_upsample=add_upsample, + resblock_updown=resblock_updown, + num_head_channels=num_head_channels, + transformer_num_layers=transformer_num_layers, + cross_attention_dim=cross_attention_dim, + upcast_attention=upcast_attention, + use_flash_attention=use_flash_attention, + spade_intermediate_channels=spade_intermediate_channels, + ) + else: + return SPADEUpBlock( + spatial_dims=spatial_dims, + in_channels=in_channels, + prev_output_channel=prev_output_channel, + out_channels=out_channels, + temb_channels=temb_channels, + label_nc=label_nc, + num_res_blocks=num_res_blocks, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + add_upsample=add_upsample, + resblock_updown=resblock_updown, + spade_intermediate_channels=spade_intermediate_channels, + ) + + +class SPADEDiffusionModelUNet(nn.Module): + """ + Unet network with timestep embedding and attention mechanisms for conditioning based on + Rombach et al. "High-Resolution Image Synthesis with Latent Diffusion Models" https://arxiv.org/abs/2112.10752 + and Pinaya et al. "Brain Imaging Generation with Latent Diffusion Models" https://arxiv.org/abs/2209.07162 + Enables SPADE normalisation for semantic conditioning (Park et. al (2019): https://github.com/NVlabs/SPADE) + + Args: + spatial_dims: number of spatial dimensions. + in_channels: number of input channels. + out_channels: number of output channels. + label_nc: number of semantic channels for SPADE normalisation. + num_res_blocks: number of residual blocks (see ResnetBlock) per level. + num_channels: tuple of block output channels. + attention_levels: list of levels to add attention. + norm_num_groups: number of groups for the normalization. + norm_eps: epsilon for the normalization. + resblock_updown: if True use residual blocks for up/downsampling. + num_head_channels: number of channels in each attention head. + with_conditioning: if True add spatial transformers to perform conditioning. + transformer_num_layers: number of layers of Transformer blocks to use. + cross_attention_dim: number of context dimensions to use. + num_class_embeds: if specified (as an int), then this model will be class-conditional with `num_class_embeds` + classes. + upcast_attention: if True, upcast attention operations to full precision. + use_flash_attention: if True, use flash attention for a memory efficient attention mechanism. + spade_intermediate_channels: number of intermediate channels for SPADE block layer + """ + + def __init__( + self, + spatial_dims: int, + in_channels: int, + out_channels: int, + label_nc: int, + num_res_blocks: Sequence[int] | int = (2, 2, 2, 2), + num_channels: Sequence[int] = (32, 64, 64, 64), + attention_levels: Sequence[bool] = (False, False, True, True), + norm_num_groups: int = 32, + norm_eps: float = 1e-6, + resblock_updown: bool = False, + num_head_channels: int | Sequence[int] = 8, + with_conditioning: bool = False, + transformer_num_layers: int = 1, + cross_attention_dim: int | None = None, + num_class_embeds: int | None = None, + upcast_attention: bool = False, + use_flash_attention: bool = False, + spade_intermediate_channels: int = 128, + ) -> None: + super().__init__() + if with_conditioning is True and cross_attention_dim is None: + raise ValueError( + "SPADEDiffusionModelUNet expects dimension of the cross-attention conditioning (cross_attention_dim) " + "when using with_conditioning." + ) + if cross_attention_dim is not None and with_conditioning is False: + raise ValueError( + "SPADEDiffusionModelUNet expects with_conditioning=True when specifying the cross_attention_dim." + ) + + # All number of channels should be multiple of num_groups + if any((out_channel % norm_num_groups) != 0 for out_channel in num_channels): + raise ValueError("SPADEDiffusionModelUNet expects all num_channels being multiple of norm_num_groups") + + if len(num_channels) != len(attention_levels): + raise ValueError("SPADEDiffusionModelUNet expects num_channels being same size of attention_levels") + + if isinstance(num_head_channels, int): + num_head_channels = ensure_tuple_rep(num_head_channels, len(attention_levels)) + + if len(num_head_channels) != len(attention_levels): + raise ValueError( + "num_head_channels should have the same length as attention_levels. For the i levels without attention," + " i.e. `attention_level[i]=False`, the num_head_channels[i] will be ignored." + ) + + if isinstance(num_res_blocks, int): + num_res_blocks = ensure_tuple_rep(num_res_blocks, len(num_channels)) + + if len(num_res_blocks) != len(num_channels): + raise ValueError( + "`num_res_blocks` should be a single integer or a tuple of integers with the same length as " + "`num_channels`." + ) + + if use_flash_attention and not has_xformers: + raise ValueError("use_flash_attention is True but xformers is not installed.") + + if use_flash_attention is True and not torch.cuda.is_available(): + raise ValueError( + "torch.cuda.is_available() should be True but is False. Flash attention is only available for GPU." + ) + + self.in_channels = in_channels + self.block_out_channels = num_channels + self.out_channels = out_channels + self.num_res_blocks = num_res_blocks + self.attention_levels = attention_levels + self.num_head_channels = num_head_channels + self.with_conditioning = with_conditioning + self.label_nc = label_nc + + # input + self.conv_in = Convolution( + spatial_dims=spatial_dims, + in_channels=in_channels, + out_channels=num_channels[0], + strides=1, + kernel_size=3, + padding=1, + conv_only=True, + ) + + # time + time_embed_dim = num_channels[0] * 4 + self.time_embed = nn.Sequential( + nn.Linear(num_channels[0], time_embed_dim), nn.SiLU(), nn.Linear(time_embed_dim, time_embed_dim) + ) + + # class embedding + self.num_class_embeds = num_class_embeds + if num_class_embeds is not None: + self.class_embedding = nn.Embedding(num_class_embeds, time_embed_dim) + + # down + self.down_blocks = nn.ModuleList([]) + output_channel = num_channels[0] + for i in range(len(num_channels)): + input_channel = output_channel + output_channel = num_channels[i] + is_final_block = i == len(num_channels) - 1 + + down_block = get_down_block( + spatial_dims=spatial_dims, + in_channels=input_channel, + out_channels=output_channel, + temb_channels=time_embed_dim, + num_res_blocks=num_res_blocks[i], + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + add_downsample=not is_final_block, + resblock_updown=resblock_updown, + with_attn=(attention_levels[i] and not with_conditioning), + with_cross_attn=(attention_levels[i] and with_conditioning), + num_head_channels=num_head_channels[i], + transformer_num_layers=transformer_num_layers, + cross_attention_dim=cross_attention_dim, + upcast_attention=upcast_attention, + use_flash_attention=use_flash_attention, + ) + + self.down_blocks.append(down_block) + + # mid + self.middle_block = get_mid_block( + spatial_dims=spatial_dims, + in_channels=num_channels[-1], + temb_channels=time_embed_dim, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + with_conditioning=with_conditioning, + num_head_channels=num_head_channels[-1], + transformer_num_layers=transformer_num_layers, + cross_attention_dim=cross_attention_dim, + upcast_attention=upcast_attention, + use_flash_attention=use_flash_attention, + ) + + # up + self.up_blocks = nn.ModuleList([]) + reversed_block_out_channels = list(reversed(num_channels)) + reversed_num_res_blocks = list(reversed(num_res_blocks)) + reversed_attention_levels = list(reversed(attention_levels)) + reversed_num_head_channels = list(reversed(num_head_channels)) + output_channel = reversed_block_out_channels[0] + for i in range(len(reversed_block_out_channels)): + prev_output_channel = output_channel + output_channel = reversed_block_out_channels[i] + input_channel = reversed_block_out_channels[min(i + 1, len(num_channels) - 1)] + + is_final_block = i == len(num_channels) - 1 + + up_block = get_spade_up_block( + spatial_dims=spatial_dims, + in_channels=input_channel, + prev_output_channel=prev_output_channel, + out_channels=output_channel, + temb_channels=time_embed_dim, + num_res_blocks=reversed_num_res_blocks[i] + 1, + norm_num_groups=norm_num_groups, + norm_eps=norm_eps, + add_upsample=not is_final_block, + resblock_updown=resblock_updown, + with_attn=(reversed_attention_levels[i] and not with_conditioning), + with_cross_attn=(reversed_attention_levels[i] and with_conditioning), + num_head_channels=reversed_num_head_channels[i], + transformer_num_layers=transformer_num_layers, + cross_attention_dim=cross_attention_dim, + upcast_attention=upcast_attention, + use_flash_attention=use_flash_attention, + label_nc=label_nc, + spade_intermediate_channels=spade_intermediate_channels, + ) + + self.up_blocks.append(up_block) + + # out + self.out = nn.Sequential( + nn.GroupNorm(num_groups=norm_num_groups, num_channels=num_channels[0], eps=norm_eps, affine=True), + nn.SiLU(), + zero_module( + Convolution( + spatial_dims=spatial_dims, + in_channels=num_channels[0], + out_channels=out_channels, + strides=1, + kernel_size=3, + padding=1, + conv_only=True, + ) + ), + ) + + def forward( + self, + x: torch.Tensor, + timesteps: torch.Tensor, + seg: torch.Tensor, + context: torch.Tensor | None = None, + class_labels: torch.Tensor | None = None, + down_block_additional_residuals: tuple[torch.Tensor] | None = None, + mid_block_additional_residual: torch.Tensor | None = None, + ) -> torch.Tensor: + """ + Args: + x: input tensor (N, C, SpatialDims). + timesteps: timestep tensor (N,). + seg: Bx[LABEL_NC]x[SPATIAL DIMENSIONS] tensor of segmentations for SPADE norm. + context: context tensor (N, 1, ContextDim). + class_labels: context tensor (N, ). + down_block_additional_residuals: additional residual tensors for down blocks (N, C, FeatureMapsDims). + mid_block_additional_residual: additional residual tensor for mid block (N, C, FeatureMapsDims). + """ + # 1. time + t_emb = get_timestep_embedding(timesteps, self.block_out_channels[0]) + + # timesteps does not contain any weights and will always return f32 tensors + # but time_embedding might actually be running in fp16. so we need to cast here. + # there might be better ways to encapsulate this. + t_emb = t_emb.to(dtype=x.dtype) + emb = self.time_embed(t_emb) + + # 2. class + if self.num_class_embeds is not None: + if class_labels is None: + raise ValueError("class_labels should be provided when num_class_embeds > 0") + class_emb = self.class_embedding(class_labels) + class_emb = class_emb.to(dtype=x.dtype) + emb = emb + class_emb + + # 3. initial convolution + h = self.conv_in(x) + + # 4. down + if context is not None and self.with_conditioning is False: + raise ValueError("model should have with_conditioning = True if context is provided") + down_block_res_samples: list[torch.Tensor] = [h] + for downsample_block in self.down_blocks: + h, res_samples = downsample_block(hidden_states=h, temb=emb, context=context) + for residual in res_samples: + down_block_res_samples.append(residual) + + # Additional residual conections for Controlnets + if down_block_additional_residuals is not None: + new_down_block_res_samples = () + for down_block_res_sample, down_block_additional_residual in zip( + down_block_res_samples, down_block_additional_residuals + ): + down_block_res_sample = down_block_res_sample + down_block_additional_residual + new_down_block_res_samples += (down_block_res_sample,) + + down_block_res_samples = new_down_block_res_samples + + # 5. mid + h = self.middle_block(hidden_states=h, temb=emb, context=context) + + # Additional residual conections for Controlnets + if mid_block_additional_residual is not None: + h = h + mid_block_additional_residual + + # 6. up + for upsample_block in self.up_blocks: + res_samples = down_block_res_samples[-len(upsample_block.resnets) :] + down_block_res_samples = down_block_res_samples[: -len(upsample_block.resnets)] + h = upsample_block(hidden_states=h, res_hidden_states_list=res_samples, seg=seg, temb=emb, context=context) + + # 7. output block + h = self.out(h) + + return h diff --git a/tests/test_diffusion_model_unet.py b/tests/test_diffusion_model_unet.py index 976e88d4..6d32149f 100644 --- a/tests/test_diffusion_model_unet.py +++ b/tests/test_diffusion_model_unet.py @@ -245,7 +245,7 @@ "with_conditioning": True, "transformer_num_layers": 1, "cross_attention_dim": 3, - "dropout_cattn": 0.25 + "dropout_cattn": 0.25, } ], [ @@ -260,7 +260,7 @@ "norm_num_groups": 8, "with_conditioning": True, "transformer_num_layers": 1, - "cross_attention_dim": 3 + "cross_attention_dim": 3, } ], ] @@ -279,9 +279,9 @@ "with_conditioning": True, "transformer_num_layers": 1, "cross_attention_dim": 3, - "dropout_cattn": 3.0 + "dropout_cattn": 3.0, } - ], + ] ] @@ -588,6 +588,5 @@ def test_right_dropout(self, input_param): _ = DiffusionModelUNet(**input_param) - if __name__ == "__main__": unittest.main() diff --git a/tests/test_latent_diffusion_inferer.py b/tests/test_latent_diffusion_inferer.py index ba607c34..3b5e8833 100644 --- a/tests/test_latent_diffusion_inferer.py +++ b/tests/test_latent_diffusion_inferer.py @@ -17,7 +17,13 @@ from parameterized import parameterized from generative.inferers import LatentDiffusionInferer -from generative.networks.nets import VQVAE, AutoencoderKL, DiffusionModelUNet +from generative.networks.nets import ( + VQVAE, + AutoencoderKL, + DiffusionModelUNet, + SPADEAutoencoderKL, + SPADEDiffusionModelUNet, +) from generative.networks.schedulers import DDPMScheduler TEST_CASES = [ @@ -35,6 +41,7 @@ "with_decoder_nonlocal_attn": False, "norm_num_groups": 4, }, + "DiffusionModelUNet", { "spatial_dims": 2, "in_channels": 3, @@ -62,6 +69,7 @@ "num_embeddings": 16, "embedding_dim": 3, }, + "DiffusionModelUNet", { "spatial_dims": 2, "in_channels": 3, @@ -89,6 +97,7 @@ "num_embeddings": 16, "embedding_dim": 3, }, + "DiffusionModelUNet", { "spatial_dims": 3, "in_channels": 3, @@ -118,6 +127,7 @@ "with_decoder_nonlocal_attn": False, "norm_num_groups": 4, }, + "DiffusionModelUNet", { "spatial_dims": 2, "in_channels": 3, @@ -145,6 +155,7 @@ "num_embeddings": 16, "embedding_dim": 3, }, + "DiffusionModelUNet", { "spatial_dims": 2, "in_channels": 3, @@ -172,6 +183,7 @@ "num_embeddings": 16, "embedding_dim": 3, }, + "DiffusionModelUNet", { "spatial_dims": 3, "in_channels": 3, @@ -185,17 +197,110 @@ (1, 1, 12, 12, 12), (1, 3, 8, 8, 8), ], + [ + "SPADEAutoencoderKL", + { + "spatial_dims": 2, + "label_nc": 3, + "in_channels": 1, + "out_channels": 1, + "num_channels": (4, 4), + "latent_channels": 3, + "attention_levels": [False, False], + "num_res_blocks": 1, + "with_encoder_nonlocal_attn": False, + "with_decoder_nonlocal_attn": False, + "norm_num_groups": 4, + }, + "DiffusionModelUNet", + { + "spatial_dims": 2, + "in_channels": 3, + "out_channels": 3, + "num_channels": [4, 4], + "norm_num_groups": 4, + "attention_levels": [False, False], + "num_res_blocks": 1, + "num_head_channels": 4, + }, + (1, 1, 8, 8), + (1, 3, 4, 4), + ], + [ + "AutoencoderKL", + { + "spatial_dims": 2, + "in_channels": 1, + "out_channels": 1, + "num_channels": (4, 4), + "latent_channels": 3, + "attention_levels": [False, False], + "num_res_blocks": 1, + "with_encoder_nonlocal_attn": False, + "with_decoder_nonlocal_attn": False, + "norm_num_groups": 4, + }, + "SPADEDiffusionModelUNet", + { + "spatial_dims": 2, + "label_nc": 3, + "in_channels": 3, + "out_channels": 3, + "num_channels": [4, 4], + "norm_num_groups": 4, + "attention_levels": [False, False], + "num_res_blocks": 1, + "num_head_channels": 4, + }, + (1, 1, 8, 8), + (1, 3, 4, 4), + ], + [ + "SPADEAutoencoderKL", + { + "spatial_dims": 2, + "label_nc": 3, + "in_channels": 1, + "out_channels": 1, + "num_channels": (4, 4), + "latent_channels": 3, + "attention_levels": [False, False], + "num_res_blocks": 1, + "with_encoder_nonlocal_attn": False, + "with_decoder_nonlocal_attn": False, + "norm_num_groups": 4, + }, + "SPADEDiffusionModelUNet", + { + "spatial_dims": 2, + "label_nc": 3, + "in_channels": 3, + "out_channels": 3, + "num_channels": [4, 4], + "norm_num_groups": 4, + "attention_levels": [False, False], + "num_res_blocks": 1, + "num_head_channels": 4, + }, + (1, 1, 8, 8), + (1, 3, 4, 4), + ], ] class TestDiffusionSamplingInferer(unittest.TestCase): @parameterized.expand(TEST_CASES) - def test_prediction_shape(self, model_type, autoencoder_params, stage_2_params, input_shape, latent_shape): - if model_type == "AutoencoderKL": + def test_prediction_shape( + self, ae_model_type, autoencoder_params, dm_model_type, stage_2_params, input_shape, latent_shape + ): + if ae_model_type == "AutoencoderKL": stage_1 = AutoencoderKL(**autoencoder_params) - if model_type == "VQVAE": + if ae_model_type == "VQVAE": stage_1 = VQVAE(**autoencoder_params) - stage_2 = DiffusionModelUNet(**stage_2_params) + if dm_model_type == "SPADEDiffusionModelUNet": + stage_2 = SPADEDiffusionModelUNet(**stage_2_params) + else: + stage_2 = DiffusionModelUNet(**stage_2_params) device = "cuda:0" if torch.cuda.is_available() else "cpu" stage_1.to(device) @@ -208,20 +313,41 @@ def test_prediction_shape(self, model_type, autoencoder_params, stage_2_params, scheduler = DDPMScheduler(num_train_timesteps=10) inferer = LatentDiffusionInferer(scheduler=scheduler, scale_factor=1.0) scheduler.set_timesteps(num_inference_steps=10) - timesteps = torch.randint(0, scheduler.num_train_timesteps, (input_shape[0],), device=input.device).long() - prediction = inferer( - inputs=input, autoencoder_model=stage_1, diffusion_model=stage_2, noise=noise, timesteps=timesteps - ) + + if dm_model_type == "SPADEDiffusionModelUNet": + input_shape_seg = list(input_shape) + if "label_nc" in stage_2_params.keys(): + input_shape_seg[1] = stage_2_params["label_nc"] + else: + input_shape_seg[1] = autoencoder_params["label_nc"] + input_seg = torch.randn(input_shape_seg).to(device) + prediction = inferer( + inputs=input, + autoencoder_model=stage_1, + diffusion_model=stage_2, + seg=input_seg, + noise=noise, + timesteps=timesteps, + ) + else: + prediction = inferer( + inputs=input, autoencoder_model=stage_1, diffusion_model=stage_2, noise=noise, timesteps=timesteps + ) self.assertEqual(prediction.shape, latent_shape) @parameterized.expand(TEST_CASES) - def test_sample_shape(self, model_type, autoencoder_params, stage_2_params, input_shape, latent_shape): - if model_type == "AutoencoderKL": + def test_sample_shape( + self, ae_model_type, autoencoder_params, dm_model_type, stage_2_params, input_shape, latent_shape + ): + if ae_model_type == "AutoencoderKL": stage_1 = AutoencoderKL(**autoencoder_params) - if model_type == "VQVAE": + if ae_model_type == "VQVAE": stage_1 = VQVAE(**autoencoder_params) - stage_2 = DiffusionModelUNet(**stage_2_params) + if dm_model_type == "SPADEDiffusionModelUNet": + stage_2 = SPADEDiffusionModelUNet(**stage_2_params) + else: + stage_2 = DiffusionModelUNet(**stage_2_params) device = "cuda:0" if torch.cuda.is_available() else "cpu" stage_1.to(device) @@ -234,18 +360,40 @@ def test_sample_shape(self, model_type, autoencoder_params, stage_2_params, inpu inferer = LatentDiffusionInferer(scheduler=scheduler, scale_factor=1.0) scheduler.set_timesteps(num_inference_steps=10) - sample = inferer.sample( - input_noise=noise, autoencoder_model=stage_1, diffusion_model=stage_2, scheduler=scheduler - ) + if ae_model_type == "SPADEAutoencoderKL" or dm_model_type == "SPADEDiffusionModelUNet": + input_shape_seg = list(input_shape) + if "label_nc" in stage_2_params.keys(): + input_shape_seg[1] = stage_2_params["label_nc"] + else: + input_shape_seg[1] = autoencoder_params["label_nc"] + input_seg = torch.randn(input_shape_seg).to(device) + sample = inferer.sample( + input_noise=noise, + autoencoder_model=stage_1, + diffusion_model=stage_2, + scheduler=scheduler, + seg=input_seg, + ) + else: + sample = inferer.sample( + input_noise=noise, autoencoder_model=stage_1, diffusion_model=stage_2, scheduler=scheduler + ) self.assertEqual(sample.shape, input_shape) @parameterized.expand(TEST_CASES) - def test_sample_intermediates(self, model_type, autoencoder_params, stage_2_params, input_shape, latent_shape): - if model_type == "AutoencoderKL": + def test_sample_intermediates( + self, ae_model_type, autoencoder_params, dm_model_type, stage_2_params, input_shape, latent_shape + ): + if ae_model_type == "AutoencoderKL": stage_1 = AutoencoderKL(**autoencoder_params) - if model_type == "VQVAE": + if ae_model_type == "VQVAE": stage_1 = VQVAE(**autoencoder_params) - stage_2 = DiffusionModelUNet(**stage_2_params) + if ae_model_type == "SPADEAutoencoderKL": + stage_1 = SPADEAutoencoderKL(**autoencoder_params) + if dm_model_type == "SPADEDiffusionModelUNet": + stage_2 = SPADEDiffusionModelUNet(**stage_2_params) + else: + stage_2 = DiffusionModelUNet(**stage_2_params) device = "cuda:0" if torch.cuda.is_available() else "cpu" stage_1.to(device) @@ -258,24 +406,46 @@ def test_sample_intermediates(self, model_type, autoencoder_params, stage_2_para inferer = LatentDiffusionInferer(scheduler=scheduler, scale_factor=1.0) scheduler.set_timesteps(num_inference_steps=10) - sample, intermediates = inferer.sample( - input_noise=noise, - autoencoder_model=stage_1, - diffusion_model=stage_2, - scheduler=scheduler, - save_intermediates=True, - intermediate_steps=1, - ) + if ae_model_type == "SPADEAutoencoderKL" or dm_model_type == "SPADEDiffusionModelUNet": + input_shape_seg = list(input_shape) + if "label_nc" in stage_2_params.keys(): + input_shape_seg[1] = stage_2_params["label_nc"] + else: + input_shape_seg[1] = autoencoder_params["label_nc"] + input_seg = torch.randn(input_shape_seg).to(device) + sample = inferer.sample( + input_noise=noise, + autoencoder_model=stage_1, + diffusion_model=stage_2, + scheduler=scheduler, + seg=input_seg, + ) + else: + sample, intermediates = inferer.sample( + input_noise=noise, + autoencoder_model=stage_1, + diffusion_model=stage_2, + scheduler=scheduler, + save_intermediates=True, + intermediate_steps=1, + ) self.assertEqual(len(intermediates), 10) self.assertEqual(intermediates[0].shape, input_shape) @parameterized.expand(TEST_CASES) - def test_get_likelihoods(self, model_type, autoencoder_params, stage_2_params, input_shape, latent_shape): - if model_type == "AutoencoderKL": + def test_get_likelihoods( + self, ae_model_type, autoencoder_params, dm_model_type, stage_2_params, input_shape, latent_shape + ): + if ae_model_type == "AutoencoderKL": stage_1 = AutoencoderKL(**autoencoder_params) - if model_type == "VQVAE": + if ae_model_type == "VQVAE": stage_1 = VQVAE(**autoencoder_params) - stage_2 = DiffusionModelUNet(**stage_2_params) + if ae_model_type == "SPADEAutoencoderKL": + stage_1 = SPADEAutoencoderKL(**autoencoder_params) + if dm_model_type == "SPADEDiffusionModelUNet": + stage_2 = SPADEDiffusionModelUNet(**stage_2_params) + else: + stage_2 = DiffusionModelUNet(**stage_2_params) device = "cuda:0" if torch.cuda.is_available() else "cpu" stage_1.to(device) @@ -288,23 +458,46 @@ def test_get_likelihoods(self, model_type, autoencoder_params, stage_2_params, i inferer = LatentDiffusionInferer(scheduler=scheduler, scale_factor=1.0) scheduler.set_timesteps(num_inference_steps=10) - sample, intermediates = inferer.get_likelihood( - inputs=input, - autoencoder_model=stage_1, - diffusion_model=stage_2, - scheduler=scheduler, - save_intermediates=True, - ) + if dm_model_type == "SPADEDiffusionModelUNet": + input_shape_seg = list(input_shape) + if "label_nc" in stage_2_params.keys(): + input_shape_seg[1] = stage_2_params["label_nc"] + else: + input_shape_seg[1] = autoencoder_params["label_nc"] + input_seg = torch.randn(input_shape_seg).to(device) + sample, intermediates = inferer.get_likelihood( + inputs=input, + autoencoder_model=stage_1, + diffusion_model=stage_2, + scheduler=scheduler, + save_intermediates=True, + seg=input_seg, + ) + else: + sample, intermediates = inferer.get_likelihood( + inputs=input, + autoencoder_model=stage_1, + diffusion_model=stage_2, + scheduler=scheduler, + save_intermediates=True, + ) self.assertEqual(len(intermediates), 10) self.assertEqual(intermediates[0].shape, latent_shape) @parameterized.expand(TEST_CASES) - def test_resample_likelihoods(self, model_type, autoencoder_params, stage_2_params, input_shape, latent_shape): - if model_type == "AutoencoderKL": + def test_resample_likelihoods( + self, ae_model_type, autoencoder_params, dm_model_type, stage_2_params, input_shape, latent_shape + ): + if ae_model_type == "AutoencoderKL": stage_1 = AutoencoderKL(**autoencoder_params) - if model_type == "VQVAE": + if ae_model_type == "VQVAE": stage_1 = VQVAE(**autoencoder_params) - stage_2 = DiffusionModelUNet(**stage_2_params) + if ae_model_type == "SPADEAutoencoderKL": + stage_1 = SPADEAutoencoderKL(**autoencoder_params) + if dm_model_type == "SPADEDiffusionModelUNet": + stage_2 = SPADEDiffusionModelUNet(**stage_2_params) + else: + stage_2 = DiffusionModelUNet(**stage_2_params) device = "cuda:0" if torch.cuda.is_available() else "cpu" stage_1.to(device) @@ -317,30 +510,51 @@ def test_resample_likelihoods(self, model_type, autoencoder_params, stage_2_para inferer = LatentDiffusionInferer(scheduler=scheduler, scale_factor=1.0) scheduler.set_timesteps(num_inference_steps=10) - sample, intermediates = inferer.get_likelihood( - inputs=input, - autoencoder_model=stage_1, - diffusion_model=stage_2, - scheduler=scheduler, - save_intermediates=True, - resample_latent_likelihoods=True, - ) + if dm_model_type == "SPADEDiffusionModelUNet": + input_shape_seg = list(input_shape) + if "label_nc" in stage_2_params.keys(): + input_shape_seg[1] = stage_2_params["label_nc"] + else: + input_shape_seg[1] = autoencoder_params["label_nc"] + input_seg = torch.randn(input_shape_seg).to(device) + sample, intermediates = inferer.get_likelihood( + inputs=input, + autoencoder_model=stage_1, + diffusion_model=stage_2, + scheduler=scheduler, + save_intermediates=True, + resample_latent_likelihoods=True, + seg=input_seg, + ) + else: + sample, intermediates = inferer.get_likelihood( + inputs=input, + autoencoder_model=stage_1, + diffusion_model=stage_2, + scheduler=scheduler, + save_intermediates=True, + resample_latent_likelihoods=True, + ) self.assertEqual(len(intermediates), 10) self.assertEqual(intermediates[0].shape[2:], input_shape[2:]) @parameterized.expand(TEST_CASES) def test_prediction_shape_conditioned_concat( - self, model_type, autoencoder_params, stage_2_params, input_shape, latent_shape + self, ae_model_type, autoencoder_params, dm_model_type, stage_2_params, input_shape, latent_shape ): - if model_type == "AutoencoderKL": + if ae_model_type == "AutoencoderKL": stage_1 = AutoencoderKL(**autoencoder_params) - if model_type == "VQVAE": + if ae_model_type == "VQVAE": stage_1 = VQVAE(**autoencoder_params) - + if ae_model_type == "SPADEAutoencoderKL": + stage_1 = SPADEAutoencoderKL(**autoencoder_params) stage_2_params = stage_2_params.copy() n_concat_channel = 3 stage_2_params["in_channels"] = stage_2_params["in_channels"] + n_concat_channel - stage_2 = DiffusionModelUNet(**stage_2_params) + if dm_model_type == "SPADEDiffusionModelUNet": + stage_2 = SPADEDiffusionModelUNet(**stage_2_params) + else: + stage_2 = DiffusionModelUNet(**stage_2_params) device = "cuda:0" if torch.cuda.is_available() else "cpu" stage_1.to(device) @@ -359,29 +573,53 @@ def test_prediction_shape_conditioned_concat( scheduler.set_timesteps(num_inference_steps=10) timesteps = torch.randint(0, scheduler.num_train_timesteps, (input_shape[0],), device=input.device).long() - prediction = inferer( - inputs=input, - autoencoder_model=stage_1, - diffusion_model=stage_2, - noise=noise, - timesteps=timesteps, - condition=conditioning, - mode="concat", - ) + + if dm_model_type == "SPADEDiffusionModelUNet": + input_shape_seg = list(input_shape) + if "label_nc" in stage_2_params.keys(): + input_shape_seg[1] = stage_2_params["label_nc"] + else: + input_shape_seg[1] = autoencoder_params["label_nc"] + input_seg = torch.randn(input_shape_seg).to(device) + prediction = inferer( + inputs=input, + autoencoder_model=stage_1, + diffusion_model=stage_2, + noise=noise, + timesteps=timesteps, + condition=conditioning, + mode="concat", + seg=input_seg, + ) + else: + prediction = inferer( + inputs=input, + autoencoder_model=stage_1, + diffusion_model=stage_2, + noise=noise, + timesteps=timesteps, + condition=conditioning, + mode="concat", + ) self.assertEqual(prediction.shape, latent_shape) @parameterized.expand(TEST_CASES) def test_sample_shape_conditioned_concat( - self, model_type, autoencoder_params, stage_2_params, input_shape, latent_shape + self, ae_model_type, autoencoder_params, dm_model_type, stage_2_params, input_shape, latent_shape ): - if model_type == "AutoencoderKL": + if ae_model_type == "AutoencoderKL": stage_1 = AutoencoderKL(**autoencoder_params) - if model_type == "VQVAE": + if ae_model_type == "VQVAE": stage_1 = VQVAE(**autoencoder_params) + if ae_model_type == "SPADEAutoencoderKL": + stage_1 = SPADEAutoencoderKL(**autoencoder_params) stage_2_params = stage_2_params.copy() n_concat_channel = 3 stage_2_params["in_channels"] = stage_2_params["in_channels"] + n_concat_channel - stage_2 = DiffusionModelUNet(**stage_2_params) + if dm_model_type == "SPADEDiffusionModelUNet": + stage_2 = SPADEDiffusionModelUNet(**stage_2_params) + else: + stage_2 = DiffusionModelUNet(**stage_2_params) device = "cuda:0" if torch.cuda.is_available() else "cpu" stage_1.to(device) @@ -398,29 +636,47 @@ def test_sample_shape_conditioned_concat( inferer = LatentDiffusionInferer(scheduler=scheduler, scale_factor=1.0) scheduler.set_timesteps(num_inference_steps=10) - sample = inferer.sample( - input_noise=noise, - autoencoder_model=stage_1, - diffusion_model=stage_2, - scheduler=scheduler, - conditioning=conditioning, - mode="concat", - ) + if dm_model_type == "SPADEDiffusionModelUNet": + input_shape_seg = list(input_shape) + if "label_nc" in stage_2_params.keys(): + input_shape_seg[1] = stage_2_params["label_nc"] + else: + input_shape_seg[1] = autoencoder_params["label_nc"] + input_seg = torch.randn(input_shape_seg).to(device) + sample = inferer.sample( + input_noise=noise, + autoencoder_model=stage_1, + diffusion_model=stage_2, + scheduler=scheduler, + conditioning=conditioning, + mode="concat", + seg=input_seg, + ) + else: + sample = inferer.sample( + input_noise=noise, + autoencoder_model=stage_1, + diffusion_model=stage_2, + scheduler=scheduler, + conditioning=conditioning, + mode="concat", + ) self.assertEqual(sample.shape, input_shape) @parameterized.expand(TEST_CASES_DIFF_SHAPES) - def test_sample_shape_different_latents(self, - model_type, - autoencoder_params, - stage_2_params, - input_shape, - latent_shape - ): - if model_type == "AutoencoderKL": + def test_sample_shape_different_latents( + self, ae_model_type, autoencoder_params, dm_model_type, stage_2_params, input_shape, latent_shape + ): + if ae_model_type == "AutoencoderKL": stage_1 = AutoencoderKL(**autoencoder_params) - if model_type == "VQVAE": + if ae_model_type == "VQVAE": stage_1 = VQVAE(**autoencoder_params) - stage_2 = DiffusionModelUNet(**stage_2_params) + if ae_model_type == "SPADEAutoencoderKL": + stage_1 = SPADEAutoencoderKL(**autoencoder_params) + if dm_model_type == "SPADEDiffusionModelUNet": + stage_2 = SPADEDiffusionModelUNet(**stage_2_params) + else: + stage_2 = DiffusionModelUNet(**stage_2_params) device = "cuda:0" if torch.cuda.is_available() else "cpu" stage_1.to(device) @@ -432,16 +688,84 @@ def test_sample_shape_different_latents(self, noise = torch.randn(latent_shape).to(device) scheduler = DDPMScheduler(num_train_timesteps=10) # We infer the VAE shape - autoencoder_latent_shape = [i//(2**(len(autoencoder_params['num_channels'])-1)) for i in input_shape[2:]] - inferer = LatentDiffusionInferer(scheduler=scheduler, scale_factor=1.0, - ldm_latent_shape=list(latent_shape[2:]), - autoencoder_latent_shape=autoencoder_latent_shape) + autoencoder_latent_shape = [i // (2 ** (len(autoencoder_params["num_channels"]) - 1)) for i in input_shape[2:]] + inferer = LatentDiffusionInferer( + scheduler=scheduler, + scale_factor=1.0, + ldm_latent_shape=list(latent_shape[2:]), + autoencoder_latent_shape=autoencoder_latent_shape, + ) scheduler.set_timesteps(num_inference_steps=10) timesteps = torch.randint(0, scheduler.num_train_timesteps, (input_shape[0],), device=input.device).long() - prediction = inferer( - inputs=input, autoencoder_model=stage_1, diffusion_model=stage_2, noise=noise, timesteps=timesteps - ) + + if dm_model_type == "SPADEDiffusionModelUNet": + input_shape_seg = list(input_shape) + if "label_nc" in stage_2_params.keys(): + input_shape_seg[1] = stage_2_params["label_nc"] + else: + input_shape_seg[1] = autoencoder_params["label_nc"] + input_seg = torch.randn(input_shape_seg).to(device) + prediction = inferer( + inputs=input, + autoencoder_model=stage_1, + diffusion_model=stage_2, + noise=noise, + timesteps=timesteps, + seg=input_seg, + ) + else: + prediction = inferer( + inputs=input, autoencoder_model=stage_1, diffusion_model=stage_2, noise=noise, timesteps=timesteps + ) self.assertEqual(prediction.shape, latent_shape) + + def test_incompatible_spade_setup(self): + stage_1 = SPADEAutoencoderKL( + spatial_dims=2, + label_nc=6, + in_channels=1, + out_channels=1, + num_channels=(4, 4), + latent_channels=3, + attention_levels=[False, False], + num_res_blocks=1, + with_encoder_nonlocal_attn=False, + with_decoder_nonlocal_attn=False, + norm_num_groups=4, + ) + stage_2 = SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=3, + out_channels=3, + num_channels=[4, 4], + norm_num_groups=4, + attention_levels=[False, False], + num_res_blocks=1, + num_head_channels=4, + ) + + device = "cuda:0" if torch.cuda.is_available() else "cpu" + stage_1.to(device) + stage_2.to(device) + stage_1.eval() + stage_2.eval() + noise = torch.randn((1, 3, 4, 4)).to(device) + input_seg = torch.randn((1, 3, 8, 8)).to(device) + scheduler = DDPMScheduler(num_train_timesteps=10) + inferer = LatentDiffusionInferer(scheduler=scheduler, scale_factor=1.0) + scheduler.set_timesteps(num_inference_steps=10) + + with self.assertRaises(ValueError): + _ = inferer.sample( + input_noise=noise, + autoencoder_model=stage_1, + diffusion_model=stage_2, + scheduler=scheduler, + seg=input_seg, + ) + + if __name__ == "__main__": unittest.main() diff --git a/tests/test_spade_autoencoderkl.py b/tests/test_spade_autoencoderkl.py new file mode 100644 index 00000000..7e7c513e --- /dev/null +++ b/tests/test_spade_autoencoderkl.py @@ -0,0 +1,261 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +import unittest + +import torch +from monai.networks import eval_mode +from parameterized import parameterized + +from generative.networks.nets import SPADEAutoencoderKL + +CASES = [ + [ + { + "spatial_dims": 2, + "label_nc": 3, + "in_channels": 1, + "out_channels": 1, + "num_channels": (4, 4, 4), + "latent_channels": 4, + "attention_levels": (False, False, False), + "num_res_blocks": 1, + "norm_num_groups": 4, + }, + (1, 1, 16, 16), + (1, 3, 16, 16), + (1, 1, 16, 16), + (1, 4, 4, 4), + ], + [ + { + "spatial_dims": 2, + "label_nc": 3, + "in_channels": 1, + "out_channels": 1, + "num_channels": (4, 4, 4), + "latent_channels": 4, + "attention_levels": (False, False, False), + "num_res_blocks": (1, 1, 2), + "norm_num_groups": 4, + }, + (1, 1, 16, 16), + (1, 3, 16, 16), + (1, 1, 16, 16), + (1, 4, 4, 4), + ], + [ + { + "spatial_dims": 2, + "label_nc": 3, + "in_channels": 1, + "out_channels": 1, + "num_channels": (4, 4, 4), + "latent_channels": 4, + "attention_levels": (False, False, False), + "num_res_blocks": 1, + "norm_num_groups": 4, + }, + (1, 1, 16, 16), + (1, 3, 16, 16), + (1, 1, 16, 16), + (1, 4, 4, 4), + ], + [ + { + "spatial_dims": 2, + "label_nc": 3, + "in_channels": 1, + "out_channels": 1, + "num_channels": (4, 4, 4), + "latent_channels": 4, + "attention_levels": (False, False, True), + "num_res_blocks": 1, + "norm_num_groups": 4, + }, + (1, 1, 16, 16), + (1, 3, 16, 16), + (1, 1, 16, 16), + (1, 4, 4, 4), + ], + [ + { + "spatial_dims": 2, + "label_nc": 3, + "in_channels": 1, + "out_channels": 1, + "num_channels": (4, 4, 4), + "latent_channels": 4, + "attention_levels": (False, False, False), + "num_res_blocks": 1, + "norm_num_groups": 4, + "with_encoder_nonlocal_attn": False, + }, + (1, 1, 16, 16), + (1, 3, 16, 16), + (1, 1, 16, 16), + (1, 4, 4, 4), + ], + [ + { + "spatial_dims": 2, + "label_nc": 3, + "in_channels": 1, + "out_channels": 1, + "num_channels": (4, 4, 4), + "latent_channels": 4, + "attention_levels": (False, False, False), + "num_res_blocks": 1, + "norm_num_groups": 4, + "with_encoder_nonlocal_attn": False, + "with_decoder_nonlocal_attn": False, + }, + (1, 1, 16, 16), + (1, 3, 16, 16), + (1, 1, 16, 16), + (1, 4, 4, 4), + ], + [ + { + "spatial_dims": 3, + "label_nc": 3, + "in_channels": 1, + "out_channels": 1, + "num_channels": (4, 4, 4), + "latent_channels": 4, + "attention_levels": (False, False, True), + "num_res_blocks": 1, + "norm_num_groups": 4, + }, + (1, 1, 16, 16, 16), + (1, 3, 16, 16, 16), + (1, 1, 16, 16, 16), + (1, 4, 4, 4, 4), + ], + [ + { + "spatial_dims": 2, + "label_nc": 3, + "in_channels": 1, + "out_channels": 1, + "num_channels": (4, 4, 4), + "latent_channels": 4, + "attention_levels": (False, False, True), + "num_res_blocks": 1, + "norm_num_groups": 4, + "label_nc": 3, + "spade_intermediate_channels": 32, + }, + (1, 1, 16, 16), + (1, 3, 16, 16), + (1, 1, 16, 16), + (1, 4, 4, 4), + ], +] + +device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") + + +class TestSPADEAutoEncoderKL(unittest.TestCase): + @parameterized.expand(CASES) + def test_shape(self, input_param, input_shape, input_seg, expected_shape, expected_latent_shape): + net = SPADEAutoencoderKL(**input_param).to(device) + with eval_mode(net): + result = net.forward(torch.randn(input_shape).to(device), torch.randn(input_seg).to(device)) + self.assertEqual(result[0].shape, expected_shape) + self.assertEqual(result[1].shape, expected_latent_shape) + + def test_model_channels_not_multiple_of_norm_num_group(self): + with self.assertRaises(ValueError): + SPADEAutoencoderKL( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_channels=(24, 24, 24), + attention_levels=(False, False, False), + latent_channels=8, + num_res_blocks=1, + norm_num_groups=16, + ) + + def test_model_num_channels_not_same_size_of_attention_levels(self): + with self.assertRaises(ValueError): + SPADEAutoencoderKL( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_channels=(24, 24, 24), + attention_levels=(False, False), + latent_channels=8, + num_res_blocks=1, + norm_num_groups=16, + ) + + def test_model_num_channels_not_same_size_of_num_res_blocks(self): + with self.assertRaises(ValueError): + SPADEAutoencoderKL( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_channels=(24, 24, 24), + attention_levels=(False, False, False), + latent_channels=8, + num_res_blocks=(8, 8), + norm_num_groups=16, + ) + + def test_shape_encode(self): + input_param, input_shape, _, _, expected_latent_shape = CASES[0] + net = SPADEAutoencoderKL(**input_param).to(device) + with eval_mode(net): + result = net.encode(torch.randn(input_shape).to(device)) + self.assertEqual(result[0].shape, expected_latent_shape) + self.assertEqual(result[1].shape, expected_latent_shape) + + def test_shape_sampling(self): + input_param, _, _, _, expected_latent_shape = CASES[0] + net = SPADEAutoencoderKL(**input_param).to(device) + with eval_mode(net): + result = net.sampling( + torch.randn(expected_latent_shape).to(device), torch.randn(expected_latent_shape).to(device) + ) + self.assertEqual(result.shape, expected_latent_shape) + + def test_shape_decode(self): + input_param, _, input_seg_shape, expected_input_shape, latent_shape = CASES[0] + net = SPADEAutoencoderKL(**input_param).to(device) + with eval_mode(net): + result = net.decode(torch.randn(latent_shape).to(device), torch.randn(input_seg_shape).to(device)) + self.assertEqual(result.shape, expected_input_shape) + + def test_wrong_shape_decode(self): + net = SPADEAutoencoderKL( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_channels=(4, 4, 4), + latent_channels=4, + attention_levels=(False, False, False), + num_res_blocks=1, + norm_num_groups=4, + ) + with self.assertRaises(RuntimeError): + _ = net.decode(torch.randn((1, 1, 16, 16)).to(device), torch.randn((1, 6, 16, 16)).to(device)) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_spade_diffusion_model_unet.py b/tests/test_spade_diffusion_model_unet.py new file mode 100644 index 00000000..9d0d1405 --- /dev/null +++ b/tests/test_spade_diffusion_model_unet.py @@ -0,0 +1,633 @@ +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import annotations + +import unittest + +import torch +from monai.networks import eval_mode +from parameterized import parameterized + +from generative.networks.nets import SPADEDiffusionModelUNet +from tests.utils import test_script_save + +UNCOND_CASES_2D = [ + [ + { + "spatial_dims": 2, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, False), + "norm_num_groups": 8, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 2, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": (1, 1, 2), + "num_channels": (8, 8, 8), + "attention_levels": (False, False, False), + "norm_num_groups": 8, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 2, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, False), + "norm_num_groups": 8, + "resblock_updown": True, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 2, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, True), + "num_head_channels": 8, + "norm_num_groups": 8, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 2, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, True), + "num_head_channels": 8, + "norm_num_groups": 8, + "resblock_updown": True, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 2, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, True), + "num_head_channels": 4, + "norm_num_groups": 8, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 2, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, True, True), + "num_head_channels": (0, 2, 4), + "norm_num_groups": 8, + "label_nc": 3, + } + ], +] + +UNCOND_CASES_3D = [ + [ + { + "spatial_dims": 3, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, False), + "norm_num_groups": 8, + "label_nc": 3, + "spade_intermediate_channels": 256, + } + ], + [ + { + "spatial_dims": 3, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, False), + "norm_num_groups": 8, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 3, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, False), + "norm_num_groups": 8, + "resblock_updown": True, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 3, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, True), + "num_head_channels": 8, + "norm_num_groups": 8, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 3, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, True), + "num_head_channels": 8, + "norm_num_groups": 8, + "resblock_updown": True, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 3, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, True), + "num_head_channels": 4, + "norm_num_groups": 8, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 3, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, True), + "num_head_channels": (0, 0, 4), + "norm_num_groups": 8, + "label_nc": 3, + } + ], +] + +COND_CASES_2D = [ + [ + { + "spatial_dims": 2, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, True), + "num_head_channels": 4, + "norm_num_groups": 8, + "with_conditioning": True, + "transformer_num_layers": 1, + "cross_attention_dim": 3, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 2, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, True), + "num_head_channels": 4, + "norm_num_groups": 8, + "with_conditioning": True, + "transformer_num_layers": 1, + "cross_attention_dim": 3, + "resblock_updown": True, + "label_nc": 3, + } + ], + [ + { + "spatial_dims": 2, + "in_channels": 1, + "out_channels": 1, + "num_res_blocks": 1, + "num_channels": (8, 8, 8), + "attention_levels": (False, False, True), + "num_head_channels": 4, + "norm_num_groups": 8, + "with_conditioning": True, + "transformer_num_layers": 1, + "cross_attention_dim": 3, + "upcast_attention": True, + "label_nc": 3, + } + ], +] + + +class TestSPADEDiffusionModelUNet2D(unittest.TestCase): + @parameterized.expand(UNCOND_CASES_2D) + def test_shape_unconditioned_models(self, input_param): + net = SPADEDiffusionModelUNet(**input_param) + with eval_mode(net): + result = net.forward( + torch.rand((1, 1, 16, 16)), + torch.randint(0, 1000, (1,)).long(), + torch.rand((1, input_param["label_nc"], 16, 16)), + ) + self.assertEqual(result.shape, (1, 1, 16, 16)) + + def test_timestep_with_wrong_shape(self): + net = SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, False), + norm_num_groups=8, + ) + with self.assertRaises(ValueError): + with eval_mode(net): + net.forward( + torch.rand((1, 1, 16, 16)), torch.randint(0, 1000, (1, 1)).long(), torch.rand((1, 3, 16, 16)) + ) + + def test_label_with_wrong_shape(self): + net = SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, False), + norm_num_groups=8, + ) + with self.assertRaises(RuntimeError): + with eval_mode(net): + net.forward(torch.rand((1, 1, 16, 16)), torch.randint(0, 1000, (1,)).long(), torch.rand((1, 6, 16, 16))) + + def test_shape_with_different_in_channel_out_channel(self): + in_channels = 6 + out_channels = 3 + net = SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=in_channels, + out_channels=out_channels, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, False), + norm_num_groups=8, + ) + with eval_mode(net): + result = net.forward( + torch.rand((1, in_channels, 16, 16)), torch.randint(0, 1000, (1,)).long(), torch.rand((1, 3, 16, 16)) + ) + self.assertEqual(result.shape, (1, out_channels, 16, 16)) + + def test_model_channels_not_multiple_of_norm_num_group(self): + with self.assertRaises(ValueError): + SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 12), + attention_levels=(False, False, False), + norm_num_groups=8, + ) + + def test_attention_levels_with_different_length_num_head_channels(self): + with self.assertRaises(ValueError): + SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, False), + num_head_channels=(0, 2), + norm_num_groups=8, + ) + + def test_num_res_blocks_with_different_length_num_channels(self): + with self.assertRaises(ValueError): + SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=(1, 1), + num_channels=(8, 8, 8), + attention_levels=(False, False, False), + norm_num_groups=8, + ) + + def test_shape_conditioned_models(self): + net = SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, True), + with_conditioning=True, + transformer_num_layers=1, + cross_attention_dim=3, + norm_num_groups=8, + num_head_channels=8, + ) + with eval_mode(net): + result = net.forward( + x=torch.rand((1, 1, 16, 32)), + timesteps=torch.randint(0, 1000, (1,)).long(), + seg=torch.rand((1, 3, 16, 32)), + context=torch.rand((1, 1, 3)), + ) + self.assertEqual(result.shape, (1, 1, 16, 32)) + + def test_with_conditioning_cross_attention_dim_none(self): + with self.assertRaises(ValueError): + SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, True), + with_conditioning=True, + transformer_num_layers=1, + cross_attention_dim=None, + norm_num_groups=8, + ) + + def test_context_with_conditioning_none(self): + net = SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, True), + with_conditioning=False, + transformer_num_layers=1, + norm_num_groups=8, + ) + + with self.assertRaises(ValueError): + with eval_mode(net): + net.forward( + x=torch.rand((1, 1, 16, 32)), + timesteps=torch.randint(0, 1000, (1,)).long(), + seg=torch.rand((1, 3, 16, 32)), + context=torch.rand((1, 1, 3)), + ) + + def test_shape_conditioned_models_class_conditioning(self): + net = SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, True), + norm_num_groups=8, + num_head_channels=8, + num_class_embeds=2, + ) + with eval_mode(net): + result = net.forward( + x=torch.rand((1, 1, 16, 32)), + timesteps=torch.randint(0, 1000, (1,)).long(), + seg=torch.rand((1, 3, 16, 32)), + class_labels=torch.randint(0, 2, (1,)).long(), + ) + self.assertEqual(result.shape, (1, 1, 16, 32)) + + def test_conditioned_models_no_class_labels(self): + net = SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, True), + norm_num_groups=8, + num_head_channels=8, + num_class_embeds=2, + ) + + with self.assertRaises(ValueError): + net.forward( + x=torch.rand((1, 1, 16, 32)), + timesteps=torch.randint(0, 1000, (1,)).long(), + seg=torch.rand((1, 3, 16, 32)), + ) + + def test_model_num_channels_not_same_size_of_attention_levels(self): + with self.assertRaises(ValueError): + SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False), + norm_num_groups=8, + num_head_channels=8, + num_class_embeds=2, + ) + + def test_script_unconditioned_2d_models(self): + net = SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, True), + norm_num_groups=8, + ) + test_script_save( + net, torch.rand((1, 1, 16, 16)), torch.randint(0, 1000, (1,)).long(), torch.rand((1, 3, 16, 16)) + ) + + def test_script_conditioned_2d_models(self): + net = SPADEDiffusionModelUNet( + spatial_dims=2, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, True), + norm_num_groups=8, + with_conditioning=True, + transformer_num_layers=1, + cross_attention_dim=3, + ) + test_script_save( + net, + torch.rand((1, 1, 16, 16)), + torch.randint(0, 1000, (1,)).long(), + torch.rand((1, 3, 16, 16)), + torch.rand((1, 1, 3)), + ) + + @parameterized.expand(COND_CASES_2D) + def test_conditioned_2d_models_shape(self, input_param): + net = SPADEDiffusionModelUNet(**input_param) + with eval_mode(net): + result = net.forward( + torch.rand((1, 1, 16, 16)), + torch.randint(0, 1000, (1,)).long(), + torch.rand((1, input_param["label_nc"], 16, 16)), + torch.rand((1, 1, 3)), + ) + self.assertEqual(result.shape, (1, 1, 16, 16)) + + +class TestDiffusionModelUNet3D(unittest.TestCase): + @parameterized.expand(UNCOND_CASES_3D) + def test_shape_unconditioned_models(self, input_param): + net = SPADEDiffusionModelUNet(**input_param) + with eval_mode(net): + result = net.forward( + torch.rand((1, 1, 16, 16, 16)), + torch.randint(0, 1000, (1,)).long(), + torch.rand((1, input_param["label_nc"], 16, 16, 16)), + ) + self.assertEqual(result.shape, (1, 1, 16, 16, 16)) + + def test_shape_with_different_in_channel_out_channel(self): + in_channels = 6 + out_channels = 3 + net = SPADEDiffusionModelUNet( + spatial_dims=3, + label_nc=3, + in_channels=in_channels, + out_channels=out_channels, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, True), + norm_num_groups=4, + ) + with eval_mode(net): + result = net.forward( + torch.rand((1, in_channels, 16, 16, 16)), + torch.randint(0, 1000, (1,)).long(), + torch.rand((1, 3, 16, 16, 16)), + ) + self.assertEqual(result.shape, (1, out_channels, 16, 16, 16)) + + def test_shape_conditioned_models(self): + net = SPADEDiffusionModelUNet( + spatial_dims=3, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(16, 16, 16), + attention_levels=(False, False, True), + norm_num_groups=16, + with_conditioning=True, + transformer_num_layers=1, + cross_attention_dim=3, + ) + with eval_mode(net): + result = net.forward( + x=torch.rand((1, 1, 16, 16, 16)), + timesteps=torch.randint(0, 1000, (1,)).long(), + seg=torch.rand((1, 3, 16, 16, 16)), + context=torch.rand((1, 1, 3)), + ) + self.assertEqual(result.shape, (1, 1, 16, 16, 16)) + + def test_script_unconditioned_3d_models(self): + net = SPADEDiffusionModelUNet( + spatial_dims=3, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, True), + norm_num_groups=8, + ) + test_script_save( + net, torch.rand((1, 1, 16, 16, 16)), torch.randint(0, 1000, (1,)).long(), torch.rand((1, 3, 16, 16, 16)) + ) + + def test_script_conditioned_3d_models(self): + net = SPADEDiffusionModelUNet( + spatial_dims=3, + label_nc=3, + in_channels=1, + out_channels=1, + num_res_blocks=1, + num_channels=(8, 8, 8), + attention_levels=(False, False, True), + norm_num_groups=8, + with_conditioning=True, + transformer_num_layers=1, + cross_attention_dim=3, + ) + test_script_save( + net, + torch.rand((1, 1, 16, 16, 16)), + torch.randint(0, 1000, (1,)).long(), + torch.rand((1, 3, 16, 16, 16)), + torch.rand((1, 1, 3)), + ) + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/test_spade_vaegan.py b/tests/test_spade_vaegan.py index 048549dd..3550c31e 100644 --- a/tests/test_spade_vaegan.py +++ b/tests/test_spade_vaegan.py @@ -18,7 +18,7 @@ from monai.networks import eval_mode from parameterized import parameterized -from generative.networks.nets.spade_network import SPADE_Net +from generative.networks.nets import SPADENet CASE_2D = [[[2, 1, 1, 3, [64, 64], [16, 32, 64, 128], 16, True]]] CASE_2D_BIS = [[[2, 1, 1, 3, [64, 64], [16, 32, 64, 128], 16, True]]] @@ -75,7 +75,7 @@ def test_forward_2d(self, input_param): """ Check that forward method is called correctly and output shape matches. """ - net = SPADE_Net(*input_param) + net = SPADENet(*input_param) in_label, in_image = create_semantic_data(input_param[4], input_param[3]) with eval_mode(net): out, kld = net(in_label, in_image) @@ -93,7 +93,7 @@ def test_encoder_decoder(self, input_param): """ Check that forward method is called correctly and output shape matches. """ - net = SPADE_Net(*input_param) + net = SPADENet(*input_param) in_label, in_image = create_semantic_data(input_param[4], input_param[3]) with eval_mode(net): out_z = net.encode(in_image) @@ -106,7 +106,7 @@ def test_forward_3d(self, input_param): """ Check that forward method is called correctly and output shape matches. """ - net = SPADE_Net(*input_param) + net = SPADENet(*input_param) in_label, in_image = create_semantic_data(input_param[4], input_param[3]) with eval_mode(net): out, kld = net(in_label, in_image) @@ -124,7 +124,7 @@ def test_shape_wrong(self): We input an input shape that isn't divisible by 2**(n downstream steps) """ with self.assertRaises(ValueError): - _ = SPADE_Net(1, 1, 8, [16, 16], [16, 32, 64, 128], 16, True) + _ = SPADENet(1, 1, 8, [16, 16], [16, 32, 64, 128], 16, True) if __name__ == "__main__": diff --git a/tutorials/generative/2d_spade_ldm/2d_spade_ldm.ipynb b/tutorials/generative/2d_spade_ldm/2d_spade_ldm.ipynb new file mode 100644 index 00000000..a7b4ba07 --- /dev/null +++ b/tutorials/generative/2d_spade_ldm/2d_spade_ldm.ipynb @@ -0,0 +1,1539 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "f136309d", + "metadata": {}, + "outputs": [], + "source": [ + "# Copyright (c) MONAI Consortium\n", + "# Licensed under the Apache License, Version 2.0 (the \"License\");\n", + "# you may not use this file except in compliance with the License.\n", + "# You may obtain a copy of the License at\n", + "# http://www.apache.org/licenses/LICENSE-2.0\n", + "# Unless required by applicable law or agreed to in writing, software\n", + "# distributed under the License is distributed on an \"AS IS\" BASIS,\n", + "# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n", + "# See the License for the specific language governing permissions and\n", + "# limitations under the License." + ] + }, + { + "cell_type": "markdown", + "id": "18d8580a", + "metadata": {}, + "source": [ + "# SPADE LDM" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d6f80402", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import tempfile\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "from pathlib import Path\n", + "import zipfile\n", + "import gdown\n", + "from monai.data import DataLoader\n", + "from tqdm import tqdm\n", + "from generative.losses import PatchAdversarialLoss, PerceptualLoss\n", + "import numpy as np\n", + "import monai\n", + "import torch.nn.functional as F\n", + "from generative.networks.nets import SPADEAutoencoderKL\n", + "from generative.networks.nets import SPADEDiffusionModelUNet\n", + "from generative.losses.adversarial_loss import PatchAdversarialLoss\n", + "from generative.networks.nets import PatchDiscriminator\n", + "from torch.cuda.amp import GradScaler, autocast\n", + "from generative.networks.schedulers import DDPMScheduler\n", + "from generative.inferers import LatentDiffusionInferer" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "dfaa6930", + "metadata": {}, + "outputs": [], + "source": [ + "# INPUT PARAMETERS\n", + "input_shape = [128, 128]\n", + "batch_size = 6\n", + "num_workers = 4" + ] + }, + { + "cell_type": "markdown", + "id": "b7c045b7", + "metadata": {}, + "source": [ + "### Data" + ] + }, + { + "cell_type": "markdown", + "id": "f12f4810", + "metadata": {}, + "source": [ + "The data for this notebook comes from the public dataset OASIS (Open Access Series of Imaging Studies) [1]. The images have been registered to MNI space using ANTsPy, and then subsampled to 2mm isotropic resolution. Geodesic Information Flows (GIF) [2] has been used to segment 5 regions: cerebrospinal fluid (CSF), grey matter (GM), white matter (WM), deep grey matter (DGM) and brainstem. In addition, BaMos [3] has been used to provide white matter hyperintensities segmentations (WMH). The available dataset contains:\n", + "- T1-weighted images\n", + "- FLAIR weighted images\n", + "- Segmentations with the following labels: 0 (background), 1 (CSF), 2 (GM), 3 (WM), 4 (DGM), 5 (brainstem) and 6 (WMH).\n", + "\n", + "_**Acknowledgments**: \"Data were provided by OASIS-3: Longitudinal Multimodal Neuroimaging: Principal Investigators: T. Benzinger, D. Marcus, J. Morris; NIH P30 AG066444, P50 AG00561, P30 NS09857781, P01 AG026276, P01 AG003991, R01 AG043434, UL1 TR000448, R01 EB009352. AV-45 doses were provided by Avid Radiopharmaceuticals, a wholly owned subsidiary of Eli Lilly.\u201d_\n", + "\n", + "\n", + "Citations:\n", + "\n", + "[1] Marcus, DS, Wang, TH, Parker, J, Csernansky, JG, Morris, JC, Buckner. Open Access Series of Imaging Studies (OASIS): Cross-Sectional MRI Data in Young, Middle Aged, Nondemented, and Demented Older Adults, RL. Journal of Cognitive Neuroscience, 19, 1498-1507. doi: 10.1162/jocn.2007.19.9.1498\n", + "\n", + "[2] Cardoso MJ, Modat M, Wolz R, Melbourne A, Cash D, Rueckert D, Ourselin S. Geodesic Information Flows: Spatially-Variant Graphs and Their Application to Segmentation and Fusion. IEEE Trans Med Imaging. 2015 Sep;34(9):1976-88. doi: 10.1109/TMI.2015.2418298. Epub 2015 Apr 14. PMID: 25879909.\n", + "\n", + "[3] Fiford CM, Sudre CH, Pemberton H, Walsh P, Manning E, Malone IB, Nicholas J, Bouvy WH, Carmichael OT, Biessels GJ, Cardoso MJ, Barnes J; Alzheimer\u2019s Disease Neuroimaging Initiative. Automated White Matter Hyperintensity Segmentation Using Bayesian Model Selection: Assessment and Correlations with Cognitive Change. Neuroinformatics. 2020 Jun;18(3):429-449. doi: 10.1007/s12021-019-09439-6. PMID: 32062817; PMCID: PMC7338814.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "dbe2f3af", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Temporary directory used: /tmp/tmp_4nr_pwr \n" + ] + } + ], + "source": [ + "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\n", + "root_dir = tempfile.mkdtemp() if directory is None else directory\n", + "root_dir = Path(root_dir)\n", + "print(\"Temporary directory used: %s \" % root_dir)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b616a986", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Downloading...\n", + "From: https://drive.google.com/uc?export=download&id=1SX_MCzQe-vyq09QYxECk32wZ2vxp9rx5\n", + "To: /tmp/tmp_4nr_pwr/data.zip\n", + "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 384M/384M [00:07<00:00, 51.1MB/s]\n" + ] + }, + { + "data": { + "text/plain": [ + "'/tmp/tmp_4nr_pwr/data.zip'" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gdown.download(\n", + " \"https://drive.google.com/uc?export=download&id=1SX_MCzQe-vyq09QYxECk32wZ2vxp9rx5\", str(root_dir / \"data.zip\")\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e758c8fe", + "metadata": {}, + "outputs": [], + "source": [ + "zip_obj = zipfile.ZipFile(os.path.join(root_dir, \"data.zip\"), \"r\")\n", + "zip_obj.extractall(root_dir)\n", + "images_T1 = root_dir / \"OASIS_SMALL-SUBSET/T1\"\n", + "images_FLAIR = root_dir / \"OASIS_SMALL-SUBSET/FLAIR\"\n", + "labels = root_dir / \"OASIS_SMALL-SUBSET/Segmentations\"" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "33bb9e76", + "metadata": {}, + "outputs": [], + "source": [ + "# We create the data dictionaries that we need\n", + "all_images = [os.path.join(images_T1, i) for i in os.listdir(images_T1)]\n", + "np.random.shuffle(all_images)\n", + "corresponding_labels = [\n", + " os.path.join(labels, i.split(\"/\")[-1].replace(i.split(\"/\")[-1].split(\"_\")[0], \"Parcellation\")) for i in all_images\n", + "]\n", + "input_dict = [{\"image\": i, \"label\": corresponding_labels[ind]} for ind, i in enumerate(all_images)]\n", + "input_dict_train = input_dict[: int(len(input_dict) * 0.9)]\n", + "input_dict_val = input_dict[int(len(input_dict) * 0.9) :]" + ] + }, + { + "cell_type": "markdown", + "id": "d2cc6624", + "metadata": {}, + "source": [ + "### Dataloaders" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "148a1344", + "metadata": {}, + "outputs": [], + "source": [ + "preliminar_shape = input_shape + [50] # We take random slices fron the center of the brain\n", + "crop_shape = input_shape + [1]\n", + "base_transforms = [\n", + " monai.transforms.LoadImaged(keys=[\"label\", \"image\"]),\n", + " monai.transforms.EnsureChannelFirstd(keys=[\"image\", \"label\"]),\n", + " monai.transforms.CenterSpatialCropd(keys=[\"label\", \"image\"], roi_size=preliminar_shape),\n", + " monai.transforms.RandSpatialCropd(keys=[\"label\", \"image\"], roi_size=crop_shape, max_roi_size=crop_shape),\n", + " monai.transforms.SqueezeDimd(keys=[\"label\", \"image\"], dim=-1),\n", + " monai.transforms.Resized(keys=[\"image\", \"label\"], spatial_size=input_shape),\n", + "]\n", + "last_transforms = [\n", + " monai.transforms.CopyItemsd(keys=[\"label\"], names=[\"label_channel\"]),\n", + " monai.transforms.Lambdad(keys=[\"label_channel\"], func=lambda l: l != 0),\n", + " monai.transforms.MaskIntensityd(keys=[\"image\"], mask_key=\"label_channel\"),\n", + " monai.transforms.NormalizeIntensityd(keys=[\"image\"]),\n", + " monai.transforms.ToTensord(keys=[\"image\", \"label\"]),\n", + "]\n", + "\n", + "aug_transforms = [\n", + " monai.transforms.RandBiasFieldd(coeff_range=(0, 0.005), prob=0.33, keys=[\"image\"]),\n", + " monai.transforms.RandAdjustContrastd(gamma=(0.9, 1.15), prob=0.33, keys=[\"image\"]),\n", + " monai.transforms.RandGaussianNoised(prob=0.33, mean=0.0, std=np.random.uniform(0.005, 0.015), keys=[\"image\"]),\n", + " monai.transforms.RandAffined(\n", + " rotate_range=[-0.05, 0.05],\n", + " shear_range=[0.001, 0.05],\n", + " scale_range=[0, 0.05],\n", + " padding_mode=\"zeros\",\n", + " mode=\"nearest\",\n", + " prob=0.33,\n", + " keys=[\"label\", \"image\"],\n", + " ),\n", + "]\n", + "\n", + "train_transforms = monai.transforms.Compose(base_transforms + aug_transforms + last_transforms)\n", + "val_transforms = monai.transforms.Compose(base_transforms + last_transforms)\n", + "\n", + "train_dataset = monai.data.dataset.Dataset(input_dict_train, train_transforms)\n", + "val_dataset = monai.data.dataset.Dataset(input_dict_val, val_transforms)\n", + "train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=num_workers)\n", + "val_loader = DataLoader(val_dataset, shuffle=False, drop_last=False, batch_size=batch_size, num_workers=num_workers)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d9256001", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "torch.Size([6, 1, 128, 128])\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Sanity check\n", + "batch = next(iter(train_loader))\n", + "print(batch[\"image\"].shape)\n", + "plt.subplot(1, 2, 1)\n", + "plt.imshow(batch[\"image\"][0, 0, ...], cmap=\"gist_gray\")\n", + "plt.axis(\"off\")\n", + "plt.subplot(1, 2, 2)\n", + "plt.imshow(batch[\"label\"][0, 0, ...], cmap=\"jet\")\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "99beca82", + "metadata": {}, + "source": [ + "### Networks creation and losses" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "60f17beb", + "metadata": {}, + "outputs": [], + "source": [ + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ea57cd8f", + "metadata": {}, + "outputs": [], + "source": [ + "def one_hot(input_label, label_nc):\n", + " # One hot encoding function for the labels\n", + " shape_ = list(input_label.shape)\n", + " shape_[1] = label_nc\n", + " label_out = torch.zeros(shape_)\n", + " for channel in range(label_nc):\n", + " label_out[:, channel, ...] = input_label[:, 0, ...] == channel\n", + " return label_out" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "41bda675", + "metadata": {}, + "outputs": [], + "source": [ + "def picture_results(input_label, input_image, output_image):\n", + " f = plt.figure(figsize=(4, 1.5))\n", + " plt.subplot(1, 3, 1)\n", + " plt.imshow(torch.argmax(input_label, 1)[0, ...].detach().cpu(), cmap=\"jet\")\n", + " plt.axis(\"off\")\n", + " plt.title(\"Label\")\n", + " plt.subplot(1, 3, 2)\n", + " plt.imshow(input_image[0, 0, ...].detach().cpu(), cmap=\"gist_gray\")\n", + " plt.axis(\"off\")\n", + " plt.title(\"Input image\")\n", + " plt.subplot(1, 3, 3)\n", + " plt.imshow(output_image[0, 0, ...].detach().cpu(), cmap=\"gist_gray\")\n", + " plt.axis(\"off\")\n", + " plt.title(\"Output image\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "4cc4c8d3", + "metadata": {}, + "source": [ + "SPADE Diffusion Models require two components:\n", + "- Autoencoder, incorporating SPADE normalisation in the decoder blocks\n", + "- Diffusion model, operating in the latent space, and incorporating SPADE normalisation in the decoding branch" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c4583af3", + "metadata": {}, + "outputs": [], + "source": [ + "autoencoder = SPADEAutoencoderKL(spatial_dims = 2, in_channels = 1, out_channels = 1,\n", + " num_res_blocks = (2,2,2,2), num_channels = (8, 16, 32, 64),\n", + " attention_levels = [False, False, False, False],\n", + " latent_channels = 8, norm_num_groups = 8, label_nc = 6\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "77c9e228", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [ + "diffusion = SPADEDiffusionModelUNet(spatial_dims = 2, in_channels = 8, out_channels = 8,\n", + " num_res_blocks = (2,2,2,2), num_channels = (16, 32, 64, 128),\n", + " attention_levels = (False, False, True, True), norm_num_groups = 16,\n", + " with_conditioning = False, label_nc = 6)" + ] + }, + { + "cell_type": "markdown", + "id": "07dd943d", + "metadata": {}, + "source": [ + "To train the autoencoder, we are using **a Patch-GAN-based adversarial loss**, a **perceptual loss** and a basic **L1 loss** between input and output." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "f8d57b88", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n", + "Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=AlexNet_Weights.IMAGENET1K_V1`. You can also use `weights=AlexNet_Weights.DEFAULT` to get the most up-to-date weights.\n" + ] + }, + { + "data": { + "text/plain": [ + "PerceptualLoss(\n", + " (perceptual_function): LPIPS(\n", + " (scaling_layer): ScalingLayer()\n", + " (net): alexnet(\n", + " (slice1): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n", + " (1): ReLU(inplace=True)\n", + " )\n", + " (slice2): Sequential(\n", + " (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", + " (4): ReLU(inplace=True)\n", + " )\n", + " (slice3): Sequential(\n", + " (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (7): ReLU(inplace=True)\n", + " )\n", + " (slice4): Sequential(\n", + " (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (9): ReLU(inplace=True)\n", + " )\n", + " (slice5): Sequential(\n", + " (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " )\n", + " )\n", + " (lin0): NetLinLayer(\n", + " (model): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (lin1): NetLinLayer(\n", + " (model): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Conv2d(192, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (lin2): NetLinLayer(\n", + " (model): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Conv2d(384, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (lin3): NetLinLayer(\n", + " (model): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Conv2d(256, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (lin4): NetLinLayer(\n", + " (model): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Conv2d(256, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (lins): ModuleList(\n", + " (0): NetLinLayer(\n", + " (model): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Conv2d(64, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (1): NetLinLayer(\n", + " (model): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Conv2d(192, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (2): NetLinLayer(\n", + " (model): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Conv2d(384, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (3): NetLinLayer(\n", + " (model): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Conv2d(256, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " (4): NetLinLayer(\n", + " (model): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Conv2d(256, 1, kernel_size=(1, 1), stride=(1, 1), bias=False)\n", + " )\n", + " )\n", + " )\n", + " )\n", + ")" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "perceptual_loss = PerceptualLoss(spatial_dims=2, network_type=\"alex\")\n", + "perceptual_loss.to(device)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "487d74b4", + "metadata": {}, + "outputs": [], + "source": [ + "discriminator = PatchDiscriminator(spatial_dims=2, num_layers_d=3, num_channels=16, in_channels=1, out_channels=1,\n", + " )\n", + "discriminator = discriminator.to(device)\n", + "\n", + "adv_loss = PatchAdversarialLoss(criterion=\"least_squares\")\n", + "adv_weight = 0.01" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "7f023ea5", + "metadata": {}, + "outputs": [], + "source": [ + "recon = torch.nn.L1Loss()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "93fd4e18", + "metadata": {}, + "outputs": [], + "source": [ + "optimizer_G = torch.optim.Adam(autoencoder.parameters(), lr=0.0002)\n", + "optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=0.0004)\n", + "# For mixed precision training\n", + "scaler_g = torch.cuda.amp.GradScaler()\n", + "scaler_d = torch.cuda.amp.GradScaler()" + ] + }, + { + "cell_type": "markdown", + "id": "4984e16a", + "metadata": {}, + "source": [ + "### Training the autoencoder" + ] + }, + { + "cell_type": "markdown", + "id": "3a01bb6a", + "metadata": {}, + "source": [ + "We used the exact same approach as the one from the 2d_ldm_tutorial to train the autoencoder." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "993bdf43", + "metadata": {}, + "outputs": [], + "source": [ + "## Loss weights and number of epochs\n", + "kl_weight = 1e-6\n", + "n_epochs = 100\n", + "val_interval = 10\n", + "adv_weights = 0.01\n", + "autoencoder_warm_up_n_epochs = 10\n", + "perceptual_weight = 0.001" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "cf64d4fc", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:02<00:00, 3.37it/s, recons_loss=0.509, gen_loss=0, disc_loss=0]\n", + "Epoch 1: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.04it/s, recons_loss=0.198, gen_loss=0, disc_loss=0]\n", + "Epoch 2: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.77it/s, recons_loss=0.149, gen_loss=0, disc_loss=0]\n", + "Epoch 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.95it/s, recons_loss=0.13, gen_loss=0, disc_loss=0]\n", + "Epoch 4: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.97it/s, recons_loss=0.12, gen_loss=0, disc_loss=0]\n", + "Epoch 5: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.82it/s, recons_loss=0.108, gen_loss=0, disc_loss=0]\n", + "Epoch 6: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.85it/s, recons_loss=0.104, gen_loss=0, disc_loss=0]\n", + "Epoch 7: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.99it/s, recons_loss=0.0972, gen_loss=0, disc_loss=0]\n", + "Epoch 8: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.71it/s, recons_loss=0.0942, gen_loss=0, disc_loss=0]\n", + "Epoch 9: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.80it/s, recons_loss=0.0896, gen_loss=0, disc_loss=0]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 10 val loss: 0.0968\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 10: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.92it/s, recons_loss=0.0858, gen_loss=0, disc_loss=0]\n", + "Epoch 11: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.08it/s, recons_loss=0.0855, gen_loss=0.648, disc_loss=0.431]\n", + "Epoch 12: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.10it/s, recons_loss=0.0834, gen_loss=0.33, disc_loss=0.313]\n", + "Epoch 13: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.64it/s, recons_loss=0.0805, gen_loss=0.279, disc_loss=0.269]\n", + "Epoch 14: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.47it/s, recons_loss=0.0793, gen_loss=0.258, disc_loss=0.259]\n", + "Epoch 15: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.58it/s, recons_loss=0.0782, gen_loss=0.266, disc_loss=0.255]\n", + "Epoch 16: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.47it/s, recons_loss=0.0759, gen_loss=0.257, disc_loss=0.254]\n", + "Epoch 17: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.60it/s, recons_loss=0.0739, gen_loss=0.257, disc_loss=0.254]\n", + "Epoch 18: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.36it/s, recons_loss=0.0745, gen_loss=0.256, disc_loss=0.254]\n", + "Epoch 19: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.45it/s, recons_loss=0.0739, gen_loss=0.253, disc_loss=0.254]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 20 val loss: 0.0730\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 20: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.51it/s, recons_loss=0.0726, gen_loss=0.255, disc_loss=0.253]\n", + "Epoch 21: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.36it/s, recons_loss=0.0723, gen_loss=0.25, disc_loss=0.252]\n", + "Epoch 22: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.51it/s, recons_loss=0.0714, gen_loss=0.259, disc_loss=0.252]\n", + "Epoch 23: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.40it/s, recons_loss=0.0672, gen_loss=0.248, disc_loss=0.255]\n", + "Epoch 24: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.18it/s, recons_loss=0.0687, gen_loss=0.262, disc_loss=0.254]\n", + "Epoch 25: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.58it/s, recons_loss=0.0703, gen_loss=0.253, disc_loss=0.252]\n", + "Epoch 26: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.57it/s, recons_loss=0.0684, gen_loss=0.256, disc_loss=0.253]\n", + "Epoch 27: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.52it/s, recons_loss=0.0685, gen_loss=0.252, disc_loss=0.252]\n", + "Epoch 28: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.56it/s, recons_loss=0.0678, gen_loss=0.255, disc_loss=0.251]\n", + "Epoch 29: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.60it/s, recons_loss=0.0673, gen_loss=0.253, disc_loss=0.251]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 30 val loss: 0.0696\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 30: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.48it/s, recons_loss=0.0651, gen_loss=0.25, disc_loss=0.251]\n", + "Epoch 31: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.45it/s, recons_loss=0.0665, gen_loss=0.248, disc_loss=0.25]\n", + "Epoch 32: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.53it/s, recons_loss=0.0651, gen_loss=0.255, disc_loss=0.252]\n", + "Epoch 33: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.31it/s, recons_loss=0.0636, gen_loss=0.258, disc_loss=0.254]\n", + "Epoch 34: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.21it/s, recons_loss=0.0656, gen_loss=0.257, disc_loss=0.252]\n", + "Epoch 35: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.04it/s, recons_loss=0.0653, gen_loss=0.253, disc_loss=0.252]\n", + "Epoch 36: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.46it/s, recons_loss=0.0641, gen_loss=0.253, disc_loss=0.251]\n", + "Epoch 37: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.53it/s, recons_loss=0.0626, gen_loss=0.25, disc_loss=0.252]\n", + "Epoch 38: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.48it/s, recons_loss=0.0622, gen_loss=0.254, disc_loss=0.251]\n", + "Epoch 39: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.28it/s, recons_loss=0.0616, gen_loss=0.252, disc_loss=0.251]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 40 val loss: 0.0680\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 40: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.29it/s, recons_loss=0.0659, gen_loss=0.251, disc_loss=0.251]\n", + "Epoch 41: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.51it/s, recons_loss=0.0604, gen_loss=0.252, disc_loss=0.25]\n", + "Epoch 42: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.47it/s, recons_loss=0.063, gen_loss=0.249, disc_loss=0.25]\n", + "Epoch 43: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.36it/s, recons_loss=0.0605, gen_loss=0.252, disc_loss=0.25]\n", + "Epoch 44: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.45it/s, recons_loss=0.062, gen_loss=0.253, disc_loss=0.25]\n", + "Epoch 45: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.58it/s, recons_loss=0.0621, gen_loss=0.252, disc_loss=0.25]\n", + "Epoch 46: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.34it/s, recons_loss=0.0619, gen_loss=0.253, disc_loss=0.25]\n", + "Epoch 47: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.09it/s, recons_loss=0.0624, gen_loss=0.251, disc_loss=0.25]\n", + "Epoch 48: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.49it/s, recons_loss=0.061, gen_loss=0.254, disc_loss=0.25]\n", + "Epoch 49: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.46it/s, recons_loss=0.06, gen_loss=0.254, disc_loss=0.25]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 50 val loss: 0.0629\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 50: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.34it/s, recons_loss=0.0666, gen_loss=0.254, disc_loss=0.25]\n", + "Epoch 51: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.43it/s, recons_loss=0.0597, gen_loss=0.253, disc_loss=0.25]\n", + "Epoch 52: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.37it/s, recons_loss=0.0621, gen_loss=0.252, disc_loss=0.25]\n", + "Epoch 53: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.49it/s, recons_loss=0.0617, gen_loss=0.253, disc_loss=0.249]\n", + "Epoch 54: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.58it/s, recons_loss=0.0612, gen_loss=0.253, disc_loss=0.248]\n", + "Epoch 55: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.61it/s, recons_loss=0.0591, gen_loss=0.257, disc_loss=0.248]\n", + "Epoch 56: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.36it/s, recons_loss=0.0604, gen_loss=0.258, disc_loss=0.247]\n", + "Epoch 57: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.60it/s, recons_loss=0.0592, gen_loss=0.261, disc_loss=0.247]\n", + "Epoch 58: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.41it/s, recons_loss=0.0587, gen_loss=0.263, disc_loss=0.246]\n", + "Epoch 59: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.61it/s, recons_loss=0.0612, gen_loss=0.265, disc_loss=0.243]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 60 val loss: 0.0632\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 60: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.44it/s, recons_loss=0.0606, gen_loss=0.273, disc_loss=0.241]\n", + "Epoch 61: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.46it/s, recons_loss=0.0588, gen_loss=0.268, disc_loss=0.251]\n", + "Epoch 62: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.40it/s, recons_loss=0.0609, gen_loss=0.273, disc_loss=0.247]\n", + "Epoch 63: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.27it/s, recons_loss=0.0598, gen_loss=0.261, disc_loss=0.242]\n", + "Epoch 64: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.35it/s, recons_loss=0.0587, gen_loss=0.284, disc_loss=0.24]\n", + "Epoch 65: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.56it/s, recons_loss=0.0589, gen_loss=0.275, disc_loss=0.234]\n", + "Epoch 66: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.54it/s, recons_loss=0.0574, gen_loss=0.305, disc_loss=0.254]\n", + "Epoch 67: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.68it/s, recons_loss=0.0566, gen_loss=0.271, disc_loss=0.254]\n", + "Epoch 68: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.57it/s, recons_loss=0.0563, gen_loss=0.272, disc_loss=0.248]\n", + "Epoch 69: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.62it/s, recons_loss=0.0582, gen_loss=0.285, disc_loss=0.24]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 70 val loss: 0.0663\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 70: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.14it/s, recons_loss=0.0578, gen_loss=0.294, disc_loss=0.235]\n", + "Epoch 71: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.28it/s, recons_loss=0.0564, gen_loss=0.298, disc_loss=0.232]\n", + "Epoch 72: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.40it/s, recons_loss=0.0574, gen_loss=0.297, disc_loss=0.237]\n", + "Epoch 73: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.52it/s, recons_loss=0.0574, gen_loss=0.3, disc_loss=0.227]\n", + "Epoch 74: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.25it/s, recons_loss=0.0577, gen_loss=0.325, disc_loss=0.242]\n", + "Epoch 75: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.39it/s, recons_loss=0.0567, gen_loss=0.27, disc_loss=0.232]\n", + "Epoch 76: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.31it/s, recons_loss=0.0554, gen_loss=0.336, disc_loss=0.233]\n", + "Epoch 77: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.42it/s, recons_loss=0.0579, gen_loss=0.322, disc_loss=0.23]\n", + "Epoch 78: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.48it/s, recons_loss=0.0565, gen_loss=0.308, disc_loss=0.245]\n", + "Epoch 79: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.44it/s, recons_loss=0.0568, gen_loss=0.275, disc_loss=0.246]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAACFCAYAAACXD7UpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABZpklEQVR4nO29e5ycZXn//57z+bAzuzu7s4fsZnOGkACBUAhyEEQipKJQvlhU+q2+qq3V1mrbX20r2tpWa1trbbWt/UorFY9FiQahiEEOAgYMJJCETTZ7nN2dnfP5PL8/nlx3ZsMGIm6STXjer9eSZWfmmWdmnrmv+zp9LkOz2Wyio6Ojo6OziBhP9wno6Ojo6Jx96MZFR0dHR2fR0Y2Ljo6Ojs6ioxsXHR0dHZ1FRzcuOjo6OjqLjm5cdHR0dHQWHd246Ojo6OgsOrpx0dHR0dFZdMwnekeDwXAyz0PnFHEye2ZDoRDlcplms0mz2cRgMJzU59P55Tj2O22xWHC73YyOjp7E57zzpB1b59TRbN75qvc5YeOio/NqVCoVZVBk4dI3JUsbMf4Gg4F6vU4qlTq9J6Rz1qCHxXQWlUajoTyXX9Rr0b2chZH35bW8Pwt9Dgsdr9ls0mg0aDQav8SZ6ugcRfdcdBYNWZiO9V5OFN3LWZhfxgtc6DELHa/Vg9HRWQx0z0Vn0WjdCR+7SL0WT0bn1PBaNgI6Oq+G7rnonBL0xWvpspAHo6Pzy6J7Ljo6Ojo6i45uXHQWDT30paOjI+jGRWdR0cNfOjo6oBsXHR0dHZ2TgG5cdHR0dHQWHd246Ojo6OgsOrpx0VlU9IS+jo4O6MZFR0dHR+ckoBsXHR0dHZ1FRzcuOjo6ejhTZ9HR5V90dE6AV9JNOxs4G1+TzulFNy46Okd4JWVg+duxMvXH3q6jo6Ohh8V0Xtf8ouEgGSegGxYdnVdGNy46r1uON4RLBme1GpFXMiC6ppqOzsvRjYvOonIm7OLFGBxPar71tmPHAMttx77OhcJmOjqvZ15XORez2cyGDRswm83YbDbsdjt2u50f/ehH5PP50316ZwVnwuApCW3J762Gw2q1snbtWmw2m/JeAIaHh6lWqzQaDcxm88vGAR/P6OicjViAa4CLW/62B7gfKJ6WM1qKnPXG5dxzz6W9vR2z2UypVMLtduNwOLDb7VgsFkwmE1dddRXVapV6vU6hUOCJJ5443ad9xnKmLK6tBmZwcJCOjg5qtRp2ux2Xy0WpVKJarWIymbDZbGzYsIFyuYzRaCSbzbJv3z6azSZGo+78vz7YDFwPdrRV8w40+yI8dh7cdR7kgBLAziM/r1/OeuPidrvx+XzYbDYKhQK1Wg2j0Uiz2VQGpa2tjUajQaVSOWMWR50TR7yK1hyL2WymXq9jMBjw+Xxq85HL5Ugmk9RqNSwWCw6HA7PZjMPhwGKxqGO8Uojs2OfVORu4Hr4LtB/5X/uRH6EXeOuR33PAW6+E0s5TdG5Lk7PauKxZswaHw0GhUKBSqZDNZmk0GlitVhwOBz6fD7tdu0IymQyFQgGv18uWLVt4/PHH9fj5WYIs8K0GplKpALBy5Ur8fj+JRIJsNqvuazabcblc9Pf3EwwGMRgMjI2NEYlECAaDXHTRRezevVsZKHi5MdENy9nCZXAz0AW4598SWDPFjab76GMCgJ1cxWPPXQu3A1++Hi1U9vrkrDMuDodDfaklp1KpVIjH42QyGUwmEz6fD5fLxeDgIKFQCICRkRFmZ2cpFAq0tbWxbt069u3b97LYus6ZR6uH0Ww2cTgcynvp6OjA5/NRLBbJ5XI0m03q9TqNRgOn08mqVavo6elRnsrMzAyxWIzOzk42bNjACy+8QKlUwmg0HtfI6JyJeIFOwAH2a+EDQFcVcpZ59+ozTfBB/okLDu+DGvzlygqPma+F9wC5zfB1gIeA6ql+Aaeds8q42Gw2tm7disfjwWQyYbVasVqtRKNRstms+tLX63UAfD4fy5Ytw2AwkEqlaDQa5PN5SqUSDoeDYDDI3NzcaX5VOr8s4q3UajUcDgfXXHMNnZ2dOBwOnE6n8mIymQylUgkAo9GI2WzG6XTidrspFosqkZ/P5ykUCoTDYTKZDC+99BLw8h4Y3cCcqTjA/2HY1eSCoccZ5G4u5Qme4FK+c+B2qC3wkEeACJj+RFtbcAPvA1Kb4YezwLOn7OyXCmeFcQkEAsqYmEwm2tracLvdWCzaLkMWBpPJBGghkWKxSLPZxG63z0vK2mw2LBYLuVwOq9WKz+fDYDBgMpmIx+On5fXpnDjH5kHE8wwEAlgsFqxWK3a7nba2NpYtW4bb7VYhMYvFQr1eV4UeVqtVeSSNRoNarYbJZMLr9WI2m2k2m7jdbgYGBjAajVSrVaanp+c9t1xbusE5E+gB1gJe+Ah8begmbot87+jNYfiO+dehtsBnuBfYA6Y/OWJ5zODeNEfujg744TYgcOSOo8DBk/galg5ntHHp6OjA6XTS3t6OwWDAaDSSSqXw+Xx4vV7sdjvlcplGo4HFYiEQCCgjUy6XKZVKKtxRLpexWCyEQiHa2toYGxvDYrFQLBZVctflctFsNpmYmDjdL13nOBzbbxIMBvH7/XR2dmKxWFTuLZ1Oq9Ji0AyB2+2mo6MDi8VCPp9XnkqtVqNWq1Gv17Hb7fj9ftrb29V11dvbqwxJW1sblUqFw4cPU6vVlKcs16eex1uK9ACXwcA6LVdiB94MowySCVnwzlaZC7s5yAqoGeg6Z4QwEV5Mr1v4cGZYufo5buUbPHHrpTxcuwEObtFu++4W2H0YeBrYd0pe3enijDUuHR0dDA0NqQVAfnK5HJOTkyqeXigUKBaLDAwM0NfXh9VqJZlMqoSt0WikVquRzWYxm8309/czMDBAd3c3oVCIaDTK5OQk+XyecDiM1Wqlra0No9FIJBIhGo2e7rdiSXG68w2txqWzs5OVK1dit9up1WoUi0VMJhOVSoVoNIrFYsHj8ZBIJJidnVW5No/HQzqdpl6vq6KPQqFAtarFzbu6uhgYGKBSqRCJREgmk8zNzWEymeju7sZqteL1emk0GkQiEWZnZ+d5QAsVGOicLnrA/174CHAusOLIn83wVd4JJlgdPsAuNvFtbmbZ6v18hM+yiV3c59tGBSvr0/tgV8shzU1u5jv8Pv/AdTzA6l9/iUe5nL2HNsElBjg4CHcNwq4qMIuW9J86xa/75HNGGpdAIMDQ0BBut5u2tjb8fr8KU5TLZfL5PLFYjEwmQ6PRwOfzsX79elavXj2vJNnj8aj/l4oys9mM1+ulra2Nnp4ekskkL7zwAs8//zyZTAaj0UhXVxcul4ve3l6y2Szlcpldu3ZRqy0UjNU52Sy0QHd0dHDOOedgNpsxGo0EAgGMRiNOp5NGo0G5XGZ8fJxyuUytVsPlcrFmzRrOPfdc/H4/5XKZcrmMy+XC4XCQzWZVot/tdisv2OPxEIvFqFarTExM0Gw21WMk/LZu3ToqlQo/+9nPqFarWCyWeQ2ax74GPXR2qgiB+73wWej6zRHewKNYqahbs7j5Mu8hXg5SyDnpC07w53ySd9/3TXgQLgk+BybgEZh9BEIfgjpmMNcIEyEQKXGZ/VnWBV7kaTbzqaGP8VjtWq1s+VwgZYGDvXDXe2E/UHsRuJezJfl/RhoXs9mM2WzGbrcrL0M6qqvVKtFoVFV/OZ1OVqxYQX9/P6FQCKfTSa1WU+EQCXnUajUqlQrlclnF0l0uFy6Xi0qlwtTUFIlEgnq9jslkwm634/P58Hg880pYdU4Px0q2iAJDsViko6ODgYEBAoEANpuNer1OOp3mxRdfJBaLYTQa6e/vp7+/n76+PjweD5VKZV5Pi9VqVZsHg8GA0+lUyX6Xy0U6nSYWi6mNihQKWK1WnE6nelyrl92a6xMvRr+OTiVrtaT7JngDj/KPfAh/Pq1u3eM6lw/wBUYOngPAVcEf8470N+Ef4fMPHz1KDfhwGLgF6pjmPYOhBIFIiTebH+H5zvU8Zr9SqzhrR/sZAC45cpA/XQeP/RDduJwmfD4fq1atUnkQt9tNMBjE4/FgNBopl8uYzWZSqRTZbJZAIEA4HMbn82G1WqlWq+RyOZVzkRBJKpWiWq1SrVYxGAwq+Ws2m/H5fCqPEwqF6Ovrw+VyAVqFUb1e55prrqHZbPLggw/q5cunEDEAJpNJLdoej4fVq1dTLBaxWq20t7fT3d1NMBhUITKn00kymaRQKOBwOOjq6lL9LFIxKDmSSqWikv6yCbHZbKqQxOFwEI/HmZubIxqN0tXVRVtbGwDVapVSqUStVuPaa6/FZDJx//33qxCdvAY9PHaqCYH/StgEvRuG2coOQok0hhYVqNX2A2w17eDFgXV0uyLcyHYsX4fhhzUBmPd3ApuO3PkyeO6ylTzAdUcPEAXuRlOGuQS2fWI7O5a9hUcOXcfVQz/gUo4qgezmfL7/nlsg9+EjOZn/PMmv/+RzRhkXr9fLRRddRC6XU02QUjIaCoVUyajkQ7LZLKtWrWLVqlV0dHRQKpUYGRlhdHSUXC5HoVCg2WySy+WYmZkBjn7RRQZEylH9fj/Lli1j7dq19Pb2YrFYKJVKxONxFeKoVCq86U1v4pFHHqFer6sS19cTp3rn3eqt1Ot1AoEAF110kVq4A4EAHR0deL1eldjPZDIUi0W8Xi/hcJhgMMjq1avxer1ks1ny+bzqeZHjT09Pk05ru1qj0ag2NtJX1dHRocKlAwMDBINBlc9LpVIcPnyYdDqN3W5ny5YtPPnkk/OukYXeN92TOVkEwP5++AJwSZXNPMV1PIChBPwPcA8QBu8dVS7f9ih7XOu5lW/wq19+kNn3wYAP3v878NynVvJtblZHfZrNPDZ25dGniUL8c/BPdbhzL6y5cYxrNj2EbajMZ/goGyLD6q7D4V6c7y7wzS3vgrsH4c73AN9E0yo7Mz2ZM8a4GI1GLr/8clKpFF6vl8HBQXp6enC5XKoqx2azkclkiMfjJJNJHA4HPT09BINBGo0Ghw8f5umnnyafz+N0OpWkh8ViYWBgYF6FUKugoeRV2tvb6ejoUOXLFosFg8FANpulWCwq+Zi3vvWtjI+P8/jjj5/ut+2UczoWRPmczGYzmzdvVs8fCoXUQm+z2XA4HJhMJuXhZjIZrFYrfX199PX1YTQamZqaYnp6mkKhgMfjweVyqdBWIBBgamqKarWqwmYSorVYLNhsNgwGA36/H4/HM09iyGq1kslkSKVSuFwurrrqKkZHR9m7d++8BP/peg9fX3wQvgS+m2d4p+2/2Mb2o+GwB+HTT8EfrQHWwnZuxEqFWx7/PpPvhYALLP8F92z7VQ6xgn6OVo72M4FpWZ37x258xWe/nEfnGRaAlZFJLg8/yjfN74C3WsDeC9/+MOx6DK0J88zjjDEu4XBYhayCwSA9PT2Ew2GVODUajapabHZ2lnQ6rfpdTCYT6XSaiYkJFSrr7u6mra0Nq9VKPp8nEAgwMzOD1WpVIQopQy0UCpRKJZWvKZVKarFyOBzYbDZsNps6h2azidfrxefzqd2uzuIin5G85yaTiZ6eHlU+7vf7GRoaor+/H6fTqa6RarVKsVhUYVOPx4PX61U9LtIg6Xa7lSciBiSVSqm8G6DK2o1GI6VSiWQyqY7TaiDEu5ZjGI1GTCYTHo8Ht9tNNptVIbjWHh3dwJwMVmhSLpfAOtuLvIuvctHevTAOlIFxLeTFG+GRlRfzFJsZ4hDsgu3A+zfD1LYAL7GazTzFm4cfgcNAHq2h/zIYXTZAkNjLnzoEs3RSx6xKnBfEDNwArAFu3gK1p4HMor8TJ5szwrgMDQ2xdu1aZRgGBgbo7e0lHA7j9/uxWq3YbDYVmspkMtRqNTo7O/H7/dRqNUZHRxkdHaWjo4N169bR1taG0+lUPS9+vx+Hw6Hi9K09DkI8HmdiYoKuri46Ojqw2WyqPLVer+N0OvF6vbjdbtxuN+vXr+fnP/+5Lud/Eji2n2VwcJBVq1apXpRly5axfPly+vv75zVFNhoNZRwcDgft7e1K0SGRSCjPore3l+7ubtxuN0ajEa/XqyrL2trasFgsmM3a10c2HLVajWq1SiqVUpuPZrNJrVZTisqBQACXy4XH41G9Mi+88ALZbFaF8nROFmthza1wO6xd/Szv4ctcFNkLd0HhSzCb19IjALhgD+vxkOUm7oWo1l7JNvgSv0WIKG/e/YiWU7kHDkdg8DJ471fvZtXgS6znedgHU/Wjzz7W18EezuMQQ6wwHeSO8FcIREovO8uOc8YZ5DCFc5zs/f5F8OYPA3/PmWZglrRx6e/vp7Ozk97eXkqlEna7naGhIVavXs2yZctob2/HZrOp+9frdRwOB16vV315vV6v6m1oNBqEQiF6e3txuVw4nU4sFotaMOx2O6lUSi0AoC1AHR0d9PT0MDw8TDqdpre3F4/HQ6PRUM14brebUChEe3s7tVqNSCRCW1sbQ0NDHDhwgHK5fLrexlPKqdxtGwwGlajv7OykWq3SbDbnGZb29naVh2v1DkTp2G63K29BJPY9Hg+9vb1KIga0QhKTyYTL5VL9L9LBD6i8nPTHiPRQvV6nWCyqsGogECAYDOJ0OpmdnVVyM/v27dOrDk8aK4Dr4ZIg/DGwscqtfIP/G7kH/h6e/zuty8SMJtLiBcjDOl7kAKsY4iDkYb0J2KaJU36Qz8MH4P7HtVbIDNDzOLx3G1xx29MwCNwzX3R/2cQcN/d9m8/yEX7MVbyVewnsmoF+mNnoo4KVG5Z9l2t4iGuOhMKeum4zv/nDr8Gb3w18mTNpXsySNi7ipUhOpa+vj+XLl9PZ2ani6MlkUkm1SEhCvvSyk/R4PCxfvlxVhOXzeSWnLgrJ4q10dHSo8lLQdsbBYJDu7m4VPuvv78fj8RCJRIjH47hcLjo7O2lvb8ftdjMzM8Pk5CSFQgGr1co555zD888/r/fBLBKtkyTb29tpa2tTlX/t7e2EQiG1QajVaszMzNBoNFSIS0qV5XOXfJ3X6yUQCKhSZZHbl01Id3c3Xq+XUqmkrjcJybndbjo7O3G5XIRCIRWim5ubo16v097ejtPpxGg00tHRgclkYnZ2lmw2i8PhYMOGDTz99NPKw2l9rYJueF4r18Nng7AR6IKLlz3BleyE3ZrHMgVcfxPQD9fuQOtdWQ9hIvhJqaPsrMPb3wa/8fOvUMYGa+GyXTBZ1ozLFPD5vTDwMdgWhucjkGg9jVn4jc6v4LFlCRJj+T/OaMUDH4L4xiCrOMDb+TbLHp6DHJTeCE+4LiVwzRSJP+6Bv7kDzcCcGQn+JW1cQCvlLJfL2Gw2Feay2+2YTCaq1SrxeFwt8DabjWw2S6FQIJ/Pk06nyefzBINBJQMSiUSIxWIqASsLjsTFpf9AFiFJ+JvNZtra2pQ8jMTnm82m2o1KKWskEiGTyZDNZqlUKni9Xn1hWGSkOkzCkpIT6+/vVxsEqehLJpNkMhnlnUp4S8KpkpD3+/3kcjkl3SJlxnI/r9erNi6SqK9UKmqgmDyn2+1Wzbit15/VagW0XE0sFmN2dpZEIoHdblcFJuLh6kn9xcSrOS9dgBm2soM3JJ6GshYKu8yGpmK88si/AK6XHyUK/P1u+K3yN/gv2zvhD8F7Lpz3e0f76xNHfvZFFta3dMUbvMv+TQxR4J/h+WE4rwzrEiOsY0SrWPsCEIT4tgA/YCuJgz1anujJEOx0cKYYlyU9Rq9arZLJZCiXyzidTjwej/IwDAaDkvQoFovk83ny+TzJZJJYLEY6nWZ6eppIJKI8Fb/fT6VSYXJykpmZGSqVipLlEHFKEbvM5/MkEgni8TjpdJp0Ok2j0VATLEXTrKenh+7ubqVzViqVlDJAR0cH3d3deDwerrjiCn2xeI0c2wMiOl0yrhq0Bbuzs1OFySQHJ9Mia7Ua0WiUeDyu1BtqtZpK4FcqFTwej/oMp6enmZ2dJZ/PU6/XqdVqyuORHE6z2SSRSJBMJtXnXiqVMJlMKtHvcrkIh8MsW7aMoaEhuru7lQae6NnVajVsNhsXXHCBKlBoTerr45N/WY7uoS9e/cjRsmO51YymJ+ZC05cMQKkTHuIafnTkh23wbpcWlHLd1yCLhxdWLofgwjt0KSBeC9wpRssHj4Uv4PHABdq0ytIRM1EDwyNg+ADwXpi9V7uthokiWgMubo4MI3v3Ir4vJ5cl67n09vbicDhIJpNKbqOzs1PNYpFFRXaD2WyWVCpFLBbDbDbT19dHuVxm//79tLe3s2bNGvr6+jh8+DBjY2OqczscDgNHq44AyuUyY2NjzM3Nkc/nmZ6e5uDBgzidTnp6ekin07jdbsLhsNIos9lsyiBJ3kYEDWW6oXSM6/ziLNRkuGzZMgKBANlsFqvVSjAYZNmyZcq7FK8jFAqpqr9KpaIkWKSKMBqNqk2A1+vF6XQyMTGB2WxWDbpirODogh+Px5mcnFSfr8gDSVm6GB2Xy6UKPaLRKFNTU9RqNbq6ugiHw8oDi8ViSo7oWM9F92ReKxfADQY1QfKN/IhLIs9BBPiqJh/pzcP1R8JTBKBph4dcV5PCz3r2cB/bCF4d5923fxPzvwL3wKZbnuG/eBebb3+Ktz1yP89++eXqYD3ArVcDfwX0wc/C5/KnfIrL+Qlbgs/CB+DCJ9EUX3bBF6Oa0tjvmoBbtMbKy3mUK1fvBOCp1RfzvZ23wXcdnAm5lyVrXMxmswpBOJ1O2tra1I/H48Fut6sehUajoXIcEr92uVzMzs6qnWq1WsXr9dLV1UU0GlUlw/KvVPWYTCZqtRrJZJLZ2VkqlYqapy6yMqVSSZUaS2JXjJ0o43Z1dWG329XoXIfDwQ033MC3vvWt0/zOnnkcWxkmyMZC8hQWi0XpebW3t2MymajX62oTMDY2Rjwex2QyEQqF1IKez+fJZDKqg99qtVKpVJieniYWi6lNQmuZerlcJp1Ok0gklLJDvV5nbm5OzYkxGAyUSiX8fj8ulwuDwTDv366uLiwWiwrvAmzatImdO3e+rHJMNyyvlfVaWa9f+z8TNa1s+F/hvnuP6hKbvwzX+oAPgaEGYaZZzx6cFHmUywkShyOVX8P3wtU7fsrnt/4uD3Adb3vP/YQWMC69ANcBfdr/e8jiIct2tnFV306uvv2ncDWwQ7vP+7fDpyMQvA6aW6CPCTaxi56IlrnZH17G7nvPZ8zwu8BnTtL7tXgsSeMiJaJS/ilCgLKIi9GRqZKBQECFrdxuNz09PbjdbpxO57zJghKqcDqduFwu1QQJqNCH9CNIwlfyLblcjtHRUWZmZmg2m6RSKfx+P8VicV61kQwZk/yNJH+lOk1ncXA4HAQCAdWsKGXjkgORcKck2yuVCrFYjFKphMfjUeoONpttnjcpMvpyjcnvgjRstpY0i9ac3W5X4qnxeFyF0prNJj6fT4XcPB6PKpk2Go3U63UVukskEkqDTEJvrerJugfzi+AABrV8i5mjSZAy8Mj88V2PA9d+EziS2L/g8X1wZHzT23z3Qz9aKAt4HliZBz8p1rMHhk/Mj1gTGWNb+D4+Wv5bHrBdRzgcgTB4NmUJJxIYgnDlXwFhTZPsgsi+lz3+z8Of5Dev+doZ0Ve5JI1LKBTiggsuUF982ZG2fuml8spms9Hd3a2a52TRkWR9a2y+UqmoBLtUdkmvQqtKrdPppLe3F7fbrQyE9LSk02lVRDA7O6sq0ESy32g04vF4VL+DxNVdLpfSRZPJhWcjp2LxEzn9c845B6/Xq8JQ4hWIATCZTMrIBwIBBgcHVV+UeL9tbW0kk0lVaizGpbOzU1V9tQ4Na23e9Pv9DAwMqHCb9K+I5EsqlVK9V263WxWnyAZHSqelxFmuy/7+fqampuYZFJ3XwmXwELz/jX/Pi6wji5tBRmEYMuMvv/c3JuDWvwK2AvfA5BGBjd5zgduA/Zp9evtG2H/LMq7jAW5Ofw8+ubBgfgY0Kf7A0b+9d+vdHAyvIEKYL/MeDrCaIDHeF/hXLtn2HJvDHGmoWZjreAD+EnhoBUt96NiSNC5Op5O+vj46OzvVjlSaHAHVGyA7RulrqdfrqhLIaDQSCoXUztbtdpNKpVRXdHt7Oz6fb16XtXg5drtdJelFwqOtrQ2Xy0UsFqNYLJJIJJibm+PQoUOk02m1MxXvpFAokE6nle6ZeDSXXnopbW1tzMzMMDY2dtre4zOBhaY3ymLdbDbp6uqit7eXer1OqVRSRiWZTNJoNPD7/ar8VzYaXq9X5V2MRiM9PT10dXWpTUg+n8fv97N27VrC4TDhcFh5y1JIIB6z1Wqlo6NDKWlns1ni8TiJRIKpqSlSqRSFQoHR0dF514jP51MhtGq1Snt7Ow6HQ/VmnX/++fj9flKpFJOTk3pC/zVzGb/5xi/wCT5OlE7K2BjgMHwLMmUtNf4QRw3DPuDuHbB2B4QAr00rM/7OXgh+TMuHVAHysGbvGGuiY/AluH944fbGUeC+b0GoJRK+eSN8+g/vJPNrFnaZNlHGym7O55/5HQ5ufgDP5izreZ7lkRmqLtjtO5c6Jjbmn8Oehp5Igr/Y/BH+7I7Pwl2TaJ00S9PILEnjIotBKBRSvQrSb1AulykUCrhcLkwmk6rOEbXbZDLJzMwMfr+fnp4epU5rMBiw2+10dnaqxUH6GEQFuVwuK+kOWVBkgZOQXDweV4uI3W7n0KFDHDp0CJvNhs/no62tjWazSaFQoFwu09XVpcQNZYrhunXraDabZ6VxWexF8Nh8S2s4SsZQgxbWzOVyRCIRSqUS3d3d6nGi+SXeZyKRIBqNqhHFHo9HeSUej4fu7m7l7Yh3KzkQ6UGRqkW32029Xqder6uCALvdrsJaExMTjI6OMj09rbTuBgcH1fyXarWK0+lUpcx+v1+Fdk0mE5OTk+p16JMsf1EMdBOhI5Kjg5z2pzoQh96bgMvgso9o8pDCQbSS4w/fCPwerHsEop+c3wx59zDc/mlgL9y9+/hjvorMD70BPLsbBt4B1z9V5eo/+SkbO3/OdrbxSf6cHfWtmEx1Psan+BD/Rtzn4/N8kCIOPuP6KMvTmrjub/PPPPGVS7l/xdvgT69FNy4niOwaZQSxhMQkni3hJ6fTSSqVIpfLqaZKCUWNjo4q8cCOjo55jXMik26327HZbMprAVRF0ELaTjKB0mKxKMMkO+ZoNKo0q2RWjEi+hEIhFbOXUufWXI/OK3Os3hZozbWrVq0in89TLBZVMUW5XCaXy2Gz2ZTkSjKZVEbD6/WqkNXw8DAul0vl5sR4WK1WNVhMciLH5kXkXKS6UDr+rVar8oqtVit+v1+dm4hhinEolUrzBpCJPI0YunK5rHp4Wg2Lft2cKAFYAxP0HdXxegQteW4DtgE+WBeGOwE6YXg3/Lc8fBX87OpzuWhwL1d+E57ff7QhcgyI3wMH67/4sj6Ldpxr7gJLHAL9JW7+828zahvgAdN1/PTA1dy3+kbqYRMx2nmCSwkxS4WjSiSBaImBzlFNe6w15rbEWHLGRRb7qakpFUMPBAI4nU4lhy5d1CMjI0xOTnLOOecoHadsNsvo6KgyBiKdL0n11mIA+Vee1+FwzOsxaJ2zYTKZVPhNwmQ+n4/29nYikYhq2CwUCmpnLZI1LpdLhWFEh8rpdNLV1aWk/nVezrELqRgZaTrMZDJKoFSS3zLf3ufzYTAYiMViJJNJ2tvbWbVqlarOmpqawmAwqMbIQCCgNjGykZEwmDy3/C6JerlWWq8Zue7a2tro6OhQ0jSRSIREIqEmpwKqaVM8H9mgSHFIV1cXpVKJ0dFRZWBaDZrOKxGCLfASq5kw9XEOI1DWjELwbWjd+v+I1o3/IDy5ZgOX/MZzWO468vAAfIXf4L7BGH/x1b/mg2+Dv5/Qwl9VNBn910oV+EwauFuzD2+/r8HHb/sMN//Jt/n66lsByOLBRI3L+ck8wzKPdmCLBR5bT4sq2pJhyRkXqbaZnJxUHdD5fF5Vi0ncWpriJicn6erqUo1ook48NzfHyMgIJpOJ9vZ2urq6VD5ESkdlbos0TkryV77srTIjsrCIRpkk/X0+H+FwWCWVi8Wi8mYSiYQSuJS/x2IxNXddmjoTicRx3w8djdb8i+ThZNKoeCAS4hThUED1ohgMBjXky2g0qiFxEoaSKkHxMuUakU2HlKrLcWQOi9xfBpWJxyGPEx27cDhMLpdTIba5uTmazSalUkltnkRZQv4tl8tK/mhyclL3XH5RzHCgvpofmLYyEPwXXG9qELwOZr8FoXHY+ZTWi2Jd08G93MQl73yO930V/vOI4YjSyVNczLZN27noH/fy+++Bv0oc7Y93oCkoV1m4Wsxx5N9jb7Mcua2KNt34zr1w2cfg2ntG+AvfX2t3cgG3Qf42Iy/a1jGUHtOq3GxQtR2ZeNkO/Cnwx2+H3TWOFlYvDZakcZFRsYAyKlKxJdIbknuRxslisag8E7vdTiKRYN++farKR77AUu4pHdqiQyXhj0ajQSqVUiXEYrAajQaZTIbx8XEajYZq6PT5fNjtdiqViipnLpfLKiQnRQPFYpFsNkssFiMWi1Eul2k0GkqUU16vzsK0VmqJB5PL5ZRQJKA8Q+lJaTQaZLNZxsfHsVgsrFixQiXPg8EgkUiEw4cP09XVRWdnp5LpkdxdOp3GYrHMKwyR0JtMIJWxDqCF5aLRqHpcIBBQzZMSJpMNjFxbEtar1+tkMhnm5uaIxWKq6bPZbDI4OEgulyORSOjhsV+QxP4eHj3nDbzL9lVcaOMvAj6g8+jiD/AEl3L31W/n9q3f0bT1E3Aj2/kXfpv7uJHV2w7g3VrVVJDRglEfHATeCDwJ/753fu5F3R6G7zw+36/4fRc4bwMisHOHls95HHh879H7OIBfexAG/6fBRVv2aiG9c4H3wY7wm3iIa7Q79qLF9X7vVhj9IlrgbWmwJOVfWkswJVwg4SQJjckOsVAoUCwWlachvQnS15DNZlUoQRZ+mXcuDXSyIIG2Y00mk8zNzZFOp5URaDabZDIZJiYmGB8fJ5FIKC9GjJ3sZqXpU4yL7HZbn0d2yvV6Xdce+wWQz1jyHK2D3WTz0RpiymazJBIJEokEhUKBarWK3W5XfS7ZbJZcLqeaIGu1GrlcjsnJSQ4fPszU1BTxeFzlAKVwYGpqirGxMXWNiZebz+eZnJxkZGSE2dlZFSaVcnUxSjJ8TPJ3TqdT5eoajYZ6bTIx1ePxqNyhfq2cCFWYBMnjK8JguQP4mFa5tTIMRZy8WF/HE1x69H452MxTmKjzNJtJmvzzDnMewPuAT2j/bj7madaCJvnyIXhbQGu1sRy5zXn1kcf9IVzZd9TIhdCOsxlNmfk/gf/dDtwD9+0A7gPKcIghJuJ9R59sBZr2GOtP+N05FSw5z0U8kmAwqGRVjEajMgjFYpFgMIjJZFLNb7JjlUmQ4u1IElZ2sblcTgkGSke0SIPIQp/NZolGo2QymXmJXcnnzM3NKUkP6cKemZkhlUqpKYTt7e0qxCK7XVFrbm9vV96XLBz9/f3Y7XZGR0dP4zu/tGmtkpKQlryXcDSpLtePCJgWCgVVFNJqlEQjTBLqMohOuuVbNxiSQ2lVcpBRyNIbI6FTo9FILBYjlUrNkwaKxWJEo1ElKWO325XHJefk8Xjo6upS1+Hk5KSactrT04PBYGB8fIEGDZ0FmILvV+EGy/yV/zZgJeQ7jbj+pAFlLekfMs1qZcqvRP/R5fvKW4AroOQD221w3gOwc7uWrHcA127SbscHhr+D278MX3z8iF9hhrFwB5WwjZV/Pskf/hHsS8C6jUfOD+Bb8OIuCAJE4QLQLJZJ86gOBwf4UfAaDsZXUJ3xwpXAk1vgsSzw1C/97i0GS864FAoFZmZm6O/vV6XGiUSCYrFILpfD5/OpnpZCoYDdbsfj8VAsFpUnIiEHWWBk8mC9XmdmZobR0VGi0aia2yE7T4BMJkMikSCXyyn5FvmJx+PMzMyoCYZ2u518Ps+hQ4dIJBI4HA7C4TCFQkEZK9GaqlarStlZZrWLLE2tVmNwcJCxsTG91PQ4SFjMYDCQz+cZGxvD7/eTyWQYHR0lEAgow2Cz2dSkSVEd9vv9yojI5yLjjlvFT2VRn5iYYGJiAr/fT39/v5IAkjEOYlSy2Sx2u10NFctms0p5OxgM4vV6ARgZGWF8fByXy8XAwIDauIjkkMlkwmAwEA6H8Xg8xGIxCoWC2oBIv9Sx5eu6F3M8isBTMLOFCfrYwVY6w7PUw2Ye5XIu51F+9bIHyYQs7GITF/IM29gO6+H3H0dTSD5ChDAvsZplt8yx7TBaEcAfwXPnruRR3kDW5eH/e9/n+OBTkEmDww7cgjbTBeBNwF64+HEYMAEb4Wv8Oju5ks+856Ns6BxmXQa4Gv43vIUhDrJ88wzrjk5Q1qRkwoBdG4n8x+FPcx0P8BfBP+fpmStgAC3/csf1MKMbl+MiX5hsNqvKi2u1GvV6nfXr12M0GsnlclQqFdUjICNoy+UypVJJffHn5uaIx+Mq8ZrJZJiZmWFmZoaOjg5yuRzZbFZ1/MtcEFmEZP6LzD8XgcxcLqd2uJOTk8TjcXw+n1ICkMVLPCgJr1ksFprN5jzZGJn/fjZwMsM2rccVLySfz7N//37Vp2S32+nq6lLCkbFYDLfbjcPhUCEpCa02Gg0KhYLSnzOZTGQyGWZnZxkbG2Nqakrpj/n9fjXmQWTxrVarGkSXTqfVdSnhr0qlokZkj4+PMzw8TG9vL8FgUDVt1ut1dR2Uy2UMBgNWq1U15JrNZhVOFQ9poeZSnePz3NRGPtr1t1hNZeqYqddNrDYdAOCAaTXf5a2s5UX6yhNwCxjeiDay+Ah7xzZy37IbuXTtE7j+UAtrZ9Za+Ffex9fK7+BS2xP81tYvEbinhLeGtqp2vuw0uHAT8GfAWhhlgJ9zPhP0sWHTMAB3h9/Ox/kEv88/8IGV/zHPwB1LTyQB4d2a5pnQixYim5Eyg9PLkl3RpBdEqmdEBkZi4slkUo2GzWazlEolNfFPBohVq1VmZmY4ePAghUIBo9HI7OysGvIFMDc3h8vlUh3cYqRaY/YSZ89kMqr8NZlMYrPZmJmZUTIwpVJJ5Xta56bL7Bd5fLlcJpvNkk6nqdVqOJ1O3G73vIVDZ2Fae0yk2q/18/H5fKrfSPJpgPIwS6WSqkaUTcvk5CRGo1FNrUwmk0xPT5PJaH3XY2Njau6L5F1mZmaoVqsEAgEqlYrqvxofHycej6t8YT6fJ5VKkUwmVWWgqCJLnkWKCFKplOrdkU1MaxUkHDXe+nVyIozCF7ZAyk7i5h4lXom/pJWJAQWcxGinfmQp/NnGc1XuJUKYCfogZ2EnV/F52wdxbtQKb1L42cmVpA928eI569jBW7j1wu9gOTLRvOqCnb4tpPBzJTvp2JjTDM56eGzwAnazcd6ZjoS72MFWRg6t496ht2IK17iGH7EyMjnvfs+FV7KTqwCIEeQAq4/e+CTwWJOlYFgADM0TvEpP5S5J+k8uvfRSJUkuO8OhoSE6OztJJpOMj49jNBqVbL4kXcvlsspzALjdbnw+n0rKJ5NJyuWy6tCWWelms5l0Os3o6CgGg0EJYJrNZgqFApOTkwwPD5PNZgmFQkqiY3Z2lnK5jNlsxu/309bWNq+XRvTJZICYlLnWajXsdjvt7e08/PDDZLPZk/7ensxFSRoAT/a1IobFYrGwadMmNfVxZmZGhRhDoZCS0xdlBikIEU9DSovls5JcjGxUKpWK0h8LBoNKDaDRaCjFbBm1Ld5nJBJhZGQEj8dDT08PLpeLVCpFNBpV4S2Hw6GuSXmshF0LhYJSUxbj0t7ejsViYdeuXcoDXqgHCH55z1G+IycLg+HOk3bshbEA18DAZvg/aD/uJtcP3ctmnuIwA3wnfzN9rgneynd5gkt55NB1Rx9eM2iCYmbAfMx3p+W2tauf5Ua240QzPgWcbOdGYrSzjft4K/fSTpwfcxXbuZGfHrgaS3uGm4L3so4X2cN67p29iUbMBWYw+vPcGLqP89k97yl/wuU8PHYd1Mzzz2EXcAfA37OwGM3i0mze+ar3WZLGRZCZG3fccYeqpGkVEJRmutaFwOv1Ktl8mXE/NzdHpVJRwpeidCwhBwmvSWe15HgcDoeSDhE9sXQ6rYxY61iA1vdHdrdSFi3Je4mvA0oDzePx8PzzzytP6mRzso1L64jek4EYFjEKXq8Xv9/P5ZdfTrPZ5NChQwBKHqj1msjlchgMBjUxVPpJJDkvgpIy6VS8DxlKJ2KVkvPL5/PKIElptHioMukStPdcQl3SpyP6aCJ2KtVkcl+5dmu1Gm1tbar6rPU6O54HoxuXhXAAb4M/XakZGMEMK1c/R5hpHpm6EnJ2jP48W0M7GOAw29nG2NiQtpiXDOox2I/xDuR2M+AucUXPTuIE2Tu2EYC1y/YQJM5jU5dDzQQly/xRlWK8zC1/LFnm/631OexV7f/FuHwB+NJ3OFXNlCdiXJZsWAxg69atrFy5Uu3W2traiMfjqpKrv7+frq4uJiYmSCQS+P1+NedcFu/JyUmmpqbI5/MMDAwwMDCA3+/HYrFgNBqZmZlh7969SugyFAqRyWSIx+MqHi6GrHVIlIRcZBplq2xHPB5XgoQidpnP5/F4PAQCAXWMSCRCNBrlvPPO44knnlCxfJ2Fac01iLexdu1alXAHrS9KkvPBYJBVq1YRCASYm5tTase9vb2q9yiVSqny8nK5TGdnJ11dXUodQpp1h4eH8fv9LF++XBkXye21ys3U63UmJiaIRqMqdxcIBFi5ciUej0c16cZiMeCotzczM0M+n1dd/ZVKRQ2sK5fLrF27lnQ6rYzSiRgZHeF62LhZazr0z7+la/UIH+WzbGQ3n+75I5L4uZlvcxU7CdcjXGP6ERPL+niUy/nm2DsgZ+H61f/DVnbMO86jXM43p27lip6d3MrX2cQzpPBzYNnqefe7tecbVLDyDW7l6ReuUH9fu/pZ3sHX8JMCtA79h3jjkZkuzwCwkyv5zqFf5+qhH3AT3yVOkP/mHQy/sAG2AHe9HUoHWSqDxJascREDkMlkqFaruN1uXC4XmUxGdWG3t7fT1tamvAkZhSxqyuVymXw+j91uB6Cvr4/Vq1cTCARUN7fD4WB8fByr1Uo4HKarq0v1HrTKfIjAoOR9JHQiMi4i2V6pVLBarUq+w+FwYDQa1RyP9nZtJJ7BYGB2dlZVtOmLw4nRuqhKol68DjHecj20tbXR3d2tmhelr0TGLRiNRuWlTkxMYLPZ6O3tZWBgAK/Xq2baHzx4kFgsRmdnJ/39/WoUgxSCSPGGhLMkrxOLxZR3FQwGCQQ0HahyuYzVasXhcOByudS1lMlk1GalVCqRz+eVQZGNR6tqxELvy/Fuf/3iBftm+EswbsrTGdKaDKOzIRo5J+ezmyvZycrIJJeGnyCJn/dH/lMTuIzAr5YehDA4Vxa4130TuIvcyH3afUAbPJaHgY2H+UnP5WzmKe22KGCGawOPveyMmnZIBvwcXLOCxGQn5Cys4gC/xb/SEdEac/JBI05bgfXs4erITwEIhmP8fOh8trGdD0T+g7mwm4OsYNi9DjZa4Brg+0tnSuWSNC4+n4+LL74Yi8XC3Nwcfr+fvr4+3G43zWYTp9PJwMCAknSRCiwZFCXKxxIXbzabBINBOjo68Hq9SkdKelBCoRCNRgOPx6M6ri0WC4VCQVXpSNhNKoSkskg6/EUdAFAd/TI0DLSmSdGtkgo0qWDSF4ITozWZ73K5WL58uarQWr58OStWrMBoNDIyMkIqlSIcDqtxBxLW8nq92Gw2pSkm4U25RsQIyLA6kQmS8dmSS2k0GqpkvdFoKE9KuvXtdjsOh4NsNqsKRvx+v+qwl3yLqEbIXJe2tja8Xi8ul0t5txJSlRLqV9qI6F5MK17g3fABoB2uCz3Ab/PPVLDxr6HfIhYK8k7+i5UTkzAOpnCLYFgc+BSakfgkqnJrW/A+zWspA8NorfV74IY/eJibL/s2JurabXehDRe7Dq0/xXv00IYa/DpfY7XpJb627B08Ub6UPiaw1Y9ELobB9XiD337Tv2GZAHYDnXBN+Ee0E2foiFymP51jm+8+nlh2KSMvnHNS3sFfhiVnXDweD5dccokSJhTZjIGBAWw2G5lMBrPZTDgcpre3V+0cZeER1WLJ0USjUQwGA93d3eoL7fP5VP9BvV4nFAqRSCTU4uFwOGhra5vXuS16UsFgELfbjd1uJx6P09PTQzgcVlLrMrRMkvXNZhOXy0VHR4fqzcnlcir3IzkbnVdHFk6Xy8WaNWvw+XwUCgWl4xUKhbDb7epvAwMDhMNhpUMm3iqg1KnL5TKpVApAGQGn04nf7ycYDKq8y8zMDIlEAovFonqc5BqVijTxYILBoFJEjkajKhQnHhQc9V5kaBhonpj8XarEXk1BW9+YHA8H8G74SFDrXnfDEAe5IfowJRf82HUlA9jYVt4Onwby4LyswJG2Rc0jETmWMBxgNdWSlSEOsSwyB2ng07DzYa0x8tYEbNr5DAcZ0nIgj8N9u+D6r4Pldo72vBxhjXmMNZeNEd4U4QnbpVzHA3h3VbWKr2/B4cdh8DJgHJ6fgPMGoeO2HNde9hhSaGbJwzrfi7QTY+SkvpevjSVnXFwuF93d3SQSCSWjIhpNYkQkzu12u5W0vYQZHA6HKk+enZ0lFoupaqHWxkZJ6ovwoeRFRJRSpgrKzrVaraoqI9AWB5PJRCAQUDtdKUCQ/gapRhLPJplMks/nVZJYlAH0BeLEkB25w+Ggs7NThSBlAZbrQ3IfEnaSz7Ver6uS9lQqhclkUv0sMt5BvE4pCJFRyB6PR31+5XKZYDCojJDk5sSrEA9aOvjb29vnKTeIJyzTMk0mE+FwGIfDQTQaVSKn8nol6S/o3smJ0ANvPWpYjqWIkz2sx5VucPifYXANmtfRSj9wGTx27gVs50bI2Y/eVgb2tsx5GTnm8SVtlsu+NAz88zzHBdCqki/8BFy1/Kds8u3Ck67C/8Bjn9FS8rNAz+OQRav92nkYBv4Ktt3EUTXnJc6SMy6yCMhuX8pA7Xb7PP2u1tkoLpdLSeB7vV5V8SL6X+3t7bS3t6uGSzEssuOVyZCiPSVVPBICk7JX8TKkrNhsNqvwiVQYAWqBk/JpycHIoiGaaGJcdI5P6yIqGwtZ9D0eD8FgUM1qEbVjabAVr1Mk9aX/qHWwnCTeRXHb6/Uqgy+bEJPJpNQApKte+lRa5fkBZThkUJxcY7JhEcMl4TyRMBJlbqvVSjweJ51Ok0gkVNhOXnPrPJnjNVPqmxUAC3SBb+MMV9p+TDtxrmIn/AjsQSi/yUYMLf85BQyWYSO7CRPRDMcjaGGvmyBOOzHaWb76BS7liQWf7fkJuH34O/xw5RXz/l5kYa1iL3DhvWDYAt41Vc1L+pb2tNWWx77bBMHWsccbj/5a8mmCm+P0aaGzh+RRS4Mlt7JJn0o4HGbNmjUqxOD1etW4WOlJMJvNtLW1sXr1ajWn3O/3k06nGRkZUfpT5513HkNDQ6q/QHpXZIFasWKFmnUv8W9AGQuJh8vOVrSqyuWyCqWIVySNnKKgLGXOgCp7leSthM5eeOEFZTR15nNsolrCVKLjNjQ0pMJhMltHvExZxO12OwMDA2qBllxeLBajXq8zODhIOBymv7+fjo4O3G63Kl82m834fD56enrmGSvxklrnAcm5SrkzaIUpdrtd5d/EqyoWi8TjcVKp1LxZLclkUlU/zszMUC6XMRqNHDp0SP1+7Hujc3xW2w7w5/wF69P7sOwAvgW88+X3e+YwXPiWfeDaB3mY3QGhNcBWrUprkMP8Hv/Ar97zoHaMNDwWPfr47YBnFbz5S4/A1a9+Xhngrt1wx3vQDMZT8MXI/PbHHrTxytze8kczYIOHO3+FHWzlPm5k5oXl8BhQ+g66cXkFpDJLciPivUgvgYSdotEoY2NjdHd3s2LFCvWFLxaLjI+PK8MyNDTEunXrCIVCytNp9TDsdju9vb1KNl/UclsnIB7bWyF5HYm1y2KWyWSIRqPqvo1Gg5mZGdW5LyWrYoDE25FmT535HLszb/1/WfhFN0wGhCWTSbxer+phSSQSdHd3q5yXDIRLp9NYrVaWL1+O3++no6ODnp4eVbQhRslgMKhyYfEgPB6PElRt7Ydp7cECVA+OfMYy70cq1OT/s9ksyWRS5QnHx8eVmrd4NCINc2yHvm5gXhkTdWyUtc757TB5L/TeAk4K2Cgz1tnBlt+Zo3kPfH7H0WmTK4Db3wf3rPxVOolyP28m8GslDn9LUys+lira33/tfbDuMnhq7wJ3OoYp4NOHoVUv0wG8xwTBbUf+MAtEYP8Vy7iXm1jP8wD8f/wNe1+4SCsa2ItWQHDcgcunhyVnXAQRqiwUCkoepbe3l40bNzI7O6v0mmq1Gg6HY173tM/nY/Xq1aoQQJoj5Usp8XQxFk6nUyV+W/W+JAQjO2XQvuRTU1NKwkMq1Wq1Gul0mkgkgsfjob+/n7a2NhKJBHNzc+Tzebxer0oiy/H3799/Sjrzz0QWCveIoReDLI2STqdTSbgMDg7idDqxWq3EYjEajQbd3d10dnZitVqVOkNnZydOp5POzk46OzvV8US6RxZwi8VCW1sbDodDqSeLgZNrqvW6qlQqyitpRXJ20WgUh8Mxr1lTdPBEXkiMW7VaZWRkhHw+rxuSReA/gfe9E76w9ff4hu/t2KjAn4DhTfDB98KdR7yRKMA9cNtl34O7YPKf4d95db/gm6BVkL0KXuDDfWjzYI7lTfDD265ggFHW3D0GZrBS5kXW8Q1upYKVfS9cADPA59DUn7mLo6ZxabDkjEvrIi6if1Lj7/P5GBwcxOv1qm5r6WeR5KjVaiUUCqnphIFAQBkAOJrTkX8FibPL4iXqt7IjFW+nVCoxNzfH2NiYGmAGqC58GejUaDRwOBz4/X41QKpYLCrPbHZ2lmefffZUvrVnNPLZtOZdREhUPEcJXYo3AtrnHYlElHq21WpV4VTxQGWYl3jMrYZCDEirMZHjtnorcLRaLJfLkUqlGBkZIZPJzJtuKirffX19dHR0YLFYlKERL6ZSqeDxeEilUhw4cGCeF617LL8YBZwk8WsrXUCTrn+oDre+E27/wHe0iY9hYBPwRrDco3khGeD+p+D698LO3S2J+0XCA3AbzH3aTWHe2DKoYOMHbOV8drPmak0Fe3lkhq3hH7C9fCPpg13aHVMcMSyfWuSzWxyWnHGRL4+EmaQfREqKHQ4HAwMDSv1YhkNJ6aYkX10uF/V6XYlQejwe3G63mvAnXf8izy87SOl9KZVKypORMEmrTlg0GmV6elqF2arVqgp/ST5ISpvb29uVzIyo6srQMJ0TRxZX8UJLpRIzMzOEQiE1BMztdqu8iYSgRJKlUCjgdrsxmUxKHsZisZDNZl8mNCpiqKCVCMs10rqhqVarKtR67OdZqVSYmZlhZGSEYrGori1AFRRIsYeEgNva2pRMUetUzVa9Nt2onChFOAjPHdrMd4du4rzgHrxvq3J9GPgWTG4H74Pg3YTWx7IG6NP+EQGVYYDdUEDrT3SgJecPoimWrUfpXzJ15HGtORPHkdujHEftywff5a38gK1kNXMzj21s10JmQcALb+BRftv2L/zLit8m/f0uLc/C5Mset1RYcsalUCioneb4+Dj1ep1oNIrVasXj8bBu3Tra2tqo1+ukUinVI9DW1qYkO6Qjf3Z2lpGRESwWC0NDQ9hsNqrVKul0mlQqpfpowuEwfr9fLV5S2dW6kLUihiiRSGAymZSmltVqpaOjg46ODhXblyqker1OPB5nbm6OF154QZU0n20sdnf4QlInpVKJSCRCR0cHk5OTOBwOlRdZtmwZa9eupaOjg2QyOW8Mg2xCZKMAMDMzw9zcnJL/kZDo5OQk09PTKqQmnf6topL5fF4VkYjRketRciVi1Fo1y0QJwuv1qtELIrHv9/uV5H+pVJq36dENyy/CLDyUgR96+fHvXMlG025CV8/C1XDt2x7DuxHuKsMHI0BYUyVevn6GzRw1LglgFHj/INrUyU648NNw535tjPG2rWhzW4ALH4fQl+H+ljMYAG5dCTuHj+P55CFInD2cRzTfyTrXi1ipYKLOzXyba3c8Bl9GGyB2mSazvy18H//Cb2vnE3sKjuRgliJLzriUy2VmZ2fp7e1lYmJC9am43W5WrFjB0NAQ5XKZSCTCvn371OIN88cjF4tFtUAMDAyo7nkJqVSrVaLRqJJ18Xg888JnsgBJybJ4SFItJJ6Q1Wqlu7tbJXgDgYAKd0gTplSb1et1nnzySaLR6MIvXudlHLugyihhyW3J4m02m5WCQ29vL1arVZWMA2o6qSTlJXk+PT1NJBLB5XKpfiiDwaDmCIn3LAKVsoGRhljZXIjHI6OvW4VRnU4nK1euVFWFPp9PVZGJF9toNNSm6KWXXlKTTY8tEtA5UYrA8xDbwrNTm/hoz2cwU8dEnb9d81Fu6f8+K4eB2+CxNRfwDJv40PC/vcwIXADwIWAbYEOrFNt/ZDTxuWiDwAA2weZxeOjBo96LF2AQAsPHOcUyDDCKhywDrsN8go8T0rI9rIxOwidh+ClYufXoQ/awnvR7uiD2RY7MtVyyLDnjAkfj2VKyKwu41WpVi4aEO7xer4qlC+KdSGOkhMIkhGW323G5XEriRXIrsks0mUzKWMgXu1wuq1i6LAjyGNE9k1i+iCLKwiRjdyWcpvOLs1DeQdSvRcNL+kvks5Y5O263WyXkQeslEQXjeDxONpvFYrGoSZR+v5/Ozk4KhYIqjU+n00omyGg04nK5VCm5eC1yncloBQmdyfP7fL55ytziIUv4TsKu8Xhc5fhaX7vOayRlZya1XPvdDLHVQfDB9YPAO2Ef6+hkFiLQOuczBGzeBNwGz3au5fzEPgxXwPU7jgwS/hZazmYrWt4mrC2oYlxmgcwjR8JrLbwNOG8zmnE6gocsq3lJaYuRAS6BlZ1ozZzA/vAyfsBWTV5/iRsWWKLGpVVhNp1OYzab6e3tpb29XelxxeNxLBYLXV1dqtxTRCYTiQQvvfQSk5OT6staLpfp6Oigr68Pm82m5PQlli5lxZK4lUVDOq4TiQQTExPE43Hi8bjyqgA19lbKWKUEdm5ujrm5OZLJJKVSiUKhcDrf1lPCyV4EZQGW3hCv16u67WWEdKFQoFKpEIvFVDe9GCYZ5jY3N6c+T9m0zMzMqDEJUk0mQ8gk/yLPbbPZ8Pv98zzdUqmkhpDNzs4yPj5OoVDA6/XOC8k1Gg21UWkdNic5wlbDcire07OXUfjuFriEI3OC4YLVj2mNkAHganhyzQbG6eMv9v81zf+Z73W8fyXwFfh/nbcRJM560z4st8DmPPBJrYz41z4OgyvRjMvLn51/Ks/Pw7wNOO+zwDYohbUemol6HwOmw/Mf7EXzmGowtTLADrbyA7byvf+4DfYvfcMCS9S4RCIRVR4sSVSn04nX61XGI5PJYLfb1YAvCU+IoGQikVCJUhkklclkVDe3lDmLsq7Iq4s30irLIgq4k5OTHDhwgKmpKTV/pVQqMTExQSaToa2tTSXsp6amGBsbU56K0+nkwQcfPG3v6aniZO2yj62UikajHD58mFWrVmG32zEajUoqSLrepcBCZqUkEglV6CEzXABV8ZdMJtXMFpFqkeeT3ifpzpfKxHq9TrPZVMO+RkdHGRkZIRKJMD09TaFQUFVfMjOos7OTcrnM9PQ0o6OjzM3NKYPy9NNP61pzi8ZB2P0d+Ju3w51o4pU8yIbDw9oqvxleZB3reBEi2njj93xLS3OYQZNYccEqDnB+eTeWPDwyeDH+TyTZ/M1h7t9/pDT5FdrUjp0Jed5lwG3w/fDVbGcb93Ejif097D7nfD7OJ/CEs2xlB1dEniYfNnKv7SYt6Z/eSmkyoJ2c9p8lz5I0LgAHDx5Uu0gpBTYYDFQqFRVqkvJRMS7SG2A0GlU+RCZQygwWmQApIQvpj4Cj6gBiWFrLl6VKbHp6msnJSSX9YrVaVchL+l6kzyESiZBOp2lrawNO7qCu1xMShjp06NA8EVJpVLVaraTTaXK5nCriEG9GNOHa2trweDwUi0VVflwoFNTYZCnQkMot8WRzuZzSIZMcXbVaVf0thUKBaDRKNBqlVqup8dWyyRCl7Xq9zvj4OBMTE2ocg+Rc5DXqLAZ7YOc2SFmgHUzUtNzJjfBCeDkHWM3NfFsrE/sc9OaBI82U/7sfrr0Ptmx7VhOjtGuehp8UG14W7DqKFy0nk2GBvhizJrm/nW3824EPgbuEpStDJB7mi7nfhZwFzoHzQz/nsGmAL/MeHnnhzdpjS0AOlsoY41djyRoXQJUeS0hB4unSfW0ymVSjmtvtVl5HIBBgYGCAarWK2WxWY43FQEly1mg0KpViiZmLYnEgEFCqANK01yo70tHRocQwJamcy+UYHR1Vu9JyuYzD4cBsNjMzM6Mbl9dAqyd0rPciCzpogqdShCGqwpFIBICenh58Pp+6r2jFyVwfCVPlcjnl2chzAGpEQiwWI5PJUCwWleadzP2RzYpUF7rdbgYHB/H7/arBNplMkkwmlUKDjDEWgyiTKF9NVl/nFyUD+4Pghvo585e8A6zia7yDzvA/aGrHLdQAJoD/0Q7Bbcc5vFebv+IKNjgPuH4lcBnEvwr/WV+4DNlEna7VI7yLr7KaAwA8FdzMfdyohcpMfWTxsKe+XntACrgb2Pvia3oHTgdL2rgkk0mazaZSwI3H4ypZXi6XlfCgCEy26n7192tZMFkUEomEmrVhNBpVKOzQoUOk02kVcms0Gvj9/nlzW6TpUgQtu7q6GBwcVAPCJGEfi8UYGxtTQ6Sk9HRmZobh4ePvdM4mTmYZ8rHPYzQaicViVCoVVq5cqRL0co1IU6LZbCYUCql+JZFVEWkhKSuWoV0yxVSkekRhQea3lEolBgcHlXfcquIgv3d1dbFixQolqZ/L5dTIbcnLACr3l0gkGB4entcPo7NY3A9/fC1sCvHMzy4kEbYTiGg5tCghfpS/hk5XlI+4Poel5VHDwLK/04zMeecCNx3n8JvgK7bf4NbPfoPrb8pR2gh1s5HgygaXfWx+ebLgIcu7+Cof4bMqif/G8EPcyH3s4C18JX2HFgbLAfuBHwJffxG4d1HekVPBkjYukUiESCRCNpulo6OD0dFRtQDIrlVi5G1tbTidTorFoioCkP4DqdySiiIxLiKDf/DgQer1OsFgkLVr1xIKhQDUDlbi6tJQKXPUJdxitVppa2vDYNDGFxeLRRwOhzJ+09PTun7Ya2ShPpfW32dmZpSX6Ha7OXTokJJQkVCYVHdJyEvCmKITJ2Mams2m8mAk1CUh0omJCXK5nLquZL6PCJ3WajXy+Tyzs7NqoqQcFzQBy9bplxKyS6fTTE9PMzc3N0/xWGcxOaj97FrLg392K//0Fx/k8vCjHGKIGEFqNRMVrFgOA/u0BsmL0WZ8zaKpuZzX0pZWxwTrYWC/1iC5bhgmwn18gC8wetkAq3iJj/C3bLANz1tg1wKsgYOBXiKEuYaH6IjkyIQsJE1++hNzLCs9zLrwi0z4+vj+/lvg28BnAf4XTcT/zAiJAZwRmUOJS09OTjI8PMzU1JQyFlI2KhP9ZN752NiYCjvA0d4Xqfqx2WwEAgG6urrUcySTSaWI27ojFeMCqAFPZrNZLSYShzeZTDidTjWBcP/+/YyPj6vGutcDp2vXHYlElOTK448/zu7du4lGo9jtdrq7u5UkkOREhoeHmZ6entdlL9WJUsJutVrVcLh6va4mm8oIB0noS8+LeCUydhlQHk+rkZSu/Gw2y6FDhxgfH1cSR6fzPTz72Qffhs/mP8L/5f/xMT7F8Ng6zvft5ka2w91w92EtX3Ltm6D3e3DhHxwxCi2UscFtcKNJW+75PfibxJ0MMMrTh96AnyQbIsPwdU1CX7i1E7gN7uWtPNQiKva8aT3f5SayPs1vGkzM0MfEUe0w/h7NxC0dxeMTYUl7Lq0Ui0XMZrOSUJEkqDQ3ioT97OwsExMTquNZxCLlsdK7YLFY8Hq9DAwMKGkWyY+0VopJPF1mo0toTGa2SLNba/m02WymVCqpaiSd185CO/lWZWC5XRb5arVKMpkkl8thsVjo7u5Wm4FqtUomk2F6eprx8XE6OjpUA6R4IPF4XJUey2jinp4eJYEvnovD4cBoNKom2VZpH0E2O6lUSvXeSC+NiFgWCgXdWzmV7C+Qu7uD3JYO9Sc/KULMQh/cvgawA3fAs9vWcsHafVy7D23M8ZF6i6e4mMw2C8FglUwUHtsNW/4ObvrUvTwwdJ3WCBkBIsfkWzqBsDYfJh5vV0Mvizh5gksZMh3kBvPDPBXYwBfHflercKs9xnHEY5Y8Z4xxefTRR7niiiswmUzk83kqlQo2m00ZEul2npiYYP/+/apRbnBwkFKpRKPRIJPJqIXH5XLh8/lYu3YtnZ2dWCwWpqenKZVKSt9JxCtTqZSSbpHCAEDlgXK5nJq3Ho1GeeSRR/Qw2CLwSoal9XbJdfz0pz/lkksuwePxqLCpeA7SS5JMJhkfH2dqakqpa4t6teRoZHJls9nE7XbT19enQmDSRCt5GakOFMMiA+DMZrPykiKRCPF4HJ/PpxQo9u7dO0+vrvW16cbmZPJP8L4/gi8BW7S/HGA1P+Fybrvle9rMext8b/BNfJ7fZcXKQ9z0g3u5LvEIBi3owfbZbfwkdDk38DCgeSfev4JLAs9x0x/cy6Nczsim/2b5m2a44C7Nu7kMtGZL+/yzmQu7+TFXsSO/lVHXALs7z+fPxv4aBjJoGs5nlrfSyhljXMrlMj/5yU94wxveoCb6TU9P8+STTzI5OakSp1IGKhP9hoeHMRqNjI6OUqvVmJqaUs12Ho9Hdfd3dXUxOjrK2NiY0ouS543FYgwPDzM6OqqGSIknI4lfURT43//9Xz2scRowGo2k02meeOIJfuVXfgW/38/c3BzRaJQ9e/YQi8Uwm81K2l4S/6Ojo6owIxKJqJzezMwMxWIRr9eLw+EgHA4rFeZEIqHm/7jdbqWUPT4+TjweJxgMqvHKiURCCaWWSiXS6TR79+5VodZWnTPQS5BPPkXg05qB+TJwCYy8cA4fP+cTPB3ejCNcpIKVHWxl3wsX8DCw45yt3BjYjp8UP+KNNEpW4rTD++DOXcBu+PcI8BH4+Fs+w5Vr7mcHb+EDv/MfbOuEbXvRVJdvg8f6LmAnV3Jd8AE2sYsJ+tjBVnJ3d/D0XVfwdOoK2H+YhafGnFmcMcYFtKa4n/3sZ7zhDW/A4XBQKBSYmpoim80qoUgp55RkbyKhzThIp9PYbDa14JTLZZrNppr7IeWriUSCeDyuDIQYF4np+3w+tSuWeP3OnTv1mSynEVmkJQ/2zDPPcPHFF+NwOJTGnIS06vU6uVxOddnPzs6qAW+ZTAan06kaNB0OB11dXfT19amx27Ozs+TzeZLJJKBdV61jGAqFAqtWrcJsNquxECaTiWeeeYZisajKjFul/HV5l1NNEbgbHrpdW/TNMPzCBj7HhgXvPfnCSr7Ih4/+wV1llk7yf2LEVGtg/zKs/D2tYvm834HLf/QTCjgorQX7HwA1rbelbIMdvIWnxy7lc8s+wDnRER7pvJgUfq0a7Mm70Pr6zw7OKOMCqLi55FSKxaKaRy/4fD4lw55MJuc1OR46dAiDwaCGSokAZSAQoK+vT8mCiLSL7GIjkYjSlZJGuGQySTwen/fcOieXhRZhWaBl4a5UKmSzWSVkKRperf0rTqcTn8+nDJAobFcqFUZHR0mlUni9XkqlEn6/n0AggNfrxefzMTc3p8qXpYdlbm6ORCKhCgOk9FiuESkOkfN8tdekc7KJwtfRRgxfw8vCVQCYwd6VwOkukk15qM5ozbqULHyNX2eP7TxW2A7y8ds+w5V3w7O7gASEibCDt5BytXGN6yFWc4Cfs5HtbONRLoeamVlCPNz5K3yUzzB27Rp46DBngl7YL4KheYIxnKX0BQgEAmzYsEGFHorFokrIOhwOli9fzsqVKzEajUxOTjIyMsLc3ByVSkV17be3t3PxxRdz+eWX09PTo7ygw4cPMz4+zujoKLFYTDVtVqtVZbSazabqXZFGvTOFkxmyE9n703mtSP7F7/ezZs0a1RSZy+WU5yCadMuXL8fn85FOpxkdHVWVfWazGaPRSDAYZNOmTWzevJlly5aRyWQYHR1Vcj/SFJnJZFSDr4zmbjQajI6OcvDgQaUX1toAulSHfokHd7IwGO48acf+xQkAH4SPoOmPreDodtsMa1c/yx18hRUcYheb+Ap3aPPqW9hwzpP8P/4vF3xkH//+d5rM/rVfgh/+1hX8F+8iQhgnBUYZYN+h86Fk0JyTduAh4E9Bm3G5tEYUvxrN5p2vep8zznMBSCQS7Nmzh/b2dnp7e/H5fGpeh9vtxufzEQgE8Hg8qiFSKoFELkakY+RH8i6iKxaLxTh48KAKbdjtdprNJs8++yz5fJ6pqTPrYng9YTAYSKVS7Nu3j/b2dvr6+vD7/aqyy2Kx4Pf7WbZsGR0dHaRSKRXaEu9FRFAllCZFIXKtGY1GUqmUkuW32Ww4nU4A9uzZo6rSRKxSzqv1HHVONwngi/DZi6H9QvhLNCNjBtwlLuUJbuUbLIvMcXn4UbK4+YL5D4+07r+ctRwZHvY5eHPgEfy3pPgb/ojvTd0EKbvWbrMbrdP+4IvA05xNYbBjOSONC0AsFiMWixGPx9m0aZNSqJWyU1HAbWtro6enh+npaZV/aR1bCyjDVCgU1O7W5XIpbTOLxaIaLefm5l7ptHROEwuVJ6dSKdLpNIlEggsvvBC/308mk1HGArQO+UqlokYwCCITJFWDrRI/ovQgeTz5OXjw4Ly+FjmOzlJmFtgOsafhy+/XjAtAzs4e1hMlxDLm6IjkGAyPgrkJtYU/0y0bgT9EC7ENwubEc/xG4C729JzHSOocrSHy7mfQxpGNnuwXdto5Y42LIIu9zGoRj0R2k9KwJuKErY2RlUpFlZ/KAjI9PU00GlWyISKEGYvF9NzKCXC6FtPW522VwRcZe5n9I+MVJPyTTqeV5xoMBpXxET056aCXcQkSWpUqQRnfUK/XlVKAbFpaw1960n6pMwu7JuGhXngzUINZQvPGD29kN+cO7WLvCxepv0UI8xQXc8Fl+7Qo2yVowphAwWVkAk0jTHks/JAzqcv+l+GMNy4AP/7xj7nhhhvUhMlMJsPY2BjpdBqn00mpVJr3pZcphOPj46okWRoxI5EIc3NzZDIZlcDfvXu3blhOkKWyiMo5mEwmGo0Gu3fv5uKLL1bd+DIWoVwuY7PZSCaT87TkZIz2Sy+9RCwWo7e3F6fTqaRecrkcExMTqmrwueeeW3De/VJ4L3ROlP+Gj7wfvqsl7scG1vDGDzzBxZsf4Y38CCcFPMyvCp070M8/rP59IjeFectNO7gk+hyPdV7Aj7iG/+YdDP/ZBm3W/U7QciuvD8MCZ2hCfyEWmoFxwQUXsHz5ciqVCqVSScnti6S63+9X8h61Wo1sNks2m2Vqaopnn3123q7zbOFkJ/SX2iySVu9Bzk1yL2azmQsvvJA1a9YQiUSUBp1sJERh2W63EwwG8fl8GAwGSqUSkUiEXbt2qWO3Ns0u9e/KK/H6Sugfj1b5SjNwGfyfLVrif6GqsiN327D6Sa7jAT7zzMfhZmD0KbSsPZxtRuWsTegvhHQ5t7Jr1y5AW/RsNhtut1spH4O2CEg5ablcJpFI8NBDD73sODpnDsd6TlL6Kx338v+ivvCzn/1MDZoTkUsZby2VZ6VSSY1SLhaLPProo0pkUrwVmG/IdM5kqsf8/hB8fQvcjlYOthA1eO6FS3gudwncAMTuPMnnuPQ5a4zL8SgUCnR0dKjEvIQ8AKUPJsKSJ3PHpnNqWMhrkM1Ea9hKqsBqtRpzc3PY7XaV1JcKLzmW/C5Gplwuq7+JN9Qq46JzNnI/fO56eB+vvGp+G4g9dorOaWlz1huXF198UY0yFqPSWslTq9VUbuXpp58+naeqcwpo1e+S6aUjIyOAppR9PANhNpuZm5tjeHh43n1amzfP5HCYzqvxlBbheuiaV7nf4xxJsLzuOWtyLjonxust5yIc73UfG0I79n6t/3/shMizMWGv51x0ToTXVc5FR+eX4dWMT2uITM+r6Oi8Orpx0XldcKIexiuNVX4tx9PReb2iGxcdHY4ai4WqzVrRcys6OifG0gyQ65yxnOkho1fzUHTDoqNzYujGRUfnOLQayjPdaL4aZ/vr0zn16GExHZ3jcGwy/2zm9fAadU4tuueis6joi5SOjg7oxkVHR0dH5ySgGxedRUWP3evo6IBuXHQWGT0spqOjA7px0dHR0dE5CejGRUdHR0dn0dGNi86ioudcdHR0QDcuOouMnnPR0dEB3bjo6Ojo6JwEdOOis2i0ij/q6Oi8vtGNi86i0Too7Ew0MGfiOevoLFV046KzaLTmW87E3MuZeM6LiYx91tFZDHThSp1Fw2azUSqV5o0LPt6CLXNRXmk+Susxjh0v3Pr4he7zWjnR4yzW8/2y/DKhSHlso9HAaDTSaDQW9dx0Xt/oxkVn0TAajSfsvZyI4vArHWuhxy+W5/HLTq08HbyWc2k1zOKxOByORT0vndcvhuZS2H7p6Ojo6JxV6AFWHR0dHZ1FRzcuOjo6OjqLjm5cdHR0dHQWHd246Ojo6OgsOrpx0dHR0dFZdHTjoqOjo6Oz6OjGRUdHR0dn0dGNi46Ojo7OoqMbFx0dHR2dRef/BydCkVxExwuMAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 80 val loss: 0.0545\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 80: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.49it/s, recons_loss=0.0578, gen_loss=0.298, disc_loss=0.233]\n", + "Epoch 81: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.54it/s, recons_loss=0.0582, gen_loss=0.326, disc_loss=0.226]\n", + "Epoch 82: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.31it/s, recons_loss=0.0563, gen_loss=0.322, disc_loss=0.221]\n", + "Epoch 83: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.54it/s, recons_loss=0.0561, gen_loss=0.314, disc_loss=0.24]\n", + "Epoch 84: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.60it/s, recons_loss=0.0568, gen_loss=0.282, disc_loss=0.255]\n", + "Epoch 85: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.46it/s, recons_loss=0.0563, gen_loss=0.307, disc_loss=0.23]\n", + "Epoch 86: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.59it/s, recons_loss=0.0552, gen_loss=0.303, disc_loss=0.228]\n", + "Epoch 87: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.37it/s, recons_loss=0.0586, gen_loss=0.318, disc_loss=0.229]\n", + "Epoch 88: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.46it/s, recons_loss=0.057, gen_loss=0.328, disc_loss=0.234]\n", + "Epoch 89: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.45it/s, recons_loss=0.0568, gen_loss=0.32, disc_loss=0.245]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 90 val loss: 0.0545\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 90: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.57it/s, recons_loss=0.057, gen_loss=0.284, disc_loss=0.226]\n", + "Epoch 91: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.39it/s, recons_loss=0.0574, gen_loss=0.334, disc_loss=0.225]\n", + "Epoch 92: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.55it/s, recons_loss=0.0541, gen_loss=0.285, disc_loss=0.235]\n", + "Epoch 93: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.42it/s, recons_loss=0.0578, gen_loss=0.305, disc_loss=0.251]\n", + "Epoch 94: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.48it/s, recons_loss=0.0566, gen_loss=0.322, disc_loss=0.225]\n", + "Epoch 95: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.69it/s, recons_loss=0.057, gen_loss=0.277, disc_loss=0.226]\n", + "Epoch 96: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.63it/s, recons_loss=0.0568, gen_loss=0.328, disc_loss=0.251]\n", + "Epoch 97: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.39it/s, recons_loss=0.055, gen_loss=0.322, disc_loss=0.257]\n", + "Epoch 98: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.53it/s, recons_loss=0.0559, gen_loss=0.283, disc_loss=0.242]\n", + "Epoch 99: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 5.63it/s, recons_loss=0.0588, gen_loss=0.331, disc_loss=0.242]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch 100 val loss: 0.0640\n" + ] + } + ], + "source": [ + "autoencoder.to(device)\n", + "\n", + "# Loss storage\n", + "epoch_recon_losses = []\n", + "epoch_gen_losses = []\n", + "epoch_disc_losses = []\n", + "val_recon_losses = []\n", + "\n", + "for epoch in range(n_epochs):\n", + " autoencoder.train()\n", + " discriminator.train()\n", + " epoch_loss = 0\n", + " gen_epoch_loss = 0\n", + " disc_epoch_loss = 0\n", + " progress_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=110)\n", + " progress_bar.set_description(f\"Epoch {epoch}\")\n", + " for step, batch in progress_bar:\n", + " images = batch[\"image\"].to(device)\n", + " labels = one_hot(batch['label'], 6).to(device)\n", + " optimizer_G.zero_grad(set_to_none=True)\n", + "\n", + " with autocast(enabled=True):\n", + " reconstruction, z_mu, z_sigma = autoencoder(images, labels)\n", + " recons_loss = recon(reconstruction.float(), images.float())\n", + " p_loss = perceptual_loss(reconstruction.float(), images.float())\n", + " kl_loss = 0.5 * torch.sum(z_mu.pow(2) + z_sigma.pow(2) - torch.log(z_sigma.pow(2)) - 1, dim=[1, 2, 3])\n", + " kl_loss = torch.sum(kl_loss) / kl_loss.shape[0]\n", + " loss_g = recons_loss + (kl_weight * kl_loss) + (perceptual_weight * p_loss)\n", + "\n", + " if epoch > autoencoder_warm_up_n_epochs:\n", + " logits_fake = discriminator(reconstruction.contiguous().float())[-1]\n", + " generator_loss = adv_loss(logits_fake, target_is_real=True, for_discriminator=False)\n", + " loss_g += adv_weight * generator_loss\n", + "\n", + " scaler_g.scale(loss_g).backward()\n", + " scaler_g.step(optimizer_G)\n", + " scaler_g.update()\n", + "\n", + " if epoch > autoencoder_warm_up_n_epochs:\n", + " with autocast(enabled=True):\n", + " optimizer_D.zero_grad(set_to_none=True)\n", + " logits_fake = discriminator(reconstruction.contiguous().detach())[-1]\n", + " loss_d_fake = adv_loss(logits_fake, target_is_real=False, for_discriminator=True)\n", + " logits_real = discriminator(images.contiguous().detach())[-1]\n", + " loss_d_real = adv_loss(logits_real, target_is_real=True, for_discriminator=True)\n", + " discriminator_loss = (loss_d_fake + loss_d_real) * 0.5\n", + "\n", + " loss_d = adv_weight * discriminator_loss\n", + "\n", + " scaler_d.scale(loss_d).backward()\n", + " scaler_d.step(optimizer_D)\n", + " scaler_d.update()\n", + "\n", + " epoch_loss += recons_loss.item()\n", + " if epoch > autoencoder_warm_up_n_epochs:\n", + " gen_epoch_loss += generator_loss.item()\n", + " disc_epoch_loss += discriminator_loss.item()\n", + "\n", + " progress_bar.set_postfix(\n", + " {\n", + " \"recons_loss\": epoch_loss / (step + 1),\n", + " \"gen_loss\": gen_epoch_loss / (step + 1),\n", + " \"disc_loss\": disc_epoch_loss / (step + 1),\n", + " }\n", + " )\n", + "\n", + " epoch_recon_losses.append(epoch_loss / (step + 1))\n", + " epoch_gen_losses.append(gen_epoch_loss / (step + 1))\n", + " epoch_disc_losses.append(disc_epoch_loss / (step + 1))\n", + "\n", + " if (epoch + 1) % val_interval == 0:\n", + " autoencoder.eval()\n", + " val_loss = 0\n", + " with torch.no_grad():\n", + " for val_step, batch in enumerate(val_loader, start=0):\n", + " images = batch[\"image\"].to(device)\n", + " labels = one_hot(batch['label'], 6).to(device)\n", + " with autocast(enabled=True):\n", + " reconstruction, z_mu, z_sigma = autoencoder(images, labels)\n", + " recons_loss = recon(images.float(), reconstruction.float())\n", + " val_loss += recons_loss.item()\n", + " # We retrieve the image to plot\n", + " if val_step == 0:\n", + " reconstruction = reconstruction.detach().cpu()\n", + " plt.figure(figsize=(5,3))\n", + " plt.subplot(1, 3, 1)\n", + " plt.imshow(images[0, 0, ...].detach().cpu(), cmap=\"gist_gray\")\n", + " plt.axis(\"off\")\n", + " plt.subplot(1, 3, 2)\n", + " plt.imshow(reconstruction[0, 0, ...], cmap = \"gist_gray\")\n", + " plt.axis('off')\n", + " plt.subplot(1, 3, 3)\n", + " plt.imshow(batch[\"label\"][0, 0, ...].detach().cpu(), cmap=\"jet\")\n", + " plt.axis(\"off\")\n", + " plt.show()\n", + "\n", + "\n", + " val_loss /= max(val_step, 1)\n", + " val_recon_losses.append(val_loss)\n", + " print(f\"epoch {epoch + 1} val loss: {val_loss:.4f}\")\n", + "\n", + "progress_bar.close()\n", + "\n", + "del discriminator\n", + "del perceptual_loss\n", + "torch.cuda.empty_cache()" + ] + }, + { + "cell_type": "markdown", + "id": "ef7953d6", + "metadata": {}, + "source": [ + "### Training the diffusion model" + ] + }, + { + "cell_type": "markdown", + "id": "6540c598", + "metadata": {}, + "source": [ + "Likewise, we use the same approach as in the 2d_ldm_tutorial." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "bcd8df52", + "metadata": {}, + "outputs": [], + "source": [ + "scheduler = DDPMScheduler(num_train_timesteps=1000, schedule=\"linear_beta\", beta_start=0.0015, beta_end=0.0195)\n", + "optimizer = torch.optim.Adam(diffusion.parameters(), lr=1e-4)\n", + "inferer = LatentDiffusionInferer(scheduler, scale_factor=1.0)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "c8618e11", + "metadata": { + "lines_to_next_cell": 0 + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 0: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.05it/s, loss=0.993]\n", + "Epoch 1: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.37it/s, loss=0.986]\n", + "Epoch 2: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.977]\n", + "Epoch 3: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.10it/s, loss=0.98]\n", + "Epoch 4: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.44it/s, loss=0.971]\n", + "Epoch 5: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.43it/s, loss=0.95]\n", + "Epoch 6: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.54it/s, loss=0.945]\n", + "Epoch 7: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.37it/s, loss=0.939]\n", + "Epoch 8: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.36it/s, loss=0.929]\n", + "Epoch 9: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.918]\n", + "Epoch 10: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.904]\n", + "Epoch 11: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.50it/s, loss=0.894]\n", + "Epoch 12: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.35it/s, loss=0.894]\n", + "Epoch 13: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.40it/s, loss=0.894]\n", + "Epoch 14: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.24it/s, loss=0.88]\n", + "Epoch 15: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.47it/s, loss=0.871]\n", + "Epoch 16: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.871]\n", + "Epoch 17: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.54it/s, loss=0.847]\n", + "Epoch 18: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.44it/s, loss=0.834]\n", + "Epoch 19: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.55it/s, loss=0.842]\n", + "Epoch 20: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.55it/s, loss=0.832]\n", + "Epoch 21: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.50it/s, loss=0.814]\n", + "Epoch 22: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.44it/s, loss=0.798]\n", + "Epoch 23: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.54it/s, loss=0.807]\n", + "Epoch 24: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.48it/s, loss=0.805]\n", + "Epoch 25: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.38it/s, loss=0.797]\n", + "Epoch 26: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.21it/s, loss=0.783]\n", + "Epoch 27: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.32it/s, loss=0.764]\n", + "Epoch 28: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.49it/s, loss=0.757]\n", + "Epoch 29: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.54it/s, loss=0.77]\n", + "Epoch 30: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.40it/s, loss=0.746]\n", + "Epoch 31: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.44it/s, loss=0.741]\n", + "Epoch 32: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.51it/s, loss=0.737]\n", + "Epoch 33: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.738]\n", + "Epoch 34: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.735]\n", + "Epoch 35: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.38it/s, loss=0.724]\n", + "Epoch 36: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.60it/s, loss=0.709]\n", + "Epoch 37: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.57it/s, loss=0.698]\n", + "Epoch 38: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.15it/s, loss=0.729]\n", + "Epoch 39: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.48it/s, loss=0.716]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 39 val loss: 0.6634\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1000/1000 [00:26<00:00, 38.07it/s]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAACFCAYAAACXD7UpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABn80lEQVR4nO29e3Sc93nn9xnMfTA3zOBGgCBBEbxKoCiJFnVzTO8qq2xs2dlYWXtjbeOcumedc7xN2qbbnrNpV21392x73Dbdumfts+mpt81m462deH1J7FSJmUiWRYeUaFGiBImkQIIAcZvB3DBXzEz/GHx/+M0QpCgZvAB8v+dQIgeDd96Zed/f83ue5/v9Pq5ms9nEgQMHDhw42EB03e4TcODAgQMHWw9OcHHgwIEDBxsOJ7g4cODAgYMNhxNcHDhw4MDBhsMJLg4cOHDgYMPhBBcHDhw4cLDhcIKLAwcOHDjYcDjBxYEDBw4cbDg8N/pEl8t1M8/DwS3CzdTMJpNJKpUKzWbzpr6Og42BfU93dXXh9/tJJpNMTEzcxNd87qYd28GtQ7P53Hs+54aDiwMH74VyuQysBTCXy0Wz2TT/12PXgp77frFeIHuv17nR524FXO9z1c8ajQbVapUrV67c4rNzsFXhBBcHG4rOhUx/v5EF/IMu8u/397Z6MOnE9d6vHfjr9bqTcTrYMDjBxcGGQQvTnZ4Z3EgWtVXwft/r3fCZOLg1cIKLg5uCO3mRupPPbaPhBBUHtwsOW8zBhsEpqWxO2IHF+Q4dbBSc4OLAgQMDJ4NxsFFwgosDBw4cONhwOMHFwYbD2f06cODACS4OHDhwei0ONhxOcHHgwIGTbTrYcDjBxYGDG4DL5cLlctHV5dwyDhzcCJw7xcGGYyuUWDrfg21js5V3+Vvhu3NwZ8AJLg4crIPOLKXZbLKysuIsvg4c3CDuWoV+IpFg27ZteL1ewuEw3d3duFwuvv/979/uU9v0uBN39tfKOGxvrWazSVdXF41Gg2azSTKZZMeOHQQCAQKBAC6Xi6WlJU6fPm2eZx9fwehaWY+DrYgEcBR4GEZdrRX13Fng39/e07oDcNcGl3A4bIJLJBIhGAwaV18HWwu2eaYcgPWY/q4xAfV63fxeKBSiv7+fQCBAIpHA6/UyNTVFs9mkVqvhdrtN4OhUua9n3ulgK2IUth+F34LYF2cJ+ovMPnoQXr7d53X74WreYJ6/mW6Qrq6utvPdtWsX8XicWCxGNBolEAjg9XrNz7u7uwmHw6ysrFAoFMjn87z11lu8/vrrbY6xWwE3s6wTDAbflwvyrYC98DebTRNMFBiUcdx///309vYSCAQIBoMmC9Gck3g8TrPZJJvNsrCwQKPR4J133uH8+fPmM11ZWcHj8bRlNJsFdk+pWCzetNfZXPNcvLT23yur/34QeBLGvHDf6kODwCOtP/fsewM/Fd78Dw/C14DLwMkTwPHVY9Ru5cnfVNzIPJctEVx8Ph8ejweXy0UkEuHQoUN4vV5T3ggGgySTSRKJBKFQCLfbbRaPer2O3+8nHA7jcrkoFAosLS2RyWQoFAqUy2VKpRIvvvgitVqNer2+qTOcuy24AOYa0OIZj8d58MEH6e7uZmVlhWKxiN/vJxaLEYlE6O7uxufzUau1FoNQKEQwGKTRaFAul8lkMtRqNUqlEsVikUKhQCaT4fTp00AryFQqlbagdqeXxpzgAhAFIqt/H4DRT8AvAJPAi7T+/gUIHEmzKzaJjypuE3iuxgxDzH71HjgNvAUcnwP+lFaQSQOlm/ZObja2fHAJhUKEQiHuu+8+BgcHCYfDhEIhuru7AcziEAgETF/FDi7awfp8Pvx+P41Gg+XlZfL5PNlslnw+bxaPer1OpVJhYWGBEydOmKCz2XArgsudcq24XC4TGB588EEGBgbo6uoyPRSfz0elUiGTyeDz+eju7iYajeL3+01A6OnpMddMs9kkl8sxPz9PoVDA7/dTr9fJ5XJUKhUajQZut5vp6WlOnTpFqVTadBuRuzO4JIBRCH8CfotWshIGPlPmwPBZFull4Y0deAdzjCbfxUOdOBnGOUM/c3ioEyGPm1Z1o0iIDHEm2Msku6jiY64+QPq7w61AUwZ+Fyh/DZhmM2Y0W34S5d69e7n33ntJJpP09PQQCARMo3VlZcUsJD6fj2AwaHak9s+1W200GhQKBVZWVszzA4EApVKJeDxOV1cX5XKZYDAIYEoiDu482D2Uffv2MT4+TiwWM9eHx7N22Xd1deH1enG73QSDQYLBIM1mk1KphNfrxefzEQ6H8fl81Ot1SqUSLpcLr9drmvxer9cE1Hq9bjYrExMTnDt3Drjzm/p3+vndXPwy/Nfb4TOw5/6f4qG9BN7LIr33Lpp/u6kzzhlCFJlkF6O8y2FOEycDwAt8mAn2MsZ5qviZZJQB9xwDn5yDT8IKbt75+P3whc/B698Ezty6t3oLsSmDSygUYvv27ezatYvBwUGi0ajZXWpca6PRMEEiGAzi9/vNjrRcLlOpVHC73UQiETweD9VqlUqlQrVaJRQKEYvFzM53ZWWFer3O8vIy1WqVbDZLPB4nEomQz+dv98fhwIIys3A4zMjICCMjIyQSCWKxGF1dXWbaonpoukZ0bajhD63Mt1gs0t3d3VZW83q9JiOCNdpyrVYzG5RYLEYymeTKlSvk8/kbHvXs4FYiAfxt+IXthH9ngZHuqes+O0mKAeZYIg7AFCOc5SAZ4oxx3mQvMwzxJgf5Rf7EBCFhkV7m6Wfn429x8bf2w+d/HrgI5G7au7xd2JTBJZlM8uijjzI4OEhvby+hUIhGo0GtVqNWq1GtVvF4PASDQeLxeFuZLJfLkcvlqFarZpGIxWLAWm3c7/ebJn+9Xqder1MsFkmn09TrdYaGhkxJbXFxkampKVOCc3B7oeAQj8d5+OGH24gc1WqVcrnMysoKjUYDr9dLNBolFovh9/tJp9MUi0XT9K9Wq+RyOVNqVdYTiURIJpOEw+G2MuPy8rIpn1WrVfL5PHv37mV5eZmLFy9SqVQ2Rf/l7sEh+J09dH1xmf7u+Ws+K06GUSY5yFmSLPIDnuI0h1nBDbSCzBnG2c05Qqt9lBGm2M15Bpjjw/yVOdbb7ON7/CJTjBB4Jk35rQR86QvA87QymK2zjmy64BKLxThy5AiJRIJEImGooplMhkqlYspd0WiU3t5e4vE4gOmd5PN58vk8jUbDZCOVSoVwOGwCUSQSMQEGWkHJ7/fjdrvxeDx4PB6TJYVCISKRCK+//vqWYZRtRigzcLvdRKNR7r33XiKRCD09PfT39xOLxcjlcia4iILe19dHIpGgXq+TzWap1+sm+KiBXygUiMVihEIhk7GqzKbrSJsNt9ttyCS5XI5CoUA4HCYajfLqq6+a4wp3SqC5E87h1iIBg8fgWdg3MME2ZhjjPFOMMMmoeVacDB/mBT7MX5EnwnE+avooQhUfE+zjPGMc5Cz7mGAfE4xxDh/VtlftJYWbOn/CL0IM3vliBDIh+NYnYDFKi1m2NbDpFPoej4dYLIbX6yUYDJryhM/nMzd3IBAgFosRi8XweDyUy2WWl5dNWUu7R+kVqtWqWZSSySTd3d14vV78fj9er9fsWNXwFXEgEAgQjUbZtm2b4zl1m9C5KK6srOByuRgYGCAWixEMBg0DLBQKmT5KMBgkGo0SiURwuVyk02mT0SrAKAPJ5XKGUTYwMMC2bduIx+OGGKCNh8/nMyQTXZ+6LqLRqKEpixJ9J6n976RzuTUYht+CPft+CsAY5/k0X+cwp9uelSTFEU4yxBWmGOEER9sCizDJKGcYB2CcM4xz5qrAAuCjylFOsJcJPNTxhkvQCxwBOEaL/rw1sOkyF9XNtQDU63XcbjexWAyfz2dKYvF4nFAoRKlUMoGlVCqZxcftduNyuVhZWTE9Gr/f32b7Yf/f5XJRr9epVqusrLToh8pwGo0Gf/fv/l1DY37xxRc3pdZhM0KLoj7ver1uMku7VOlyucziH41GzSYhEAhQqVTI5/NUq9U2FqGusa6urrZyqVhhChJ6rU6qend3N/39/ZTLZbq7u/nkJz9JrVZjamqKU6dO3dCCbvdqbibuvsylBG9Bhh56aTXr3dQ5yFnzDDcr9JIiSWo1eBxaN7AA1HFTXy2Tubl+BeMsB5lkFwDJ5CKzvxSFJ2jFlpf/cUuAOfunwImf8T3eXmyq4NLb28sv/MIvmBtfJQvd/IBh90hRrWAgqqi9o9QiouxF4kotVKLVij2UTqdZWloil8vRaDSM6E4N4mKxyPz8PI1GgxMnTjh9mFsI9Vp6e3s5cuSIyWLFAgRM8AgEAqan5vF4WF5eNmJJlT51PJXQ7KzHXoiV4aj5Pz8/z9LSEvV6nVAoxMjICLVaDa/Xa6jM2pT89V//NeVyeV0fs+sp/G9GsLlTynO3BlHgE3B47ZFJRvkGnzJMsSAlDnKWXbT0LK2AMEqQa9O03yuo1HFzhnH+mL/DeXYD0EOGnqOvtH73Y63nTMzto/Hlvw3/9GHgK2zWPsymCS5dXV08/fTTAIZOXCqVyGazFItFKpUKtVqNZrNJNBqlXq+b0ojElbVaDY/Hg9/vx+PxmKDg8XhMgAFM7V7ZSqFQYG5ujnQ6zfLysunBJBIJotEoAJVKhWKxaBafXC7Ha6+9dts+r7sFCv7aEBw5coS+vj5CoRA+n4+VlRVT1pL5pHoqLpeLeDxOIpHA7/dTrVZxuVwmuOj6cLvdhMNhE3zsbEIbm1KpxPz8PKlUygQxt9tthJra2Ci4HThwgFwux09/+tO292Mv8p3WMirldr73jcLdUxp7Gp6LkvjitMlaphhhihHzDB9V3mYv45zhMV5ijHN8mq9fM3OBVhP/egFmgn1tgcXGKJPEyXCaw+wbmKD4P4S4OLgfvvh32Kw+ZZsmuOzatavt3woG5XLZ0IhttpgymL6+PsPsqdVqZoeq+netVjNlLnuRsm9oKbErlYrRMUQiEeLxOPF43NCflSn19vYyNDTEwsIC6XSaSqVyaz+sLQ57EbQX476+PgKBAIAJAo1Gg2Kx2GYqKSp6V1cXwWCQvr4+s0mw/cJ0LdhaGEELu45bqVTIZrNGWOv1eo2exi69+nw+o8USISWTybRdg+u911uRVdyqEtztxQAE9sBhqJZ9zAUGiLsz+Gm/R6v4OMtBioQYYWpVMHltRtmNYIZtbQEMWkEsTsYw0TLEqeIjQ5yZzwxR+/JBeOsAcI7NlsFsiuBy8OBBHnrooTafL5W1Go2G2SUChuGTSqWIxWKG3RMOh4Grd4NqrNoLBawtTvZzpeIWo0z6GNXzlR1Vq1XGxsYIBoP8+Mc/ZnZ29qr3FA6HGRwcNH0eaAXMiYmJm/dBbnKsV7pRBjI8PMz+/fuNLUutVqNSqZjPV7+r71ialOXlZUPigFYg0XPs4LLe6wJt14jH4zHZiTJYlc10fSroNBoNxsbGcLvdvPLKK6RSKfNaeq/hcJhkMml+t16v02g0mJ6e3vAgcHeUxAaAz7bKYcehkOmD+8D3UOWq4CLM0c8Zxk1msVHoZ55eFglSYoA5kizip8phXqWOhzOMM5Sc4eKXovC5T8Piv6al5u9EEBilpdkRJq/x3FuLOza4jI6OMjo6SrPZZGRkxNTQJXxU0PD5fG1lrHK5TC6Xo16vG9qxauwqp9kBpvOmkshOC1IgEKCnp6dtsVKGkkqlKBQKhlnm8XhMZqS+j8+3lka7XC527NiB1+ulv7+fHTt2GCGerGfq9bpRdTu4NlwuF4lEgt7eXjweDwMDA4Ym3t3dba4Vv99vFmz1U2TlU61WDT1duij7++p8PUEbEZFDXC4XwWCQ3t5evF4v5XLZBB+dg4xS/X6/OU44HCYSibQFr66uLvbs2WNIKQMDAyZIlUol6vU6Xq+Xd999d8NLYlszwIzR6pSngXF4xNUymtwPHIHE/mmjTVkPJUKcY4xJRhnnzHv2Va6HAeY5wklWcHOQs/ipMsloG9NMyBAnRJHAE2nKhxPwfLDjaAdW/xyCX6JloAkts8zvQss5c/IDn+tG4I4MLiMjIxw7dsyIGHWjSpuQSCSMOE4WHNopZjIZms0my8vLFAoFpqenKRaL9Pb2kkgkCAQCbeUNoG2n2jmTQze52+1maWmJfD5vjC2ll9ECpvq7SmgqdQjj4+Ps3LnTZD6hUKiNcRQKhdizZw+NRoMLFy7c7I95U8Fe/FwuF729vTz00EPEYjHz+QFm0yFKcDKZJBqNts1fETlDvmIul4tSqUR/fz+9vb2GCKDv07bo1+sDRrOimUDQuka16VDwgbXejDKZrq4uQqGQIRUo6D388MOMjo4apwjNGZJuRpqaZrPJ5OTkuj2aD4KtGVhG4b5n4XeA2e2th8LAIzB47wVClPBTIUmKfUwY6nAdN+fYzRWGgFY/5gc8xRwD7GOC0Q+4aO9jghGmOM9uZhjiNA9wnt0UCRmm2Y3hs/CZPa0geQwS903jdreC3sIbO+BJ4Eufg8tf43YGmDsyuEg1L32JGqti7UhfID1LIBAwz5MbrdxuAcrlMs1m0/xuZ9nD1hysx8xRYz+XyzE3N0cul2N5edm47WoBUs+nVquZ4GYLK4eHhxkeHiYYDJosR2whOTvrHB1cG8ooh4eH6enpAVrfW61WIx6Pm2AvLcu2bdtMxlCtVllcXGwrnS0sLFCr1YxIUl5hdg+us5wKtHmUSUyZzWbb+niwNq7BtidSk9/j8RAIBEzGPDw8TG9vL5VKxeittHGJx+MsLS1RrVbNhkcB7k4yDL1zMA6/A/d8+o22xdtHpc0/bIQpfok/NmWvKn6+zqdNcFH/ZYJ9PM23P3Bw8VHFR5VLjPAdPtFGX35feHIP2//dO7ipX/Ve4vcuUbo3xGX2wG89jBNcOmDXsGFth6hyhhaFUqlkdncKLlLM6+ZWP0aLuT1pUPRk6SKuZRcvmrGsY5aXl9tmd4hlJjrq8vIyqVSKSqXCsWPH+LM/+zP27NlDIpEw5TlRoLVD9vv95pjRaJTR0VEmJydv3Yd+h8Ne7NXTUCC2vz8FBru30qmBkdZF3509j8UuidpqfXvxtq8VWOvJrKysGDahSrX2caAVpOS2rUb//fffT6lU4siRI+zcudPoaZThKMDU63VisRjFYpFkMsnOnTudDPe6CEKYa/ZThDn6Oc8YRzmBmzqeVWPKSUaZWQ0wIC3L+ktmHfcNlcwm2MsZxtdlna1Ygead84fgdRcssrpKHwPmgV+DL0KE9T0NPdRbdOlewHMQVsZokQFuPe6o4KKexEc/+lHzmL2Ay69JgUQOxioprKys4Ha72bFjB0NDQ6aEoB1pNBrF7XZTKpUoFArMz89TKpWIRCJEo1GzMMlJ2V6ktMjohtdOuFAokMvl2gKeFpt4PM7g4CCf+cxnjIWI+kSqoWu3HQ6HKZfLRKNRenp6WFxcNO9rszF4blb9Xt/F0NAQjz76qJnBo4W7Xq9Tq9WM6r5Wq5HJZEzJUSzCQCDAwMAAiUTCBA6/309PT4/ROUl4m8vlWFlZMeaW2qzYdHYFnmq1SrFYNCQPlduWlpYoFAqGNaiSmajN0WiUj3/840SjUdMvErvM4/GYvqJdgstmsyawqvy22a6Tm4sDcOwg3kdyrJiQ4ebixd3gqbNneMLs+K8wxJ/wi5xjN36quKmzjwme4RvMMdB21N3WQl3FxyJJTvMAGeLs5hzjqw7HHpOXtAec84xxnrG2x1ZwM5naRe3FaMuOf4WWNf85Wiv0fuDJ7XDuP4ePw56PtdPX5+oDpGeT7ByeJESx9b6eqMHnvPB7h2g192/9eJA7KriEQiGeeuops8jb4keVFsQGk92GbmZZu/T09LBz506SyaQRrmlH29XVZW72dDrN9PQ0+XyecDhMOBw2vlDJZNLQWrVzlFeZat8qfc3PzzM7O0uxWKRerxMOh9m1a5dh+Xg8HnK5luOpFiiv12vKZ2oka2eq+rvo05OTk2Qymdv4rdw+2AFKgT0UCvFzP/dzDA4OmnJlJpOhXC6bhVcaF9m3LC4umuFfgUCAZDJp5v/oNbxer7nuxDZcWFgwuhXpXLRZ6enpMaMYdK4ijkhTU6lUKBQK5ji6hru6ukwPUHZFfr/feJXZ7Ee7hGs7OXd1ddHT08OhQ4eYnJwknU7fsu/lzkcU7vs0/H6ZseQ53s2OUv5+Agqs7ui9nPeMsW9gjZlp61zc1JlihGf4Bg9xat1XKBLkJxzlJEc4z27yRNjGDKd5ADd1QhQ5ygl20z6WY5wznOUgpy0F55XlIWp/GG3Zimn8T4DWcLLDQG+Tnbsn2tyVbfjcFQLhYlsg27nzPBcP74feQ7A4APwRMHfDn+BG4I4JLi6Xi507d5pBXl1dXUbHAphF11bji7FTqVRMD0Q7Ps3bUP3bNqrUIDDpHbTrBMyNrlq+XkcMsGKxSLlcNpmKBosVi0U8Ho9hMPX19VGr1YxRogKX3dgFzG64UqlQLpfNse1S3mbDRmctNo1427Zt9Pb2mlJooVAgnU6zsrJimvGCPmvZ9mgeiz2TRVZCdl9EDtgLCwumzFWpVExWE4lECAQCRCKRtvPTNSLLIV2X2Wy2TesUCoVIJBJmeJkdoDpp0zp/lYbl7F0ul8nn8+bats9j6zK/bhQPwhfgwPBZKvgpv55YZVABnwc80FjspiMpMajjZpJR5uhnlEmKBMkQp46HOBki5EnRy0mOtAcJhkyfJkKeUSavCi7SzCggVfBTeKtvbYiY4AGOwIGHXnnPd9tDhp5Yxvx7iTipVG/reI8AJwdgNsFdG1zuv/9+Hn74YbN7FNtK2gGxwmw9SqPRoFKpmBtX5ayVlRWz6KusIcrn0tISqVTKLBqdN7cWJy1G9qx10Vzz+TyZTMb0X/Q8lUuCwSDhcNg0brXTVONW5yyCgno6+XyeUqlkZoZ02oLcrdD3vn//fj70oQ+Z3pW+fzH6+vv7zZA3m2quz1Hfra4vjbEWC0uGqOqv6boSjdieBaONg15L2isZqRYKBYrFonHr1nWrjY/Kc/aMGVuBr2tR5TD56FUqFeMUId8zp5lv43F49hiBZ9NU8HNh4l44SUsKchgST7T0Hz739fswddzMMMQEe7nCEK/yACWC7OVtDnKWUzy0rtL+RjDEDP3MkydCqpJseYllPtCh1sXs9BB8KwCvb9wxPwjuiODy8MMPMz4+bnb2ql13d3ebG167Rvl1aThTtVqlVqu1lZbS6bSpa8tGXa60hUKhbeKkzTZT1qSgMTw8TCQSMTteLTYyyCwWiwQCgbbavconajZrYVMJTA1/sYE07VLDy4LBYJsbwGaso2/Uztl+74cOHeJDH/oQfX19uN1uY+Pi8/kYGBgwfSt9h8A1swJplJaWltqCjDy/FOwV5MXK0v+Xl5e5dOmSoS97vV7TzC8Wi+a61MjsWq3WFuS0+RBFWqVfXct6rq4pZSayLlLJT++x87O6e3EMvnCM2O/OkvSnWoHl+8AgdH1mmf6BOXpucBUvEuI4H+UnHDVji+u4mWKEUzxEhjh5Im2/0888I7QGjs2wjef5m8zRz+O8RD/zzNPPFCO8xjjz9FPBT/b1QXiL9qwFYBS8ozm2MUOByFWvBVDBT6qSJOLPtzX4B4dnmB27hw6D51uOOyK47N69u82ORY1X6RV8Pp8ZM2s7GMtfzGbzqCejhdke0KRmvmw4enp62kRsEl6eP3/eqLcHBgZwu93GO0zZiAwN4/G4IRv4fD4zvEzBTiNv8/m8KX0VCgVzDgqWMsB0u92Uy+WbOsf8ZmMjd9FaNHft2sW2bdsMy25packMg1P/TdMk7X6FrW/RQqxpojKc1KKu7FQBSIHA5/OZYC9K+oULF0gmk+zevZuenh7z+NLSkjmmrhf7vdjGqirj6fVzuRz5fN5kQcqsAdM/dLvd9PT0mFkxncHlg2YxW6KUNnaMxJenSboXW2yr7wKDEP74Atu6Z64aX3w91HGv+iEn2x7Pr7PQJ0kRIY+PigkuU4zwH7739/gPY3+P4/uO8uA7b/L9Pf38IZ8mQ5wSodZxXqYlfLThAZ6A8eRrPMZL1PGQImlYbaIvFwmSfXGQ4uEQkeRacOkhQ/2pSyy8tQOuNge5ZbgjgotKQHZmEgqFDCNLi4dtueH3+9tuePVetLuUvb7KEHqO3I+7u7sNO0iZg+a+ZLNZMpkMqVTKlOQU2FQuA9oCona5soeRlqWztKFyinas2mnbtGtpeOzF5W6EXSpSb8rj8ZDP51leXm6jIttZiv6uTYO9AOs6s9l/MqqEdjqyRLvBYJBMJmP6etInpVIpo8qX+7I2BQpcynh0ragkFg6H6enpIRQKUSwWzR9lV+rLdWZiKysrbXNkVD7T+1IwvSt7L72QdC9SxQ8vuloL6zO19x1Y3i+GmGGUSV7gw4YUkKK3JTEZhI/M/wS+CuNfOmMCC0C97m6RDFbWOWgYQpTYsdqjWcHNC/wck+wywaWOBwpQK19Naw5RbAlGbyNua3BxuVx87GMfMzt47bp8Pl/bkC77BpM3k+3dJDNJlTDsBUPBSk1RlcJisRjhcNj0dmy7jt7eXsPqUvCyd4R6vmjQ3d3dxlbd7/cb5o/L5TIZkObJiG1kq7LthqzOV/2bgwcP8uqrrxrG2VZHpxK/q6uLJ554gp6eHiM41cKvTcl6pTD7MXtXr7/bPRC9jprmyjg1zrirq4tsNts2xyeZTJoeiDYytmBW56lBZaIMa/ZQLBYzjsna1NjiyvV8zZSNK5ioz7d37962bOyDBJRrabw2Dz4Lj8A70/vYOTzZWtkOQ9/OKzc1sCRJGVuYOm4TONzU4RiERxf4193P8vCXTvADnlpfJ7OdVuM9vvZQ4HCag5xlGzNkiPPa6ggyW3QZoghHyvQNv4eh5nZg9nFalORbt47c1uBy7NgxRkZGTK9EdFJlLZq9ItGhWFvKaGxGmG48/V1NWLHNVMbq6+tj586dxONxXC4Xc3NzZqcoOunQ0JAJdlp0FOQA03RPJBJt2ghRkePxuNlhLy4uMjs7a8ojEnmKeKDsy3Z07urqMiXBlZUVjh49yksvvcTy8vJt+JZuHdZzR3j44Yc5dOiQEZ9qUVVTv9OXy2Yb2n0W+5jXgyadykYmGAya+T02oUSEDW1wtNHo6uoyAslYLMaOHTvo6+try0DVS1R/cHZ21vRmtNkQBd4u99qsNM0rKpVKlMtlDhw4wGuvvWauzZ+lPLb58Mvwu3vgmTJdnnpLy7K91byXpf5GI0Kew5xmnDMc5OxV3mB+Khy4t8X0+l/5z/BRvUrMWV9xt6jRj8CBj7xChDwVWmtbiCLjnMFPlR/wFC/w4avKcSGKHBg+y3rwUYEnazDqbWVGz2+HL32WlufYrdG83NbgIpW1MhfpGKQ/sA0hdcOFQqG2Bd9WXytjUQkL1iYQ+v1+4vE4o6Oj7Ny5k2AwaPooGm+rXaFNA9ZNqgFlau67XC66u7tJJpMmmNgU6KWlJebm5kilUkaEp6CpYy0vL5t/q0YverS0MIVCgWazyejoKGfPnt2kN/+NofO9iWEXjUZNJthoNNpGW9ulr84/nbvx9Rbdzp5MNBplYGCAvr4+wuGwKbEqaNm+Y8qOdZ2KOqyemd/vp6+vz7DYbMKB2+1mYWGBubk5lpaWgDW6PazpWmwjVdsZoLe3l1gsRj6fZ2ZmhlqtxqFDhzh16pTJfu8aYWXgEIHPpdkVmwTg3ewo/keqDLhvDvXWTZ2HOMUn+PYN2/B/lB/yD/mXfIdP8FX+QauZ//IgZODRj/wF/4ovUCLECY4atf8Ac/wVH+YlHlu3oX89eKhzYOcZ2AkzlSGyk4NwZABO/m1ampebj9sSXLQoh0KhtomBwWDQzD236832jlFlL/1dQcS+0dW4VwPVzoLUD9EuWCWqa3mLdVI9Va/XzzqzKwVKlTrq9bppPEejUeO6q3KZfl8NW2iv19+tvlHSGsk1Wj23zrJpJ91Y18V6NO5O/YhdBrPp5rIU0iZAJUr9W9efplNqU6HrTWwzle4CgYAR0Or/Yi0WCgVcLpcJoLYjhK4h9YF0rioDq2/n8/nMHBn7Gup831sPXqAfBsHjWSt9KcjcLLipM8q7bYElRJEw+WsGgW3McM9fznLwI61Mo4qvRRUuwzGOc/9X34H9kP9IBB/VVS1Nkkl2kVmtlwUpttn+1/GQJ2xKcddCsRBq9XbuA04eYksHl8HBQR5//HHTKFe9Wrs7u98iFhfQNmJWAUc3vgKI1+s1N5xKDBJJFgoFMpkM4XDYsLmkkLatPLR4SNNgN1k7G/tq7LrdbhNA1AhOJpNGcBePx83MEDX2AVPflwW8Pf9DmR20SnGxWOyuUesnEgkOHTpEPB43eg4tvHbpyyZE2GMZ7MxFsBdZO7jYHmP6eblcNlmEvodCoWAo5XYvUP0OZa+dmbPL1VL9l0olMztG14SeE4/HCYVC5nqXdY3OTfRreetBa0MViUTo7+8HIJ1O09fXx+zsbFtw2ZqBBWAY+DX4OPgC1fd89kahjpt5BphgL6HVeSyiIc8zsK4Z5XE+SuYjPVdrY7bDGOfgKPz08B7+b/4jjnKCx3gJN3WGmCG/2pnfxSTjnDHuzSWCnOAor3IYD3V8VA1l2sZQcoaZz0Ht+Sh8C8gMcyvmvdyW4KKFUyUJ8fxV44a1RVc3vwKIFnrt4kThVT9GO0v1XGq1GtlslsXFRXK5HM1m0/gyaeepjEdBzOVytbkxy7vJNtAUm0dKf3t3Kzdb6V8kBFVTV0FEdXadt0pgYhTV63WzmxV9dSsHF/u7VbBWyVHfpz0WwRZHdgabzjKSftcOLoIGjCnT9Hq95HI5s0lQcFNAETVePQ9NKtXr6TpSsJL2BTDaFumuent7Ta9P71EkE12T6kXWajUz5kHXpD6nYrFINptlaGiImZkZszm60cCyObObAfi4Cz4OIXeRufoA9RU3Q/6Zm/Jqc/UB0pNDJEZnOOE+ylkOrjb0XyNPhClG2hb2CHl2c54ZhszclqtwGb7KP+Dk4SPMsI3zjDHKu+b3P8oPOcoJ8+8kKfOrddwmk6ngZ4xzvMsoU4wYpwBoZVVjyXO8OfogHAGefxL4Nxv98VyF2xJcpB9Qb0MWLba9iy2oVClEJQE1N5Wt6KbXjk9ixmazaXzAVNcW88ftdrc135UtaGFQucP2dLIzGXuErcpjOr7OSfNa1ttFxuNxyuUymUzGlE1EcbWdB7LZbFtfYDPggy5Udm9BqnvphtQ4hzX1+nplMftndhCy/68gI4KG9E2XLl0y142yWQUBCVu1yYlGo4TDYZaXl0mn00Y/Zb8HCSm1UVDJVtczrOlXdO3r52KNyYRTc12k85Hpqd6P7hsdQ5/njWLzBRaAYfgMbH/qHYIUuXxyD5Rh6CM3J7ikTw7D1yD97DCpx+dIkWSKEc6zmzruq0piI0zx6/xffINnmKd//YNm4OTcEfIDV5fT3NSv29NplecmOcoJzjHGQ5zkMV7iT/jFtuDShl64pu/NBuO2BRcFBI/HY5Tvtt5AC4NN+bVpu/LqknBOwkaVLFSKUD1cyupCoWACg3artkJfC4+OI0GdFg7dwLZ9h36mrMTn87G8vGzmyGjnrbKelNYKbPoc3G53G225Wq0a0oEWkq0Mu+Hu8XjMpEYt7vV6vW2So32trNeXsoOK3YjXNWRb48spYWlpyWx+RCaQMFfn1d/fb5rtEnHKFUJ+YiqzlUolw0wUNV7Xkz0XSK8ViUTa3LntzE0bMQk2RRbRddKZpW19eKDXsp8vcLXSfSOxvQy9AXgR3lx5cN2ndO1fNoaYS8SZY4Bf5Q8YYYrv8DR5Iqzg5vL5sZad/n0Q7820HeM8Y0wxQpJF3mafcWYeYYp9TLQZVLqpM8IUPqrEyRCixGFOs4Kbt9lndDdz9QHT41lfWLPxuK1sMS3yYkfZjBsFE5/PZ3b1theYhJD6fTVTVXrSSFhRQzOZjLG9125YzJ50Om16PhLmacHXH5loypesr6/PTEFUGUM2/ul0mlQqRTabBTCCzVgsZthuKmdopyxygTzLstmsCTJdXV3mvIvFIrOzt1F2exNh97ZsQW2lUjGZZ19fX1sgWa+3omPB2u5dn7mCgs0QU0m1p6eHubk5M7pamwBbHDk7O0sul2PXrl3m+HK2zuVylEol40smhptQrVbbypoq1UIrk92+fbvJ0rRB6urqMnoYBTNl8PLNazZbQ+t6enpwuVzs37+fN954Y10q9pbDSsuy3kP9pq+ZXZ46DQ8tVf3J1Qc/Ax/51Pf5yz//BfgaNPZ38+aRB/EeyUESvsGn+Cx/0GbPUscDL7talvr7QVMkBdGah5jhDONmpswokzzDN4ytv9DPfFuGM84ZRpnk63zaBJf6irvlr/Y5oByF7z8IvLcp5s+C2xJc7CmRjUaDYrFoJk+q3q4bS2pkm+mjBqt2ggpMylZUr240GszPz/Puu++ysrLCvn37OHz4MDt27CAcDhMIBKhWq0xNTXH+/HlmZ2dZWFgwFNK+vj4T5ET5lDUMYMSWKmFJNyOfKe1ItVjaC6ddvtDPxCyymWfSXaysrBAOh01GtxUDjB1cSqUSFy9epFar4fP5WFpaMizDzt/pZIXBWlBRv842urR39XpNj8djJoX29PQQDofp7e01PZf5+XkmJye5cOECly5dolqt0tvby86dO/F6vczPz3Pp0iXjHiCWmR0kRD9XFmTPfbF7euq1dJaDlWnZNknLy8t0d3ebrAdgeXnZDJuz+0xbD2fg2YO889v3t+bInwTLpPh9wU3dzGp5m33mcc2CmV/up/F8N2Tgk3/87/gKvwHA4J9lW3O8fhPS/0+AZ/m3/Omv/zK1l6O8+ciDTD0xwtvd+8yx3rl4EF72tny/Mq1zTh1L0juwpsep4+Y0h43jsubCuN9H9GzpZF4zA89G/FMM/c1WufBNz4Nw8hOtzOkmBpjbElzefvtt3n77bT72sY+xY8cO462kHaV2mJrPoQamykqi/tqZjfoharYqW1lZWWFsbIx4PM6ePXu45557TL9HQayvr49t27bxxhtv8Morrxi2jcp3hUKBqakp3n33XbODXlpaMlRiwJQnRIGORCIkEglTswfMAmKXZlTOg7XaeSKRMI1c7VgVRJUhbcXgYmcZV65c4Rvf+AaPP/44e/fupVKpEAwG110o9V116leg9ZlrGFwmk2nz+rL1KP39/ezbt49YLGbMKNUjkSYlEomQSqWYnJzk7bffNnPufT4f2WyWhYUFkwXbjC5l47B2nSjb6enpaRvbbZNI7DKhMixtpCKRCM1m08yPEaVZpT31dPT53GgWs7kC0ZuQeQ7+6XMwSGvBPvzBjjTKJPt4m7McbHs8Ve8l/fwwH3nq+3zvmY/R/VgDHoHnTnQc4C8ByvzJRz7Fh4//GS8+/fPwFhRm+5h7tqW5eWd6H/ye930ZSiZJcZQT9DPHCFOMdVj4Xwtu6jzAaUKUmFs1zHyJxygRwvtIjtrno/AvDrDlgougHbs9b0M7PlgbiqTAo3/bc04UKGx7fmkEms0mQ0ND9Pf3k0wmDU0Y1uaaQ2sBGBgYoFAoMDk5aQwHNYApm81y5coVMpmMOT9bI6FjKtNQySuRSBAMBo0YUtMHO0cua36L7EQAo79R8CmVSmYHLnryVoUdZPRd6lq51k7cppCLTCFGldwOlpeX2z53lU0HBwfp7+83qvdQKNT2eipL7tmzxwyae/fdd7ly5YoZTpbJZMjn823By9Yp6d86R7vUqetdxBNlKrAmrLSDjmb+qC8DmNe1fe3sz2VLo8z7tqzXQC8p4vcxQZzMVUaVPncFRuEf88/480DjPZfi5/4S/ohfpv9IvpVJnYb0kWHqY244+f5s8ONkGGWShzhJLykq+JhbhxjgX+232L2YlsFmmCSLDDFDLynOM8Yko4wm3+Wd/fff+Il8QNz24CKhGEA+nzePa8HWqFmVyGx7GLu0ZIvP5Cw7MjJCf39/m7OyYJdSRA6QU+309DSLi4tMT08bQWSlUqGvr49QKGR6KSq/hcMtHrqCmxhFpVKJxcVFI5i0bUJUAtPC4fV6jRW8ApHKIvqcRHu+03eXH/T8bJaZmvDawSsrLJfLpm/V+TsSn3Z3dxsNCWC0Rt3d3WZ2S6PRoLu7m3A4bBT00K5BsoOZaMmjo6MMDw8zOTnJ7OysGfegRr6+M20KCoUCPT095nq1NTuNRsMMmrM3VzadWeet7EfuyfodsSq1MVHAvNbnuzXxGnzrUMuba7bVSF/PWn9pdeBXL4uEKPIQp6jiW1Xcn6SHDJOM8gIfBlpZw3/HP+FXXvkuPAP/yw2eTd+BAh9/8//lu0//Sss88/chGx5s/b2zslVuDS6rDPjb7GF8VNnNefYxwRQj/DlPXlOg2c8chzhjaMkruDnDIaOpSZJaFX3OMcUIi/TeErfk2xpc3njjDfx+v+lRpNNpU/bS46lUisXFRTO9T7t3NTnV8LZHB4v+2d/fT29vr6l7d+oiOimqoVCIUChEqVRienraLPLQypAOHjzI4cOHuXjxIhMTEywsLBAMBg1BANbKXJp2qaFkmmaoc/B4PKa/ot1poVAwhAGVB9UUzmQyXLlyhbm5OROEtxo6vw+Xy8WlS5fo7+/H7XYbm/loNGp6bMoGbDo7tBblcDhsKL0aKqa/1+t1QqEQyWSSWCwGXHv+i5iAPp+vTQwrVpjYXRpPnUwmje7kypUrBINBU2qzm/W5XM6QAMSGUzBTZiUHB2XLuubtQXQS4WqQmMqp1woyWw/Pw4uj8GQUXobZI/fQc//VOcbsT++BMvQeXcRNnYOcZZR3yROhRIgIefqtaY1JFvmV09/l+K+2JhDfKP71W/CLfI/v8istBltntuIBfpuWa/K3gO/ChfBe9uw8a0w2NQ0zRZIKPlL0tlT96yDIbt5mX1vmkiFulP0+qkywlyp+5hhg4es7Wq97k4WUtzW4XL58mfHxcbPzl+WJgoUWaTnSSqms0pOmN8p1ttP+XlYxsKbqFmwrGbvGLUW0PeNDgSgUCnHPPffg8/m4ePEiS0tLZqFQc9ZW8Kt5rNfRIqjXV+1dx9AgMS0OgFl08vk88/PzXLlyhampqVv8Td0arEclTqfT5PN5w5JSs9xmjNl0XPXolNHUajXS6XSbjknfg8pLsFbCUnCyMyObiAG06aFsg9Ouri7i8Th79+4lnU7z5ptvkkqliEajplxl9xXt5rw9PsJ+PV0TCjh2b7Jer5ssuNFoWf4rAF+6dKmt17K1kQPmYCXaalJfy6tykTaqspsVhrjCGXr5Nk8zzpk21+IpRviLw49yxP9jjl9/cOX7Qxy+9vin+c7jT/PNP3y2VT4b9FL6tZBhlV1rnsx6KBFi6joWMFV8RveycGJHa87Ny0Wgs3G0sbjt81zE5bcXDDVRATOXHDBlkUqlYnyV7Ia4/XuZTMZoUWz9im5MmyBgEwr0f1jbvXq9XqLRqKFEawFSL2VhYcEEQDswaOaGynF6XVtYac98KZVKZiqiLRhsNpvGesTn85FMJrl8uXPC0NaD3rsWXumAisUikUjEfNf6TG3rHNHMs9ms2c2HQiGzgVleXjb2KtKWqL9nL8j6ruy+iR0EOq1gRDBRtlEqlQz5QuU8lc5sPzwJJ227Ifu1AEM/1rA5HUuBTRmQx+Nh+/btnDvXYj/ZhIKtizfh+BiMuuB1mHli6Gql/v4yrLRbo2SIc5aDTDGCZ5WVJcwzwO/wT3npL/8m44/QQQD+2TDOmTUn5TLwOlz+3p71Z7AMwvZ977TRma+Hc6kxaq9H1//hSVr9qUAIysOwypC7GbjtweW73/0uLpeLX//1XzdZiW5MwGhB7LkoskmRH5d+xxaqnT9/nitXruD3+xkYGDCNdLsuLY8n3dQqmajcIQQCAQYGBkgkEiaA2BMlpWtQWSYcDpvSnR3clF0pyGiBsodFZTIZM0xMfSYFM/UO3G73lg0uduDV4v36668TiUQ4duyYGeqmnpRg28NokV1ZWWmb2Gg313O5HFeuXDFZ0fDwsHlN+9h2FqSNiK4hu+kv6jisiXNFzlAZU6W8rq4u+vr6zLgGZdn2BkuZisp6ym7S6bRhLMKaVZHtSwYYga8dHG8kwGzeIPQKcAYm/zN4OUT2iUGGHmoPLnuGJ3hneh/nUmOMJ1/jbfZRx8MZxikRYsKiIAPkKxF+/Lt/g1/9r/5PvuL/jzmzQdmL90s5BpjjBEfXHnyL9nU+QMuqZT+t0toN4lxqjNpXoms6HBv7V48Lrfkxx4+y5YKLdv/NZpOnnnqK3t5e08SXpYtsLmRXL2W2rWjXoit0akl0o9k2+jYLR49rAVdPRE1dPVd2+Cqh2DtMW6WvIDQ4OEgkEjHBQBmOApDNhhJDyG4MawesQWSy/pBaX9TXycnJW/F13TLYn4v+73K5+NCHPkR/f3+bzYkyGdHJ9X1WKhUKhQJLS0skEgnz3WihBozS397RazHX8VQCszUxtgDT1tHY9kAKZtr0hEIh4/St6yUajZJIJAz9WE7a6s/ZjEmV8IrFIo1Gg1gsRiAQMO9J52sbsc7PzxOJRLjnnnu4cOGCOf+tyRzzrv5/HHgStoeuuap5qNO16p5cIsRZDhJ+r2xg9Vi1DRRo1so+vs6nefHisbUH99MiJJymFVQeac2jGXLP0M8cD3CaRZKrA8OufoNSwsDq7x9Z532M1egKVGmc7m41kV7eA+UDwJsb9+Y6XvKW45577uHIkSOmzKW6tBqroubabCGxecTEEl1UZQg19HUD79+/n0QiwcDAgOnJdGoG7P6N3c+xWVw6n0wmY5rCapb29fWxa9cuQqGQyYbEOBM5wOv1mhKMejBaDGVrIoW4x+MxXmg2M07HkHjTzma2EuzFL5lMsn//fjPVU9mE7eRgZy6NRsO4LigA2J+fHodW0AqFQvT19ZnRD3rt9fo+nfoZZSm6ZoC2TFqBRQyzHTt2mGmlPT09bNu2jUQiYY4v41L5l9lBVBubVCplMjn7PYut6PF4WF5exuPxGDPN95u16Hw2DwaAp4HtLZ3LYVor2iMQu299OpSsWdaOMM84Z5ijn11M4qNqxIsRf56D/8VZ/uBH/zHf3Mhhlr8d4Pf+3efX/j0KfAa8ozlqb0UJ3Jfm07Gvc5CWPX8PGQ5wlgxxDq2OPO7EJLs4wcOMJc/BU+0/62eeo5wgRZKTHKH4VJB3Mve3Pq+Xx9hSwUXpvZrgnc7EyiBkwdF5c9s3uHoadgPW6/WSTCbp6+szOzr9zGYEdd5wuhGVKdmLEWCCkNyVNQc9FouZ341EIkb9b8+KUb8EaAsuYolpMRKRQXRrMYFyuVybqHLr7UBbUNagIKKykFynk8lkW9ahn2ljYdPBlVXK/UEEEWhpkoaGhsxGwM4CdB72oqzX02ZHmxK7NwOtEtjS0pIp02nqZCQSoVKpGJ2SNghyV242m0Sj0TZrGt0LS0tLZkKpnVHZbhUq06rnZIsw9X623jWTgO3bW4ukehUe4EgrMFTwXzX9UXBTJ0iRAeaIkGeCvYxzhgr+teBCns/ze/DLG9tvYWXV62vR2zrf/ZA4PN0abvY4q1b7Vzi0Oj45Qh4fVUKUGOLKuods2cRsI0PPVT8b4xxHOcFZDnLyqpTm5uG2bX9l3CiFsqjGov82m02TEdjNb7sMoZ2qXcawLTdEDrDr54ICht0sVU8nGAzS19dnsgjZuJTLZc6cOcPExATVatVMFtQMdfVPlpaWjFdVIpEwAUtNY/3ROW7bts0E2k6tgrzP5ufnTfai89pKsBdpfS4Kvho57PP5SCQSJgtZz1dMWYnGN/h8PnP9yK9NQcI2E7UXdP3bDjDq5aTTaaPLsr9Pld0KhQIzMzPmZ7FYzPRaXK6Wgn5ubo5MJmNm/kjHomBjl3VFTrDdw2GtHKc+kMq2Yj7an+nWRQku09r5f5xWWckD4fsWuPzTPXQNLl+VqQghijzAafqZp46bZ/gmcZZ4m32MMkmK5Pue/ih8PgH/EY9f+wkrkP4Xw63G+iDwCMTdGfPjOm5O8DCTjBInw1FOsI8JM8dlPYwwxTN8c126cmR1iNlpDlPH3QpAN2f6cxtuS3ARpVeLhl2eEm1UWYAWddEubUqmjAXtOrX0JsVikcXFRVMu0Y7WpgUDpvSwtLTE+fPnmZubMx5WqnXLNuSNN94wxoQyruzq6jJ19k4K9Pz8PMPDw4ZGa1vB68aXdsKmyNp/1KvRopHNZk2JbavB3llrYRY7LpFImJKl6Mi2U4O9Q7c3DiobSUulbEglrFwuZ7RT6sXYynwdp16vk0qluHDhApcvXzaaFm1wCoWCEe/mcjncbjfJZNL4wemYspyBVnlTvno+n49IJGLEn3ZWBhi7I5sZZ1OwFXhsynQn002PXS/obMrsZj90/dIyyYEUblbwU6Uw2Ucj0H1D7vLxVVUIQIYew+TKE+FdRuHL8Nx/C//LWy3S8/UwCiymwvz+//GftJrno7AqN2kJFydpCSlfts59+/JVGdYVhrjCkBkAliFOnMyq4v7q7MV+D+vhFA8xtzrIbGG6vxWUbzJuS3AJBoMMDg62jX6VzkOlIe3i1HuwRwsDhjWkXoUanurHFAoFpqenyWazpnQlEaZuMN305XKZmZkZ3nzzTUqlEr29vfT29pqpltPT05w7d46ZmRnTcNfrSK8i5bxKdMVi0YyeLZVKbf5RnVoKW3Nj70xVAvP5fGaBBNpIAVsR2qn39fUZU8ZgMNiWXdhlRn2e+kwqlYqZdyKRob5vWx8i1wNtSHSd2aVYWy+TyWS4ePEiqVSKcDjMPffcQzQapVgsMj8/b64l2zViPbshBQBtHFKpFMFgkOHhYVMOtYOkPWJZf7RBsRlmKvvahqjv93PfXDgAX4LA59MMxa6YBbr4HmN/9ZxXOcxBzrZRfGfYxgmOmumPf86T/NmvPMX/9iu/yZjrp+9p//IR4Ev8NnyfVlbyDCSOtMSK6e+25sG8H/fmKj5DlXZT56P8kCG+c+MHWAfbh6e4PLbn/SlDPwBu2yRK2y1WC6uam+rBwNrC27n70p9qtWpuRjV9ReF1u93Mzs5y6dIl4vE4Bw4cYMeOHaZk4Xa7DaHg0qVLZpRwb2+v2SlLCS1q6fLyMm63u83TzG4gB4NBM39ddi2aUqjFsHP3aO80tXDavRVbaKnPbqvD6/WaUQV6v51eXYKdtQDGIsUeEe33+80cFVjLBKDVJ0mlUkxPT9PX10dvb69xAdBGIZfLGV2MzC23b99ujCMVrNR4V1lP0OuqFAdrVjPaGClDt0u9nf21TkadXUbU+7cD2fspjW2+MloE7oNdscm2R93U4b4mgd6l9X+NtVHFMqqcYYh+5sgTaRvslSHO1PII/6z7H/NvVz7LJ2Zq8PfguR9dfcznDsOFVwf5auUftPpAR1olugF3S/WfPpJs+Yudfn/vsorPiCk/aKnORpDi+nqaDcZtWaW0y7LFaGJgiXarhcSufas5rrKGKJwqialEJvuUnp4eCoUC58+fZ2lpiampKe6//35GR0eNMHN+fp6zZ89y5coVotEo8Xjc0D11bslk0pRg5ubmDGHA5XIZ+qjKL4ODg/T19Rk7G9mMyDxRmY2Co8obWkhk46FShzyk9J4VbLaatYfNatL3rY2GLSwUddzegED74DAt1OqP5PN5/H7/Ve4P2lxks1lmZmaYmppi+/btjI2NsXv3bvr6+mg0GiwtLTEzM8PS0pKx4xcTUd9jMpk0hAtNOg2FQoblWKlUzGM9PT2mz6LvVWandhYitwe7l2L3VPS7YpjJgl+Ek87P90Y+/60APxX27H7tPZ+XIc4P+ajJDIaYYS9v84v8CWcYN7NQtnXPcHz5GLFvVOEk/O0X/4jvpT+F6xF47p3WsZ67D/7hq/8jX/4//xFsh64vLvPYwEs8xkucYZxJRls6m88fhK94W5YwYeAwJAdSbee1Zk0zedU572P9HtL1kCLJBPso0roWz8+NtQLcadhyOhfdOLYoTTeVVNTavatHoQXYdgpuNptmnooWHmgtMLrR4/E4o6OjZDIZfvzjH/P222+zd+9e+vv76e7uJp/Pk8vljFhTZTnbg0pBr6+vj0wmY/4Na5qJYDBIIpFg27ZtbVMMVarQjBa7OZzL5Ux2o/em50ivsbi4SDabNYugBIJb1XLfDiKdO3H9u5NBaP8MMOyxbDZrKOqaDAm09VWU/TYaDfL5PC+++CLvvPMOe/bsYefOncRiMVM+q9VqhtqcSCQIhUIUi0VzvoODgwBcuHABn8/HwMAA4XDY+I+J/jwwMHBVKU/BVFosMQSXlpYoFApmo6PNlliEInjMzc0xPz/P7OysMW+dnJy8ikq9VQLIe8HDjXGH51dHbUEr2KzgZozzbUp9D3VGuqc493E/tctR/vTpX6ZrrMmn3v59/hv+e+6ff4d/0/93+fIb/wh+ocyB4Vap7T/lX/JL2e/yj2L/nElG8VDnwM4zvPmF8VaAyQCPNBlgzmhU3NQZ5wx/hz9mlEnquM08l/WQWtW+zHU0l3xUGOO8aeSrh9Sy/Q+0ej7ld7hZNOTW53YbYDfUlZ1oh6qFw2b06AbRJEqVwNTn8Hq9RhWtklU0GiWbzVKr1YwCWzb8V65cYXFx0ZRetm3bZgZyqcRlN4p1U3d3d+P1es2Cot5LT0+PYb6p35PL5czxde7aXapGr6mHWtzU1O3u7jbNfVFRZWgpQ8StDPUSbJdgexGG9gmUnXoOW2hpEykUpLQZ0fHcbrfp7SwvLzM/P08mkzFlMhFLlFHrmMFg0AQdMQoTiQTpdNpsbKLRqJlFY48x1mTUYDBoMmW9bzmFz87OMjs7SzabbSuRiREnE0sZni4uLpLP502/zi6XvVfmcrcEnffC2+xrGxZmYyx5jjcPP9hamM/BN59+lm/2PtsqgT0B9zz0hun7rOAmT4T6OivsPTvf5sL+e+Fl2Ll7gl/lDzjOMYIUOcIpDnKWIWY4wVHOs5ttzHCEU1c17IsEeYnH+AFPGZNKwU2dUSbbynyTqV3wtUBLvf8ybElvMbupajfXxQCzhWm6mbU42P9WgIlGo8bmXAtyOBwmHA6bxm53dzf9/f2GvaPnia5qN3vVALZhU0VlDaNFKRwOt40wVpah2roWNwXBfD7fNv9Dr6tMTT0WLWLaVcsiZnr65rqZ3ilQ+QeutuNfrwcH7T5adoaswKLNjH4Oa6yynp4ems2moZaLNqzAYS/WttuDXlelWV1P3d3dhjotKyARV9LpNOl0mmg0ajZLyqhU2s1kMsaS3y4hi7Ju9+iUxajUd/78eROAN1+j/g5GGNje8dhbwCDUH1oTN1bxc5Ij7O2euC7BoEUh/gZVfPio8iTP46ZOkSBnGOcFPsxeJhhgnio+gpQMtXiGbZzl4FWBBVo9JVnuC7Vz0VY5LsNq1nLzSmJwG4OLshA71e9scq+nYZHhpJhc5XK5TTgnPYB2cMpAQqEQIyMjbcI8ZQqy04D19RYq0VQqlTZhp5hImrki7Um5XDZzQzKZjFl0JJKTsjsWi5lFQ6VAwKirpfYW1DDeqrAXQtni2GOf4er5LfYfPSbYGY2ObVN17Z6ez+cz/RS751etVk0J1O7ZNBoN4wMnNwmJIW13B8AEIhE7tOFR6VaWPirL2q/V+fnofWlTYlPbFWxUuv0ggWVzBaI0HIc3949zz863rymY3EgknpgmvX1o7YFAhUC4iD9QxWe9fogio7zLSzzGWQ7Szzz7mGCGISbY23bMPe9c5p/M/0/MPh7jBEdXRZNrx7rCEN/haXxU2ccEBznLDEPMMEQdNz6q17TjXxcvw02ninGbgsvMzAw/+MEPuP/++9m+fftVu07VnG0HYf3RQqxAIq1CJy1VjXBRgv1+f1uJQ0FBFFPNhbHPQQuTFhN7YdHuVnNGstksgUDAjJ8F2ixffD4fvb29xONx09i16ai2I7NKZeoVKOioRLbV0Ww2WVxc5Ic//CEPP/ww+/fvNwLazoxFj0kTci1dhzJT/c56WhBlF9JeKVuuVCrk8/k2koU2RzqOSAYSw1arVZOZut1uUqkUxWLRBBB5x9m2Pj6fzzDkdH139pc6dSy2VYwyoCtXrtxwOWxz4xX4F0E4+RCp7yavdkG+CRhwzzGwe45tq9Mdk6QYYI5XOcx5xkzvpIKfF/g5MsRJkeRX+QN+5/X/mf9w39/iv+R/MsdLkaTWD96/hJnHh/gDfpXdnGcX7+KjYrIUsdomGeVVDvMApxlfVfDPMXBD1vzA6sCys9zsWS5wm4LL4uIii4uLZvywnbkooOimVqnJLpHoBlaQKJVKpkygEa+2YE3BRQFmYGDAqP8XFxdNLwMwu0474CkbsnUUOq7KEeoPJRIJYrEY4XDYiCv1HFsYWiqVjB28ApAWP5XI7Pfc1dXFwsLCLfyWbj3sPohsVEZHR01wUVO+M6jo2llPtW+Xrjof68x6YE2DJeGtBLZywpaTA9BmM2M7GwPm2lOzv1qtMj8/TzabNeLhcDhsJpTa2bxEt3YQtD8f++96TW2q3n333Z/pO9hcvZc08B148SEqZR+rE4tvOnxUOcpPeIwf4aeKjypu6kwxQmm1BFbF11aWGmIGvg377mtne03M7eP/Gfh7/OLn/4R/yT/kLAeZZJQkKcY5wwhTJrBAi3SQJ8JRfsIQM7zEY++PnnwS4Pmf5e3fMG6rYEI3lf5vN89VkhDTxr6Z7MFhKlvZVF67oWl7hKlkEQqF6O7uNiy19corwFU3to4HtM2V0d+1Q5ZpZTgcNllHsVg0C5TmkmgwmM7dfj29L/t8JMrc6rADu2jYChqdGYcdaLQgd5aT1iuV2WU0HVOvIaKGAoY2Bgr2+h1lFhLGqtSlYCdqsG3bUiqVzHygeDxuBt7JG00sRZXLtKmx3x+0l8j0XjweD9lsdsvR1O9ExFlqU8pHyL83Q+1vwvM82fr7fcBb0Hi5m29/8mkWSa6OAGgRAVZw8xh5DqyWwOy+Sh336mTJVgB7XyWxArSC8s3HbQ0u9oCuarV61VAtWXToZlXpo6urywQRW/OhWrSsUVRmCAQCJoNQGcIOSPZAJrsUZ++IpaWJx+PE43GzcCgDUsmk2WySSCRIJBL09/ebTEils/n5efx+P/l83iw0yrRsxlPnZ3M3wF5E9R3Ifsf257KDSOdiaz/WeexOVplgN+pVSpUQVteiYJfmFCS0gVEPUBR0qe+1AVGQUb9EGxA17KGVlafTrZtfc4U6S1udBpa69vSZ2BndXYHya5S/dojKb165JX2XOm7eZt8qq2t9I0lhlEk+zdf5tfl/z8WjffwBv4qHOjsfeouL5f1wGn6QfYrJ2K6rgkSEPEc5S4kQL/Bh8kQ4lxoDwJ2sc5oH1mz270Dc1uDy/PPP09fXRyKRMEIymxWm8hNgbNdtqmk+nzc9EQUioG2OhqjByhrkNyZaqN1XUZ9F2UQikTA6CWjd1NFolKGhIRYWFtqyKnvOh13e0c+gVY6Zm5szC5bGBWhhUzNXAVUZnRaqzYLOvseNopNM0dXVxU9+8hNGR0fp7e01QRhoCzD269lZjI5lBxQ7QOlaEtR0n5+fp1KpGIqwyrIiXajvZp9HLpczfTiv19umj7E3D7DWF7StWvT6dvZdLpcNFb+TsGAz4URdVmb7QT//zYs/gi8fovibwVsWXE5yhAp+HuBVDl9Dcp8nwhz9HOEkTQ98k2cMcyxEkcQj06QXh6mW/VRj62cf62lc6ituk+FcnB4lMZgyLgDXwkxlCH4fbjb92MZt9xGxbU6UmQCGVVUsFtsWXlv7ovKBlPmatyI2WWdpStRlMbnULLUHj9mZi2rpupEV/NRP0YJj90fs2rvtcaXdbalUMjtXsYjkZ6VFy9bb6OdvvPHGFm/OXg1tNOxZOnYwWK8HYQcZwWb82b0awFi8qGdXq9VIpVIm0922bZvZBIjmq+tGmartrKygZRNLuru72/ondmnPtvrRz5SFaK6RzV4TFAjt3uKZM2fMcbd+M78DBShVQvT4Mxt+aC3wdmZRxccpHiJDnG3MrBsEivUQr0w+zrd3f4K/SizxbT5x9cE90Fhxs4J73bJahjgT7DV9lbHkGn24SAhOBkgfSTIwvH5wqax2hbKvD8IfAqzjW3OTcNuDy8LCgtmp6Wby+XxmPoVq7mLX6HnVatUs4JqHIjpoMBgkHA4bm3Yt1MoGdFOKGSSnXXuB0qwWBRTRTQHTa1Hgs3e0WnjK5TKZTMYMA5MNiBaocrkMrJU17MxEKnzV8NPp9Lqlnq0Me4c+PT1tHKaVSdjUdVvBbzP+7O/T/vy0EQgEAmbU8MLCQtuALdnra4hdPB43Ykb13aSR0ogGOT6oNKtrWBsiZbq6nvQ8bSL0fpVR2form8EooaUII+VymVKpdPcFFBuzL5L90hP0/+O5qxbpCn7yRPCvsq+uBTurENzU2ccEYfKc5oGrSlfz9HOGQzzAqxzlhGmwJ0mRd0co9i4RosguJvk0f8gZDnGGcR2c9NgwnAsw3ztA3J+hSIgQRYIUqeOmSIjqNZgKblYgDt7A+mXzPBEu/+Welg5nklWb/Vs3quO2B5fjx49z6NAhIyaTd5Qowtls1tyA0WjUWHvISFLBQmpoNdODwaCxQxfVV8FFdFLATAtUlqGsQrRhu/wgjczS0pKpp2v+RrVaNc69tlW/TTCQglvWJNrhut3uNnqrjBLV7J2bm2ur+9/p2MiSTFdXF2fOnOGee+4xwV6+b7A2816fjxrs+l27b2bv6H0+n3HKbjabpFKpNsaerqtMJkMwGCQSibBt2zZjp6/z6O7uNtdaIBDA7/eTy+XM9TQ/P2/MRmUfo6Fn6inZLtd2cLDdjW2moliKS0tLZDIZY/eiz/7uDDDPw+8+weQXdrXt7gFSlSTZFwchDoGxNPFYhp517OlnUkPUyj4ODJ81j/UzxzGOG1EjHcGlRRM+wDiv8RQ/wEeVCfbyDN9sBZpYhH1MrJrMzLOLSR7gVeYY4Icc403PA3DcRfbyINnBQTPm2P2RN5hhiHOMXZNmHKJE7JFZIv72gLlEnEw2TjkTaclZjrPKEvtT4NaRgm57cAH40Y9+xCc/+Umzq3e73UZrIMrvpUuXjOOwygm2GjsQCBAOh+nu7jYWKiqXScSoRV4LUTqdNnM5IpEIHo+HSqVCPB4nmUyaWrvKMWq2zs7OkkqlyGQypukuGrQyHr2Gz+cjnU6Tz+dJJBJEo1Gi0Sher5dyuWzo1KrbK6vRbnRubo6ZmZm7LnMRlI28/vrrxONxRkZG2lwctCFRP61arRqLFfXc7LKSgk8kEiEajRrvL81WUaYMrQxncXHRWLnE43ETuLxerwkmKoFp8yLa8czMjNkYiPkXiUTM/Bidt4JZZ/nOLuGpHyMhbaFQMEw0GW/aAfSuxOK3qT37CSa+tq9tSFjEn6d4OETtcpTyHyaY3Z5g9r4a3nCJgeScyWaSyUUzn741DXKGg5xljHPMMcAA80wyetXLTjHCC/wcRzjJOGc4ygmeqvyAcf9rXGGIfubNc/uZZwU3rzHOqcoR+K6rpZo/R2v+y2zr7xcG7+XEvhmq+ExJbIk41brf9Ff8VNbV9sxOD8G3Aq2ZLfpTeBHec2DAxuKOCC6nTp2iUqnw2c9+FmiVhdRwD4fDFAoFstkss7OzZqxrT08PkUjEzCsXHdTv9xOLxYjFYnR3d1MqlQiHw8YgUjexzeZxuVxmYJPf7zevK42LLPfT6TSXL19mZmaGQqFAo9EwlGL1fpLJJP39/ab0UavVTN9FO1QNCNOiIzt4UZN1PDkNrKfVuBtg78AvXLhAtVrl6aefNtoS9bbU66hWqywsLLC4uGjmyquEpSAlrdG2bdsIh8NmQmgsFjOfu4JLvV43rL5SqcTw8DCJRMJcFypxqTQqAezi4iLT09MsLCyYa84mIMgCSBse9Q9FY4erbWr0+9oALS0tmfOUh55dKrw78Qp8v0bjK5+Cf7L2aIQ8kWSefDLC5dN7Wr2HuJfaqJe5z0Ek2QoudjYTosiHeYGjnCBCnjB5DnOaKUauYmiVCHGCh5lgL0/y5zzFD5jxD+Gn2hZYhNM8wJ/zJNlvDcKLQHn1jzDb+pPa156xzL5xD2Qg+fjidWnPg8MzzHruaQUtWKUfT3MrS2JwhwQXgLfeeqvNUFB9Foklo9Go6WHYjrKqY6uRrhtei7MYXmLuaCHoFC3aokw539qMIxlG2l5Pau43Gg1T3igUCobqrKAi9pear6qnyyFA56meDdBWj7/boQVzZmaG2dlZU+7UhkKLr0pOsrzXwm4fQ6MR9B0r2IuxqKChIKPNCLTKbMpW9Jq22FH9MV0r2vioVyjKsGzxg8GguUYymYwZySAtl/3d67Vst2j93dG12HgLfhfe/MyDHNjXvlOPkIdHaJWezgEeqJWvZmm5qbOb8xzkLEladks+4CBnyRPmbfYZO36hRIheUsRpOWhcS9g4yShnOdj6+SLtQUVYAV6HmUeGiPjzXP7RnlaAGAUGm++pp4mQZza+euzTwOIct0rbYuOOCS4rKyt89atf5Td+4zeMLqS7u9sstj09PVQqFTKZjAk62i1qUp8asTIb7O7uNmpolT1U+lAJodlsEgqFiMfjbUHF3jWr/i6qp0oa0FqspF/JZrPGekMLkKZUBgIBc/7FYtFMV8xkMm27UBECFhcXmZqacoLLKsQc+4u/+AvjBReLxQgGg0b0qH6Wvl+xsLQY6//lcpmFhQWTCahpPzo6Si6XM+UmmygQDAbp7+8nFAq12czYmyH1AV0uF8lk0lwnos3LLVnZsiaoqhSXSCTMtFJpbHSN2uaUKh1rwFmnc7Rwd2YxNcj8K/j4b/Dm9x/gwO5X2356z743uPC5e1sTId8DZxg36vgRptjHBGOc4wzjTKzjnLybczzwHpPAznKQM4zjowpPAL3WD9+iFQxWgBchyyDZ3kH4XVp+YE8CX3Cxsnt9Zplwfm5szaBy8TXgO9zqrAXA1bzB7t+tulB37NjB3//7f98wtjRUSTtDNS6VZWjHGo1G2zQyHo+HcDhMf38//f39pqeiXaZddlCZw6axqsatbGR+fp50Om1KJLZ32fz8PPPz8+bGt5X6p06d4vLlyxw9epSRkRF6enpMdhQIBMjlcszMzJDL5QzLbGlpyditbzRuZrPX1uxsNLR4ahH+W3/rb9HX12eGu2kTIqv6arVKf38/sVgMwDThRVVXrywQCDAyMsKOHTuIRCJtg7ns68POim3NjAJZqVRiaWmJubk5SqUSCwsLLC8vGwfumZkZpqenqdVqhMNhM4+lXq/zyiuvMD8/z7Fjx9i/f7/ZVCk4qmSazWYpFAosLCywsrJCJpNhZmZmw/sssre5GXC5nrtpx27HMGz/T+DLMPjJC20lrwp+LkzcC4uQeGT6PTUiAB/mBf4+/zehn7EhPsFeznKQKn5Oc5h3rR7OOz+6vxVIysARWtnKW7QCy+Lv00q3fgO+NcCBT17dP3k3O0r5xcSapf73oSVu2Xj342bzufd8zh2TuQiXLl3iW9/6Fh/72McolUpmUVDqr1KGbnYt0uqhVKtVU3bqVFjbdGJYE9zZlFbtFvV7zWbT1ORV79Z0Q1GltQtVn0i9E1ijlr788sumHNPZyFUzWs9XcLmb0blg2uLIpaUlfvSjH/Hoo4+acqY2B4FAgGQyaSaAdupfqtWqyUDta0GvqSClawfWskltXuzn2/8PBoP09vYaQbC0UKVSybDK5IYtxpf8yrq6uvirv/or43tnT52sVqsUCgWuXLliFPvVapWpqamrRoBvxOe+NTANl38ffvdZZo8MERles2fxU2mVzNYf29IG6Vd8GyTO3Lc6MaZFNg6ySJI6nhbF2UPL0j9Aq3x3mVZwWUH/Af4VfPk5ip8MtVGmAcpvJVoZWWb1D69xs231r4c7LrhAa+c0PT3N4OCgYQbZfH/VuzWASTejtCIej4dEIkFvb6+xf4Gr7drXg62PgDVRm7IVzf6IRCKmHKEGvSivtoDO1q9cuXLF/G4wGDSNfDHDtBCJJn03o3PBVLagzEEMQsBoSLSh0PWgPoVKTSpvqp+na6SnpwdYC2A2G02wrz1dH3Z2q2Bhj1NQT2VpaYnu7m6GhoZMj0cuywpAeo0LFy4YwoLNbrSJC9rUaMN199KP3wvzcPwsfPEg7zx3P12DyyQHUvSyyApuqvhxU8dPBR9VIuQpEjTmk27qjDDFUU6wlwn8/Gw2TDbzq46bBzjNLiaZYYiXeIzY4VmyX2xNMw2MpSnPJloek5l3aeuZPP8OF//n/Xg/lyMULuLzr57XKhGAF6EVWG4tO6wTd2RwmZycZHJykoceeojt27fjcrm4//7729T7XV1dRCIRY6MvbYgWk/7+fqNhEANLNGV74bBvSptWLFQqFUMHVpkjHA4TjUbp7u42NjOxWIxGo9FWE79w4UKbk/HZs2cpFAqmXNfd3U29XieXy7G4uEitVjO+Ug6uhh1wMpkMP/nJT5iZmTE0dY2vFuNKJIlIJEI8HqdUKlEulw2rb8eOHcRiMbNgl8tlgsFgW3nPJnWoRGVnL7VazUyClK5JjXll2ZrlowCnYNTV1cX09DSZTMa83qlTpyiXy6ZfaLPJMpkM1WqVCxcutJVxncByLeSAfw/fGodv/TINuln4QjelLwWJd2e4/NM9hMcWGOmeYoxzHOM4pznMSzxmAstT/ICHWiIRZmjNcYmTua4Ycz0UCXKKI7zKYep48FNhnDOGNDDHAPgh81CLWryCm/NlP43FbuAnq+9F+Lfw279M7blDZB+Jwtjqw88D517jdmcswh0ZXIRTp05x6tQpoKVJ+Rt/42+YDEYCSsAweGS/L9ZVJpMhl8sZodnAwAA7d+40Whnb9FBltVwu16bCzufzzMzMMDMzYxYWlV4ikQg9PT3m5s/n82SzWVPWUqlLaDabXLx4Ea/XSzqdNkadotA6zfsbgxbTrq4uLl++zMWLF+nq6mJ2dpZHH32UnTt3tk11VDYp4obH42FgYIBYLGaYWtI89ff309fXZxiIej07uEipr97N0tISMzMzpFIparWaYQKK3q5sRX1DXZMzMzNks9k248xGo8Hrr7+O1+ult7fV7dX1qf6KSmFOULlRnFn9A3zlcQqZn6fwL+KwAisrrY2mjyojTFHHTYb4qq3+CQ5ylnkGTCO+jptjHOcxXrruK86wjRIh+pknQp7zjPEDnjI6GTd13mWUXYwzzhkeW7VlOc1h6ri5sjxE42vd8HyOlry+E38Ehe/A8zvheVGW567x3NuDOzq42HjhhRcoFot87GMfM03SQqFAPp836vxgMGj0JNKlaPa8KKiiIcPVWUuxWGRhYYFarWYGNsmaRcfVzHI7sDWbTQqFArlczugsZmdnyWQy676XWq3GlSvXd1N1cG3YGYz6aI1Gg7Nnz1Kr1fjEJz7BwMCA0b4sLy9Tr9eJx+Nmrk84HKZSqTA7O8v8/Dy5XM6MYojFYkajpCzZzjhmZ2fNNeLxeIzNizRJpVLJNORVkrVJJOl0msXFRRYWFky23fneqtWqCSZ2MLUzKQcfBD+CP/TCI8cY/M0LpkE/wV5Oc5gP8wKjTOJmhTgZ5hng2zzNecbIEKeOm3EFqmugjptTHGGCfTzNt9m3OvDLVtrXcXOFIVL0rlKfzzFPP3VaPmOF432rDfnXuLaqvkYrQ7n9Wcp62DTBpdls8tZbb/HUU0+Zx2xbDD3H9oXKZDKGHqpmrD2L3G4S2xMHNY5WfRRpFRRQ5CmmYKZhY7LzLxQKxizTwcZjvd6ZdvNSxUciEUOeUC/G7XYbcax6IQsLCywtLZmejUqjnTOERL6Q/cry8jIej8ewGW36sDJrex6PrhF78ql6SPb7sN+f/R7vauX9huMV+MoxZp8ZMlYvcTIkSREnQ5wMVXycY4wzjHP+OhYs66GOm0WSzDBk+jcDzDHKJGc5SB03FfzMZLcRiRU4x27yRFhcfY3J1K4W2+tluBUTI28WNk1wgdYN+vWvf51PfepTBAIBs9OE1nRL3by5XI58Pm/YXjIJ1O6y0WgYkaKsZmTbr+mQts1+JBJp+z0xjsROkoFgKpUyu1InM7m5uNYCXKlUeOGFFxgYGKC7u9tMi2w0GiwsLJhykoSMdnNczD2xyUSuUNYrcaVsWOyRD9FolHw+b7IXUYcjkVYDVz1BlcZUSrPfR2c2Yv/bCSwbiRy89f/Bd38e/kHrkV1MEiHPD3hqdfH3cZoHmGLkKrPKc4wxxQgjTJEhzlkOEiHPPiZa+pVVlAhyjjFGmWSUScY5w8TqQLAqPsrPJyh7Erz9yQrzDDC5PErhZB98BfjDGq0mypu37FPZaGyq4KLyk2rY6ossLi6aGeXKQLq6uoyITYtEOp1menoaj8djdp9ut5uRkRH6+/vNzrRQKBh2TjgcNlmMfexsNmvKHplMhlQqxdLSEq+88opTsrhF6KQZKwMtFArMzc0RCoXo6+tjZWXF+LvJa07ftRhYeiydTpu+moSPPp+P7du3k0gkDENQPnPS3UQiERKJhKEW12o1FhYWWFhYaKOwl8tlfvKTn5jzX09dbweSWyWMvPuu2XPw5Z/nzY8f5MBwa9rjd3i6TRx5rUFc6ovs5hwpejnDOBHy/B3+uG22S54IL/BhMsR5gFcZZZJ9TKyJKLcD34fLi3u43At8C/hak1ZQuXXW+DcLmyq4AMzOzvK9732PZ5991rgPKytRjdw2hFRGolLF0tKSacCr/GWzvZSdACaAyGxQpQ8NEBPzKJVKcfz48U3lXLyVoN2/ypxLS0v8+Mc/Zvv27UYEK22IdCKdxpcKTNls1rACdV0pe9XUUR1LM198Pp9x7JYdjViKS0tLxtzyRz/6kbH6WQ/rBQ47M3Oyl43EHLx+Ck4+BMOsa0gpaE6Lgk0dN6c5zGkOm+ekSHKWg1cNDkuR5DjHKBLkM3ydvavBxU+FxJFp0seH4Ru0hJPHm8A/53ao6W8GNl1wAUwAKZVKxvnYtuOwa+VyNFZwkRJeWYiyGOlRtEip7GWPYFYJRErtTCZjGvd3387vzoOt+xAtPBaLtV0b9ohgZSxickmwKAsX9eeUqdjW+NqESDFviyGlxdG5iFCgYXidWqobwc0OLHcnrbkEsy3F/vUmWA4xQ5LUqrL+fcyrtzDJLr7BMy3KsY1VHzEup2hlK1sjsMAmDS7pdJrXXnuNYrFIf3+/KY9pt7iyskIwGDRWH/aQMe1uAVNrl9jR7XYbl1y5KEskqcFQ2vU2m03m5uY4f/68qdE7uH2wA4jL5SKXyzE5OWm+O/XmbEt7+cppWJwdTEQ9hjUrfTkPKyBpgqUs8OXSbFOLy+Uy77zzjhkaZ2+AnEzkduMM/M4TXOi9F8YgMJpmV2zyqmf1M89BzjJHP1dWtS7Xg5s6cTIEKZqG/vzqRBcb9RX3amA5RasUtrXWkU0ZXObn5/nhD3/Im2++SSwW40Mf+pDRm8glWcPHfD4f3d3dhnoq2PYuUlZrEZIoU862LpfL2HeIabSwsMDFixedwHIHwbZjyWQyvPzyy1y6dAmPx8PDDz9sBJbKYNTsD4fDNJtN07MD2sgCEixqto/IJJqYKnGmAg6s2fXbgcU+xzstsNydwW4OFv81PPMkMED5iwlW/vepdU0hx1apwvMMXLMXI7ipc4gzvMlBY3y5HvKZyCrdeOsFFtikwQVaCm3pSOLxONu2bTMZjOw87PHDsVjM6FVslbVtiKlgpIUDMDoX2+hSinqZaDpox+1cqOzylxynm80mQ0ND+Hw+isVim+jWLnvKF84edSCHbPX3QqFQ2ywXWJsO6Xa7DTV5eXmZVCpllPj2Z6PzdHAnYBr4N62/fvk53hm7v+Xv9QtlQ1POEGeKEeJkzEyXziwEYI4BTvIQI0zRzzxxyyxzkV4Wzo8QHlxkpHuKIiEa3++GzDtsxcACmzi42Pjxj39sVNEHDx5kdHS0bZKlFpJQKGR0KZr2qCa/zCTlKyWVv8Ya6zi1Wo25uTkuXLhwu9/2HYvbuXDaPQM7i3jppZc4deoUoVCIRx991LC7RF8PBoNXqd+lhdL0x3K5TCwWw+v1mv6KejuLi4s0m01jOXTp0iWmpqauCrR3qrLeCXYA/wp+axiIwv5jvPnFBwk8m8YXq/INnmGEKXZznjzhdYPLWQ4yxQjjnGGEqbb+ysLEDvgKFMb6eDPc13Iu/jK07PC3Ju44y/2fFX6/n8HBQR555BH6+/sJh8NEIhEzXdLerebzeTPGVmNvfT4f1WqVVCrF7OysoZNqoTl9+rShmm5G3MyF7WZa7n8QdGpglIXI5uXRRx8lHo+bUihAKBRqK5kquFSrVfx+v3FuyGazLCwskM1myeVyZiZPo9HgjTfeMFnzraISbxRUHrxZuHWW+z8rosCDcOwYfBE4UuPAzjMEKVLFf93SmI8qblao4meRJLM/vadlJvl7tOa18Bqt5n2OzZq1bErL/Z8VlUqFixcvUiwW2bFjB/F4nGQySU9PD/F4nHA4jN/vN6K5RqNBJpMxyvquri5jgT8/P0+xWKTZbPLXf/3XbWwhB5sHnSzCarXK5OQkzWaT/fv34/P5SCaTNJtN+vr6jK2LVPnabMjtWsJZbUA0ifTMmTNtzMXOjOVOxt3Zc7kecsBxOD4Jx5+E+Hbe/PyD8AR0PbLMvoGJtmdPLY9QeLkP9quc5mOuPkD6vx6GLwEUabkU/yVbiRF2PWy54CIo4wB48MEHGRgYoFwum4mTWijK5bKxc1GdfXl5mdOnT/P6669f8/gOro07ZaFaT+EutqDX62V6epqZmRkajQYf+tCHSCQS5ufhcNgQRGRGqvJqLBZjeXmZ119/ndOnT7fR3TdbUHHwXpgEfq81H+VLvwYnd9H4YjdLn4q3Pavwcl+rzPVLAZZ+rfWz9Olh+FIN+Ge38oTvGGzZ4GJjfn7eaFwkiFQ93p5uKRdcqbwdbD3Y+hO7bCZrlnw+TyqVMrRzZSUSVqZSKfx+v3F80Cal89ibLcN1guCN4EdwfAWO72F27J72H00CK5fhW9uZ/aerP5sF+NNbe4p3ELZcz8XB9XE39Vyuh/VYWwomsoTRY/bf9TMZnna+V1tHtRnh9Fwc3Ajuyp6Lg9uPO6Usdj2sl11cK2AI+llnD8eBAwdXwwkuDjYcd3pgEdYziOx0KO7sn7xX6WuzvHcHDm42nODiwAFXB4XOf69n2eIEEgcOrg0nuDjYMGzlxXYrvzcHDm4GnODiwEEH3kv4uBl6Sg4c3G44wcXBhmOzL77vde6b+b05cHCrsP7UIgcOfgY4i68DBw6c4OJgw3E3U3Q3+3t3NgYONgpOcHFwU7DZF9kPis26ON+t35eDmwcnuDjYMNhzSzbrInu3wwkyDjYKTnBxsGHoVLc7C9XmghwKHDjYCDhXkoMNQzAYxO1em3PhZC+bA/Z4aOc7c7BRcIKLgw2Dz+dzFqdNCrfbjcfjIR6P3+5TcbBFcMOuyA4cOHDgwMGNwslcHDhw4MDBhsMJLg4cOHDgYMPhBBcHDhw4cLDhcIKLAwcOHDjYcDjBxYEDBw4cbDic4OLAgQMHDjYcTnBx4MCBAwcbDie4OHDgwIGDDYcTXBw4cODAwYbj/we0tR4LY5n2WwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 40: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.27it/s, loss=0.686]\n", + "Epoch 41: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.42it/s, loss=0.694]\n", + "Epoch 42: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.668]\n", + "Epoch 43: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.35it/s, loss=0.67]\n", + "Epoch 44: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.35it/s, loss=0.732]\n", + "Epoch 45: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.47it/s, loss=0.659]\n", + "Epoch 46: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.39it/s, loss=0.664]\n", + "Epoch 47: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.42it/s, loss=0.68]\n", + "Epoch 48: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.39it/s, loss=0.652]\n", + "Epoch 49: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.16it/s, loss=0.658]\n", + "Epoch 50: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.53it/s, loss=0.638]\n", + "Epoch 51: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.43it/s, loss=0.621]\n", + "Epoch 52: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.55it/s, loss=0.62]\n", + "Epoch 53: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.52it/s, loss=0.64]\n", + "Epoch 54: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.50it/s, loss=0.633]\n", + "Epoch 55: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.52it/s, loss=0.619]\n", + "Epoch 56: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.51it/s, loss=0.624]\n", + "Epoch 57: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.40it/s, loss=0.613]\n", + "Epoch 58: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.44it/s, loss=0.588]\n", + "Epoch 59: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.589]\n", + "Epoch 60: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.59it/s, loss=0.625]\n", + "Epoch 61: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.54it/s, loss=0.629]\n", + "Epoch 62: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.13it/s, loss=0.562]\n", + "Epoch 63: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.37it/s, loss=0.614]\n", + "Epoch 64: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.38it/s, loss=0.578]\n", + "Epoch 65: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.43it/s, loss=0.545]\n", + "Epoch 66: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.551]\n", + "Epoch 67: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.534]\n", + "Epoch 68: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.42it/s, loss=0.586]\n", + "Epoch 69: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.47it/s, loss=0.523]\n", + "Epoch 70: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.40it/s, loss=0.529]\n", + "Epoch 71: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.58it/s, loss=0.572]\n", + "Epoch 72: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.49it/s, loss=0.568]\n", + "Epoch 73: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.57it/s, loss=0.553]\n", + "Epoch 74: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:02<00:00, 3.94it/s, loss=0.541]\n", + "Epoch 75: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.519]\n", + "Epoch 76: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.47it/s, loss=0.54]\n", + "Epoch 77: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.57it/s, loss=0.547]\n", + "Epoch 78: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.44it/s, loss=0.488]\n", + "Epoch 79: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.39it/s, loss=0.515]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 79 val loss: 0.5191\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1000/1000 [00:26<00:00, 38.16it/s]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 80: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.43it/s, loss=0.545]\n", + "Epoch 81: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.48it/s, loss=0.485]\n", + "Epoch 82: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.34it/s, loss=0.484]\n", + "Epoch 83: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.35it/s, loss=0.492]\n", + "Epoch 84: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.47it/s, loss=0.496]\n", + "Epoch 85: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.27it/s, loss=0.519]\n", + "Epoch 86: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.38it/s, loss=0.503]\n", + "Epoch 87: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.29it/s, loss=0.51]\n", + "Epoch 88: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.34it/s, loss=0.444]\n", + "Epoch 89: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.42it/s, loss=0.461]\n", + "Epoch 90: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.39it/s, loss=0.436]\n", + "Epoch 91: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.20it/s, loss=0.463]\n", + "Epoch 92: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.40it/s, loss=0.482]\n", + "Epoch 93: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.29it/s, loss=0.45]\n", + "Epoch 94: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.25it/s, loss=0.514]\n", + "Epoch 95: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.31it/s, loss=0.444]\n", + "Epoch 96: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.34it/s, loss=0.428]\n", + "Epoch 97: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.19it/s, loss=0.487]\n", + "Epoch 98: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.50it/s, loss=0.445]\n", + "Epoch 99: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.52it/s, loss=0.436]\n", + "Epoch 100: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.56it/s, loss=0.465]\n", + "Epoch 101: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.489]\n", + "Epoch 102: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.56it/s, loss=0.427]\n", + "Epoch 103: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.40it/s, loss=0.427]\n", + "Epoch 104: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.47it/s, loss=0.45]\n", + "Epoch 105: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.422]\n", + "Epoch 106: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.52it/s, loss=0.394]\n", + "Epoch 107: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.40it/s, loss=0.421]\n", + "Epoch 108: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.34it/s, loss=0.386]\n", + "Epoch 109: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.18it/s, loss=0.4]\n", + "Epoch 110: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.48it/s, loss=0.49]\n", + "Epoch 111: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.463]\n", + "Epoch 112: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.51it/s, loss=0.468]\n", + "Epoch 113: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.43]\n", + "Epoch 114: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.415]\n", + "Epoch 115: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.42it/s, loss=0.426]\n", + "Epoch 116: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.51]\n", + "Epoch 117: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.51it/s, loss=0.435]\n", + "Epoch 118: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.41it/s, loss=0.428]\n", + "Epoch 119: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.49it/s, loss=0.412]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 119 val loss: 0.3816\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1000/1000 [00:26<00:00, 37.91it/s]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 120: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.25it/s, loss=0.39]\n", + "Epoch 121: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.53it/s, loss=0.396]\n", + "Epoch 122: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.43]\n", + "Epoch 123: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.374]\n", + "Epoch 124: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.43it/s, loss=0.408]\n", + "Epoch 125: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.51it/s, loss=0.507]\n", + "Epoch 126: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.28it/s, loss=0.367]\n", + "Epoch 127: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.50it/s, loss=0.45]\n", + "Epoch 128: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.358]\n", + "Epoch 129: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.47it/s, loss=0.429]\n", + "Epoch 130: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.47it/s, loss=0.481]\n", + "Epoch 131: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.38it/s, loss=0.377]\n", + "Epoch 132: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.35it/s, loss=0.402]\n", + "Epoch 133: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.35it/s, loss=0.374]\n", + "Epoch 134: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.349]\n", + "Epoch 135: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.38it/s, loss=0.338]\n", + "Epoch 136: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.49it/s, loss=0.4]\n", + "Epoch 137: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.368]\n", + "Epoch 138: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.44it/s, loss=0.413]\n", + "Epoch 139: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.48it/s, loss=0.406]\n", + "Epoch 140: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.48it/s, loss=0.363]\n", + "Epoch 141: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.41it/s, loss=0.384]\n", + "Epoch 142: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.50it/s, loss=0.352]\n", + "Epoch 143: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.48it/s, loss=0.345]\n", + "Epoch 144: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.26it/s, loss=0.395]\n", + "Epoch 145: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.43it/s, loss=0.387]\n", + "Epoch 146: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.52it/s, loss=0.369]\n", + "Epoch 147: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.55it/s, loss=0.31]\n", + "Epoch 148: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.54it/s, loss=0.398]\n", + "Epoch 149: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.38it/s, loss=0.404]\n", + "Epoch 150: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.47it/s, loss=0.453]\n", + "Epoch 151: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.54it/s, loss=0.323]\n", + "Epoch 152: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.42it/s, loss=0.432]\n", + "Epoch 153: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.31it/s, loss=0.402]\n", + "Epoch 154: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.52it/s, loss=0.354]\n", + "Epoch 155: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.55it/s, loss=0.33]\n", + "Epoch 156: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.52it/s, loss=0.353]\n", + "Epoch 157: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:02<00:00, 3.90it/s, loss=0.457]\n", + "Epoch 158: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.32it/s, loss=0.42]\n", + "Epoch 159: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.53it/s, loss=0.332]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 159 val loss: 0.3115\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1000/1000 [00:25<00:00, 39.04it/s]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Epoch 160: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.51it/s, loss=0.287]\n", + "Epoch 161: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.363]\n", + "Epoch 162: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.40it/s, loss=0.359]\n", + "Epoch 163: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.51it/s, loss=0.41]\n", + "Epoch 164: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.345]\n", + "Epoch 165: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.50it/s, loss=0.343]\n", + "Epoch 166: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.43it/s, loss=0.35]\n", + "Epoch 167: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.426]\n", + "Epoch 168: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.48it/s, loss=0.345]\n", + "Epoch 169: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:02<00:00, 3.94it/s, loss=0.289]\n", + "Epoch 170: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.34it/s, loss=0.328]\n", + "Epoch 171: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.39it/s, loss=0.383]\n", + "Epoch 172: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.44it/s, loss=0.387]\n", + "Epoch 173: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.293]\n", + "Epoch 174: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.47it/s, loss=0.335]\n", + "Epoch 175: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.49it/s, loss=0.37]\n", + "Epoch 176: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.46it/s, loss=0.352]\n", + "Epoch 177: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.56it/s, loss=0.313]\n", + "Epoch 178: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.48it/s, loss=0.342]\n", + "Epoch 179: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.355]\n", + "Epoch 180: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.35it/s, loss=0.404]\n", + "Epoch 181: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.16it/s, loss=0.398]\n", + "Epoch 182: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.48it/s, loss=0.361]\n", + "Epoch 183: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.43it/s, loss=0.432]\n", + "Epoch 184: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.58it/s, loss=0.304]\n", + "Epoch 185: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.379]\n", + "Epoch 186: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.42it/s, loss=0.297]\n", + "Epoch 187: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.52it/s, loss=0.327]\n", + "Epoch 188: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.47it/s, loss=0.374]\n", + "Epoch 189: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.51it/s, loss=0.35]\n", + "Epoch 190: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.301]\n", + "Epoch 191: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.30it/s, loss=0.295]\n", + "Epoch 192: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.56it/s, loss=0.362]\n", + "Epoch 193: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.18it/s, loss=0.335]\n", + "Epoch 194: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.55it/s, loss=0.336]\n", + "Epoch 195: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.56it/s, loss=0.323]\n", + "Epoch 196: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.45it/s, loss=0.353]\n", + "Epoch 197: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.48it/s, loss=0.342]\n", + "Epoch 198: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.53it/s, loss=0.376]\n", + "Epoch 199: 100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 8/8 [00:01<00:00, 4.54it/s, loss=0.317]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 199 val loss: 0.3223\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 1000/1000 [00:25<00:00, 38.84it/s]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZcAAACFCAYAAACXD7UpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB1uElEQVR4nO39eXSc933miX4KVagq1A4UgMJCkCAJEhIoSKREm2otIzmSY2exx46VcRKnb3vueE48J550zrR7kjk9k+Pbk/TJ7fHccc/kTHvOpM/k3HG2aaXttj2J1a20FS86oi4lUQJFijtIkCB21L6hlvvHi+eHXxWLmwQuoOo5B4cEanur6n2/6/N9vq56vV6njTbaaKONNjYRHXf7ANpoo4022rj/0HYubbTRRhttbDrazqWNNtpoo41NR9u5tNFGG220seloO5c22mijjTY2HW3n0kYbbbTRxqaj7VzaaKONNtrYdLSdSxtttNFGG5sOz83e0eVy3c7jaOMO4XbOzPb391MsFqnVanf0dW8XdM7r2Jt/v5dxs9er7ud2u/H7/SQSCd5+++3beFxfu23P3cadQ73+tRve56adSxtt3AiFQqHB8NoGbisHJ83HvpXfi+ByuRq+q2q1Srlc5sKFC3fxqNq4n9B2Lm1sGmSw7gfje7/Ddiz6f7lc3hJZWRtbA+2eSxubhlqtdl3jtJUN11Y4dh1jvV5v+f+bQTswaGOz0M5c2thUXC972cqGaysd+wcpR24FJ9rG1kA7c2ljU9E2TncPH8QBbiXn2cbWQNu5tLFpaDuWrYm2Y2njdqDtXNpow8KNHKR6GPebI22mW7fRxgdF27m0sWlwuVzm517CzTgM4VaO/X5xMPfL+2jj3kLbubSxqbgXo/oP4uxs1tX1bm+jjTYa0XYubWwq7sXM5Vq4WcdwvzuQrfSdtbF10HYubXxo0Dz/Yf/bjFZT+bYRbv79Rs/XRhsfNrSdSxv3LZpLdM3OQf92dHRc0+k0R/WtdNPuBO6U02o7xzY2C23n0saHBs1T63Isgu04Wsmj6HY7W7leNtRsqD9IP6pdtmpjq+G+ntAfGBigt7cXv99PR0cHlUqFcrlMsVgEwOPx0NHRQblcZm1tjUqlwuXLl+/yUbfxQSCncaMGvAz96Ogou3btorOzE5fLRSaTIZfL0dHRYf5WrVaNY1lbW+Pdd9+lWq0CG4oErai8zWoF1zuuNu5lHILYz0Hv+q9nAE5f5/5vAidu+1Hd67ivnUt/fz/j4+N0dXUBkMlkSKfTZLNZqtUqfr+fzs5OCoWCkYpvO5etAduYNzuUVr+73W6q1WrD/d1uN4lEgr1799LV1UW9XufixYvMz89TLpep1Wq43W46OzuNc+no6KCjo8PoqNVqNVM6q9frDSU2HZ8N+/dboUC351DuJn4OXoNt445DufSv9sBf7Gl91wrwSoS2c7lPnIvdXPX7/ezZs4dEIkEikSASidDZ2Um1WsXtdhsjUy6XCYVCxvF0dHQQiUTYsWMHpVKJdDrN9PQ0i4uLxoi0ce+glX7WtRyMjL7b7aZerxMIBHjkkUeIx+P09fURjUbx+XzUajWi0Sj5fJ50Ok0+nzcZzNraGuVymVgsxnPPPQdALpfj1KlTzM/PX5Xh3GzGcjPZTDvbuVPoZMMkdgGfh8cT8AL0jV8kTMa56ZNFiPnhJzhZzChOVnMMKAKfSUDxa/AakLwEvAxcBtbu4Hu5+9jSzqWzs5POzk727t1Lb28vXV1ddHV1EY1G6enpIRaL4fP5jLPwer1Eo1E6OzspFovEYjGTvdRqNYaGhujq6qJSqZDL5dizZw/5fJ7FxUXeeOMN1tbWqNfrrK19uE6SrQTbqNfrdTo7O/F4PHzkIx9hYGAAj8eD1+vF4/EQCAQIBAJ0dXUZx9Pd3W0e7/P56O7uxuv1kkwmqdfrbNu2jVAoxNraGoVCgW3btpHNZllZWeGtt96iUqkAmNJrM4GglaNoZyN3G11AD/Cfw5dwrKIfeBYG/uNzDDFLFQ9lvAA8OHyczOfCXEquZy8vQOcDadZejEAWOr+YZiQ+w7kLe+HINjjyRcfRvHIJ+Dc46U2B+93ZbDnn0tHRQVdXF52dnYyNjTE6Oko0GiUSieD1evH5fASDQcLhMKFQiHK5zPz8PAChUMhEsOVymUAggMfjMRnN4OAg4XAYl8tFuVymUCiQz+eZn5+nq6uLZDJJJpPh7NmzlEqlu/xJtNEKKncFg0E6OjoYGxtjz549dHd34/P5zPcdDAbx+Xx4vV6KxSLlcplKpYLP5yMWi5kAQgFKMBgEYNeuXUSjUQqFgjlHlpaWjAOr1Wrk83lOnDhBPp9vOLbmUt77eW9tbCZ61n8+D1/uhF+BPc+8jYcqbqoEyDPILBOcYJZBjnLAOBgvZSeDedbHtt1nCJNh9otDlIpeJqLHCVBgaMcs1R1uMp8LM1sdYuXr2+APfwuSAIeBV3CczP2JLedc/H4/+/bto6+vz5Q0urq6jOEIhUJ0d3cTDocBp3RRKpXo6OgwBkfZh9frxeVyUavV8Hg89PT00NPTY0ochUKBbDaLy+VibW0Nj8eDy+VicHCQ6enpu/tBfMjRLOtv/z8QCPDwww/T1dVFIpEwpA4hHA7T399POBymVCpx5coVyuWyYY/5fD76+voAJ3sBiEQidHV1MTg4aDKXtbU1MpkM9XqdarVKpVIhmUzi9/vZtm0bJ0+ebOjxfBAp/DvlWD48DiwCfB72J+B3YdvnT2+UvQAvJZ7mxzzGEcr4OMtuqrjN7T5KPDh8vOEZh3yz4IODvMFBjgAwT4KXeZ6q2w1fhZXYMHwHOHYILq3gOJn7E1vKuQwPD9Pd3c3AwIBxKjL4gsfjoaury0SkpVKJtbU1Ux7R7Z2dnaYxq2zG7/fj8/moVqvmeWu1GqFQiJ6eHsrlMrlcjmAwyODgILVajdXVVcrl8l38VD58uBbFt6Ojg927dxOLxYxDiUQixrGooe9yuUw5LJfLmea9nIvOBbtB7/V6CQQC+Hw+AoEALpeLYrFIvV6nt7eXjo4OisUi+XyeYrFIKBRi586d1Go1FhYWKBQKm7aps7m5v5nN/g9Hf+dZ5+czwAvQ88LlBscC4KPMbs4wwgw/5j9ihpEG53I9DDHLY7wBwCyDzNPPKcZxu6usPD4Mc0AM+IvncUzwCjDN/ZbFbBnnsm/fPvbu3UtPTw9+v9/QiJVlaEVrrVajs7OTer1ONpslk8kY1o/L5aKzs9M09dfW1igWi3R0dOD1evF6vSar8fl8hsJss4vy+Ty1Wo3t27cDsLi4yNLSEhcvXmw3/ddxO1cdt5o/cblcVCoVJicneeSRRwiHw4bV5fV6zf0rlQput9tkJ3IIlUrFOBbNvTQPVtqkET3Wvm+1WqW/v5+Ojg6SySTVapXh4WHW1tbo7u6mWCxy6tSphhmbVp9Xq9tuhLZTuRV8Cn73MfgidPamicWTVzkWGwskOMp+MoTf16v1ssyn+R5nOM5LfILMI2HmR/sp/kUP+Dsh9nE4Crwyj8MQmHpfr3MvYks4l/379/Pwww/T399PJBIx2UWlUmlg6Ljdbrxer2H3pFIpstmsiUDlgNxuN7VajUqlQqVSMX2crq4uY0A8Ho/JdiqVCoVCAa/XSzAYJBgM0tfXR0dHBysrK8zMzBAKhahUKrz33nt3+dP6cEFO4aMf/Sj79u0jkUjg9/vxer0maxU6Ozvx+XyEw2F8Pp8pZ+n8UFDSbKx1jimYUY8ONhxLR0cHfr+fnp6eBgZioVCgs7OTbDZLMBikXC4zNXVtA9JK56vZ8G+24/7wOJZfgj98mIHfOUeCBYaYJUmMJLGGe7mpMso0CRYo4SVD+KazlmZ4KRNnmTwBYjiOzBstcfrZHni+zsDu88xdGIE/ScAffQ6WHgVe536gMm8J57Jjxw56enoIhULEYjGCwaBh62gwslar4fV6TUmsXC5TKpUoFAqmbl4qlYwzAczgJGCciaJgGY9arUapVKJYLFIsFvF4PKbsUqvVTGksFArh8/nazuUOoDnSr1ar9PX10dPTY5r1chT1et18t6Ihi56uYAM25lean9s2vG6325RLOzo6zP/r9bo5F+XYdN98Pk8mkyGZTOJ2u4lEIg3vwZ7yl/Nqhj1Hc63P4YPgWlnTfYeHHmbb7zi9lQB5JpniJHtbOpdJphhhhjPs3pSXnmWQU4xTxY2HKnvG3wbAQ5Xwjgynf/EReA+Y2wmvBGg7l9uI4eFh9u7dSzQaNQwut9ttMgzVxkUhBcdBdHd34/f7KZVK5oKsVCqmAevxePD7/eY2RaRimgHmb7VazUz0ix0WDAYJhUImCrUNTL1e57nnniOVSvHmm29eJRdi//+DSIHcq2jVuH4/j78WmnsWg4OD7Nixg2AwyMDAAB0dHQQCAfMd+Xw+1tbWzDkjgx+NRvH7/SbQ0DnUPAAp6PyIxWKmh6OMxZ6BUulVWYzH46FWqxEOh0mlUmQyGdbW1nj66adJJpMcO3as4TPTczbTlwHTE9Ln1Hz7B8X9di5u4FkIPQtZ4HnoIo+bKhMcZ5IpvJTwrGcqXTjsPg9VxjmJm+otv9peTrKXk1f9vbrOQRM81nN7qBJ6YJHs430OgWwgAXP/Jc4vW7dMds85F7GxDh48yODgIB6Px1zAlUrFNFc9HufQg8FgQw9GPZVKpWJKaMVikUzGqav6/X7jPHRhq/Eruqnq9KVSyby2z+ejv78ft9tNKBTC4/GwurpqsiM5r1AoxOjoKKFQiDfeeIN6vc7Y2Jhhs+n9lMtlZmdnmZubM+/tw46bmVKXIR4aGuLRRx8lEAg0GHMRNcLhMD09PQCGcqzsROeKHI9moXRe2Mcjo6tymijMylrdbjc+n8/Q3Ov1On6/n66uLtPgV/lVj0kmk3i9Xnbs2MHc3BwADz74IH19feY+yqouXrzI3NycYSxuFingep/x/YMn4YvPwn9bhyUXbCsao17BTZgMH+MVHmaKQWYJtGioi5Z8sxjnFOOcuurvbip0UaCy7mB8lBlhhnkSzDJIPhtwBjABDgLFOLzyOah04gxgeoAHnfeE/d3ncYY0z3Cvzc7cc84lFAoxOTnJ6Ogo8Xicer1uJqaz2SzpdJpoNEooFMLlcuH1ehtKEYBhA4mSXK1W8fl8ZugSNiLBQCBgKMhiFcl4yAjZka3L5aJUKrGyskI2m2VxcZGVlRWT2ag8Nzo6yiOPPEKlUiGbzVIqlUzJTmWUvr4+hoaGSKfTnDp1qu1gbgAZ1Wg0yuOPP05vb68ZipTT0LxKvV4nGAya7Fb3sTMrOYV0Ok25XG7IGuRkbAei7EfPofMtGo2agEGEkmKxyPLyMktLSywtLZFKpUywotLrtm3b+MhHPmIkiKrVKtFo1MxZ6ffR0VHy+TzvvPPOVRI2wvudndmsx997GIVPfhz/N1bYGZ3Grm5VcXOKcWYZ5BAzxJzBk5aIs8x+3mKB/vfd1AfYyTQv8KKZkwE4zyizDHElN0TtL4LOoKVMgB94Clj6NOx33g5L6/8+az1xNgDf+TT8BbB0HPg294qDuaecS0dHB/F43MwUqDGq8oOyBJWjbMZY84/H4zGML0WSynbsBq3f7ycajRIIBAyLrLnJK/aRokdFpNIqy+fzRsjQ4/EYrbL+/n5CoZAhGAQCAbxer4lM1VSu1+vE43HK5TKrq6t37fPfLNyOyFrBgNvtZmhoiO7ubtNbkcKCZpNEQweMU1FQIadh04vlJOz+i4ytx+MhGAwa6ntnZ2dDmVXaYyrd6u/ZbJZCoUAqlWJ1dZV8Pm/IBXKEnZ2dRCIRIpEICwsLVKtVYrEYXq+XarVKqVQyr1epVOjp6aFarbKwsGDex804mPu+l3IVOoFn4Es4jqUFqrjJEKaM1xmIvAZiJNnOzHXvA065rZdl46iquEkSo4qbGElCZJjgODGSJIkxTz9HOMgsQ2Tf63OkY5pjyxBwEDq+mmM8cZIT7z4KSdhz6O2GstqZ/WOs9Ubg6xOQPYNDa1657vHeCdwzzkUKxnv27GkoT6nskclkTP8jl8tRqVQMu8uuQdvOpauri0AgQLlcNkZIUaMyjN7eXvr7+wkGg5RKJTKZDNls1pQn9NxyPMVikdXVVRYXF5mbmyOZTF5FChArSfX/WCxm6vZqQEu3SkyjaDRKuVzm4sWLpNNplpaW7s4XcY/BLoXt3LmTvr4+JicniUajeL1eIpEIoVCIUqlEKpUil8uZHxEzVCoVU1ClTknARCIR4zA0wS/4/X76+/sNC6xWq5HJZFhZWSGTyTSUYZU55fN5lpeXWVhYYHFxkUKh0CBwqcBIQY+ybI/HY1iIOteUxQBMTExQrVZNyW1pacnMYsGHaQDyengS+Dj8NkR/0Sk5hskwyCxJulmgH4A8AY5ygDHOMsr0dZ8xRIYE88ZZNCNMho9ymIO8wRCzAMwwwo95mgxh9nOUDGEyhBnnJCcZ5zgPMsMI585OOFWtZIsX9gADEAjlCZPhmX0/AKAXxzaU8LFAP0PxWS78YsQpq733aScDmnsH+Ckwf2sf3ybinnAuY2Nj7Nu3z+g2qbxQr9cJh8NmoG1pacmwtzSbILTKXCKRCNu2bSMSiRjjLul9MYfi8TjhcJhKpdLgMKScrKhXzdlCoWDox4uLi+RyOZNB2bMVthyNXauvVCoUi0VWVlYoFAoEAgHjyDo6OkgkEszPz/Pee++ZevxWw2YaORnPsbExDhw4YL5PwPRW4vG4OR9UNrKzT30/dtNe31UkEmFwcJCuri7K5bK5P2CYZ3Is+XzeBBZST5aTEkR/VllMmmQiiMhx+f1+uru7jQRRMBgkEomQSCRMBpRMJo0GXiAQMBl3KBRidXWVer3OyspGhCqndDu/j3sbz8OXn4KvQM8Dl0m4HcM6yjSf4nss0M9LfMIMRC4TJ0/ghs86wgzP8TIxkpTwXXX7ELM8wasMMcs8/RzmoxzlAK/yBGdSu/lTfo1qxUO14iYcy5BJhqktBR2Swcs4cy7Fq57WGbR8CvqDC8RIMskUo0wzwgwASWJ8j0+RIcyOx94j+VCMasVNdikG33kYfvth4F9ytxzMXXcuExMTPPbYY2zfvp2+vj46OztJp9MUCgUTdWq2RJpOcji6YFUusZux4DT7t2/fbsoRikoV6cnoFAoF5ubmuHLlCqlUinQ6zeLiIqlUqsEgAKYhm0ql8Hq9dHd3UyqVTK3frqvn83lTO9csTTAYxOPxGOelY5N+lRhPnZ2d9Pf3k0qljDzJhwl2KWdiYoIHHniAbdu2MTIyQjgcJplMks/ncblcxnErW+zo6DAG2e6RiJEFGyUk9WN6enpMBmrft7OzE6/XSyaTYW5ujvn5eRYWFjh37hwLCwvmMXZJVQ6sXC6bnqAybwUSPp/PlH/1XuXwAoGAEVut1+uGkCCno7Ldzp07GRgYYG1tjYsXL5pS4IcTPwdfPUTf/3CRQxwmwTwnGWeZOF3kGWKWMc7gpcxxJgDWJ1xuXIYOUOAAR1s26gGjQzZPP9/j00wxSYYwx979CLwIdmKUIrjxSwXHwcRweinTNDoZj3ObjxLzJMgQZok4Q8wyyjQB8nStkxAC5An48uADgjOs/sMYc7274Mv/BWRPrz/5m9xJFYC77lyGh4cZGBggHo+b0oCchZrwXV1dxqHkcjn8fr8xHHZJoHmroJq99lS0XU/XxZpOp5mfnyeTyZisplwuk0wmjS6ZGvaBQIBisYjb7TZZz8rKCktLS6a0otmbXC5negGKTsV0k8NSpG33iADDMqrVakZ4c6tgM2r8MvCVSoW+vj4SiQQ9PT0kEglTfpKhlUFWNqDs0Zb5sR1GM/3X/txboVKpkE6nuXLlipFyaZaNAVqSAmwmYy6XM3uDVD5VSc0mBKjXaBNUFDzZM1rK6FXuvd7k/32PgUNEf3+OBPMc5AiPcYQ/4wssEzd38VLmEIfZz1vArTHBvJRv2Hc5zgRHeIwCAaf5/xNYlxi7PkaBh3BkYa4RH5TXj+ANDrKT6RuW8rpJUv6Vy6xMD8PLe+Ane6AiRtmdwV1zLi6Xi927dxsNKF0gbrfbOI5wONxgjBXRK5rUhabo1F7oJJaQ3cC1GV/6XRGi6uIyTNFotGGCv1QqUa1WCYfDJkuRzL96LGreqq+iElw2myUQCFAoFAiFQubY5PwAIz/j8/lMsz8YDFIoFNi9ezenT5/eMtnLB5lz0eNl+A8cOMDY2Bh9fX309vYSCoUIBALU63VCoVCDdph6Xvpsm8ke1zo+u0wm6P+SFiqVSmZ2qrOz0xyLfczKdMVkVFAhlYdyuWyYYzovYrGYISLI0djO0e/3m+xWWbTf7ycWi1Eul1leXqZUKjE+Ps7U1FSDc/twoBP4FPw2xH3LjHPSNM6f5kfs5gxDzOLFCQ6dLOP2GFhHlt8pm3kpO2yvgaY7HVv/9yHrb9uAgfUdMVkch3S08WGzpSFSSzF2DZ81dOYu8kxwnGlGG5yoEHZnWPkMGxs0X3mGO8kmuyvOpbu7mz179tDf3088HicUCpnBRhlqRaM2zVTyK7bRkHFuHjizsxq4euufnJFdypKDU6NVcxIul8toUEkdYG1tjXA4TGdnpxHTVHSraW05y1wux5UrVwgEAqZcoxq7zVBSZpPP5+ns7GwYBIxGoxw5cmRLOJj3GzHbQ4yJRIInn3zS0MS7u7vN/h2v10t/f7/JAHw+X0NZyQ4umh1Lq2Ntbojb/+r5REXWbVLPtjPgxcVFKpUKsVgM2BjGVVO+VqsRiUSYmZkhlUqRTCbNvhjJ/sdiMfM+Q6EQ4XAYj8djVCJUUtMCPJ0vpVKJBx98kFOnTn2gfUNbyzFNwkOfg9+Ggf/snJm6381ZAA7x+h09GjeVBp2yxL552LdxewkvU089DMBY/MzVTzDs/HPy8XFq3ww6oyuvwfxYwrnhjJ9zlb1M7ZhkguOMc4oJjnOU/eTpMjtnlI0FyPPgvjdZ2tfL4sHt8K0J+EYX8GfcCQdzV5yLBg27u7vp6ekhGo0aw6ofOwq1I9nmEocN9WDUy1B2Ih0yNWj9fr/p50SjUYaHh00fRAbBrp9Xq1WjUeb3+ymXy5TLZdM/UUkrGAzS1dXFwsICgLn4S6USuVyOZDJpSjnhcJihoSEj+16tVgkEAsZxaTanu7vbZG3lcpkjR24mz96akGPRe9fCt0AgQCgUMrRul6tRPLJ59sR2MtCoiqCeh/03Gzq/9FgFNpFIxNDF7cfrtYvFoqGc27NUen6VZzW8aZdQQ6GQkSxSb0Y7iQYGBgyleWVlxfRV7OArFAqRzWZNee3dd9+9nV/TPYQH4evw4CfeBDBT93cLExx35Parra/RF90v8D/Hf6th1qUVdifOcPqLE/DNTjgGyaUY44mT8DiUil7OMsY0OxnnFDGSfIKXOESMk4xzmENMcJwqbqaYBBx2We9jS8w+NESKnfCN54G/2ey3fxXuuHPR3hRJaYTDYTNcqJKXymCtyhfQKO5n91PkVGwDoLKG+iT2FL+MdjweN9mOpNHFulFpS9Gtz+czj5WBW1tbM68n8oF6NCpxqMRmqwzEYjEjalgul02tHTDHqhKhothgMEgul7vt39P7QXPkf6vQ96h9KuqF2MvgdH7YLDC7j2IHIDoWZRhyLLagpXp8+r5VjrIZZiKV9PT0kEqlKJfLDWVXZdxi/tXr9YYgQSxDHcvg4CCFQsGcI3bJ1z5H1S9SVq/n0ZyU7qO+TrFYJJvNEgqFTL9va2Uit4Iu4EEkC9a1nrXcqBdxs0gSI0MYHyUGmSXBAm6qhgwwxOxVQ5VDXOHR0yfgj4HU1c/5//ynf86R/oMtncsScabZSRkvHqrs2HGWC/sf2CijsbEvxkaYDPvXa2hd5JlliEmmWCZunIv9+NSvD8AfH4LsYW73LMwddS4dHR0MDQ2xa9cuY4RVL9dAmqJP+4IHJ5q1Lz5d+HI4uliz2ayJIjVpXygUSKfTJsptluxXCUwlLBkfWzNKRs0eogOMZL8d6apUZysCqKyni11zOHpu+/1Ho1Hzul1dXSYa9vv9DA8Pc+pUa9bK3YYtxnirRk1RvdvtZnx8nD179pjyj9vtplgsGvFHuxTaqqei2/S9qPwpGaBUKkU+nzeyP2q2p9Npurq66O/vp6+vr4E0Igcj426/X5Vn5QwAE+ToXFJzXv/KUdnqD8rQ7PMTNnqICizy+bw5DmXY1WqVSCRCNptleHjYLCq7f/EkfNVF36GLACRYwEuJk+wlwcJ1p+6vh2XizDLEFJNMM8oIM3yR/4OBv3O8xY+feZoJjvPMwuu82f/gVY+/sKePHT+/6PRMZml0Mn8O/+vBfwRDUHTGbfCVwDULlx/q4U/5NZJ0c5wHOc4Enc+nWeuNEAg1bjSNs9yS5aZMppsk7zDZoHGWIcwCCfoeu8jib2+H338S+N77+oxuFnfUuXg8HrZt22Ym0+UMNIAWj8fNIia7/m5DBkNzJ4CZbJc4YK1WM812ZS66wIvFYsPSKL2Wx+MxBIJCoWCUAJQNybjLgEgQU7IzaviWSiVjANWQBYzTkOGwjZ8clkpyQ0NDxGIxE2mn02nznPZMxb2KWzFqdjaqLGFsbMyUiur1uvluRTnW0q5rlb9sZ6PPMJvNsrCwQDKZJJfLsba2RiKRMAFINps166xF6BCt2f7sFWDo2Jt7PTo39Bi7n6PZm2q1alY06Lvv6uoyatsifYhFCDT0faTQrUxYChHFYtGcj806afcXusDzFPzKxkDhMnH+ludxU+Xn+Wue4NVbftYF+nmZ55li0mQuFdxcYYixx89yxHeQZeL8fO5v4CjEf3aJZdMtd+CjDAlgEijR6FxOrP8cAL8a+svAYRj2rPBfP/BH4Id//dlf5J/w+/j8JdwHV+gPLpin6GeBT/ASEy1Uk2PrCwTA2YYp6nSGMK/yBEli9LLk9F/Ydsufz63ijlmqXbt2MTIywtDQED6fz8hjFAoFurq6TNkHNgxOc/SmersiNXAymlwuZ+ZTisWimXqWowDM5kHt8rCjTGVDel6xjTTDYAtnKoMSRVrN+UKhQCaTMZmMMiRlZ3ptkQBgoyZv025lwFS+KZVKhpasXs3w8DCXL1++U1/dbYccwUc+8hH6+/sZGhoyw4V2mVOfid1bsWm/clDQqDqtrGVxcdHQzWXMg8EgyWSyQUNMj7G/H3s2Sj0ym4kINJRSdVvzsjLAOEgJUXZ2dtLT08PAwAA9PT3m/IBGpWX79RQw6UfUe/0MDQ0xOzt7HzqYL8DYHngB/GMbZR1NwLupvm8NsONMmKl6cMpMO5lmlRhf932VH/E0h3gd/xFg2Zl/WW56jnAp40zInwauVb0+DeuD/M6siwfYAyw4t/3ywe/z7ZHP8ufJcaK9SXzrTLdBZvkEL/EEr96Q8RYmwzz9LJBgngRn2W2YbAB4ElAZhU0qI7bCHXMug4ODjI+PE41GTYNbWQRg6sq2gVBGIWMiqqaiNg2uqSRm0zgVkcoQSG5DkZ2Mk6JlDa7ZKrZiZtlGTBmQLfVi1+dVXtHxaUJfDCAZDhkMO7KVEcvn8ywuLhoWkJhCHR0dZqvh/eBc7DJatVplbGyMbdu2mWhdDl2OBTYCDru3YpM8bKdgZ75yHvqbvhNRiFOplGH+2SxFmyggCrwa8XbWpX/tPkdzQKT5LJVtdS74fD6i0ajJbPXZ6Lh1bukz0PT/8vKyOQ45GHvup/lzbv7/lsTze+j79xfxUTIS+ZuFEr6GiX1NxRcI8COe5gpD/C3Pce6Z/51dR+eYZfCq55j2jbJv6JzjYK6F7PqPcADSv9pJZGoNzgPfhBf+4EUODx/CbQmOjXGWQ7x+U1TqKm5e5xA/4mnDIjPwAI8DP/koW965uFwu+vr6iMfjxGIxSqWSmecQA0vzC3Y5rNlotNKNkoORAbJnXex6tFg1Yh/Jaen4pGPWPGWvurZNLbYH3uTMFDGqrl8sFo0x0XtrHuiz98bIyIoZlEqljJS/3pPq8dVqle3bt3Px4sU78fXdMm7FgDVnGmLdyWCKcut2u43h1/31uclxVKtVoy+mLEEBiprnCmb0PRaLRVNO1fcUiUQMqUTvRT0ym42ozKO5hGtvRxUz0X6vylR0fBKvFFnE/kxsSr3O70KhQDKZJJ1Om/euYMnv9xu158HBQa5cudKQvWxpxwIQw0zbrxLjCkMNN49zkjFa0HzXUcXNcSZaLgHTMi8bXsoU6DJRf4Ywb3CQ3smXqLYwnyV8rB2CTg/OvMq5m3hP8xA5vUZxD/h/VW8zyTgnmWYUcCRoJpkicJMO9TgTnGScQit5m/1FeNwPr01AZQyu83l9ENwR53Lo0CF27tzJ4OCgiRZtyRR7EZNNL9WFLLHAxcVFMw+g/RuafZEDkFGxSwvgGJNIJGLKDoqKle2o5yK5dDVOlTEoE5KzsksSoiBHo1HjZHK5HNFolFgsZnaGtDJCzUZSWZgckR2xu1wuc/v1JsrvNm615+JyuXj++efp7u6mWq2aZV8qPYmeHolEiEaj5rO0s0uAXC7H3Nwcq6urDbpwKk2JxmtnOwpw9F2oZGV/vrq/+mXaEaQpfbuMq6ADNraY2uU2nd9dXV0MDg4adlw4HL5KwsjOwJpLfBKwlONTKVXXikgIzZ+z/Z5a9TTvbfxX8BWYZIrneZk8XVf1PMY5aeZcBDtqP84EL/KCMdrvB8eZYLf77DVvn4o+iO9nSkzsP4frCBv6kZ71nwqNCsizwL8B/y/De4d2GCXlz/OXzDACOA51guM3pShQxc1Jxpll6CpVgSpuHhw+zomvTEKyE/74Qba0c9GgmEo89mIu2NhtLoMqeq+YX+qrZLNZc/HJENt9ETXg7fq5shFdeHIMdgPdZnHpONTklfLt8PCwkf3QMehCL5fLZLNZ02PZsWOHibrtspkNW/ZfWZZeX1mebQzy+Tzz8/OmJGgPiG4FNA+x2gbT5XI1nBOavpd+nL1PxS4zZbNZVlZWjIPRnh3tRlH50l7SZvcwdLsyUmUZcko2xVk/dllO55StqJBOp03gAxussVbsRPucUDBl93fsUpZN/lAQJsaijlmZbjweJ5PJXJUxXev7uJm/3xN4KsKDz7xJhhDHmeAJXr3hoOQsgxzmkHFCjnDK6G0/1BI+3up5kLHnzhA5seY4l0kc0ebXuFoW5iLwr+GBBy+AD4rPAEHe19yOmyoHOUKihWDlO0zyOofYteMU58b2tXj05uG2Oxct7KpUKmQyGZMFqPehhmazdpJS/3w+b7IMoKFsoHKALnLbEMDGzEI+nzdlFjkrMcbEDnK73SYKbZYPAYyOk0pmuuCBBsqpdnuofNNMibVprLpdUERrP06GVOU6rVy+p41ACzRHyvb77u3tNXtMtNteg5Q2a0rGXgFCKpVibm6OfD5vnIeGVGVYm5v+YnDpPso4tS9FQpLqren17f6QMl2bVKDbtNVSwYLOS/u7V8atbEafh75zW+FZt+l1fD6fUbUQwUSfiT43WwKm+ZrYuhiGUWeD5CnGWaaXMc4YheBWqOJel77/j4zU/vtBFwViJPFSYoQZI6t/Myi5fdC/5jTrd8K7D+1iX+UcvEdj3wUcB3MR8IA/CoEn8zel2twKuzl7VQYHjtN7g4Mkq7GrX3+TcVudSzgc5uDBg2YCXiUm2/jaJQVd9JVKhZWVFVZWVhouSNhwLrpAtXLYdkDKRMTQKhQKptmu/ooa/Fo/rOeU45BSrgYg6/W6kT3XZknboQHmNq/Xa8ocdllDmVNzs9k2LHb5zO75SBXAZqx1dXUZNty9gBsZsGY2F2BWWsuw207BzjZlcOVkpAmXzWZNdmDPjCgjsckg9rmj5wkEAoyMjJjldOrbqC+oXpndW2kucyl4Ef3Y5/M1MBrt80rnuIZmdZzKtvWc+ryaSR/2OgDNW9mOZW1tzcxqaV+NzpGbcTD3phMagwd+HX63cfe84Mxw9BMjSdziby0T5ygHSGrS8n1ihBl+nv+bCU7wzNHXeW3/I7zMczzP3zLCzHWl+5eJ4/tPSkQeXAO/4xzn9kcZWEjB39Jy2JIK8BrsfugCU9GrZ2k+KKq4WXlteH1AcxsQAdKb/jq31bn09/ezfft2BgcHTeaiC2xtbc0s5gqHw0SjUTOprNt0gdtlI5fLZZrc0WiUeDx+FbVXrCzV6bPZrJHP0LY/NWj9fr85HrHKVH4IhUJmz8fa2ppxOB0dHWZJmAwAbETJcgTKduwI00arsosMjH1/lV4kaaMlZ2r6b0XIiI2OjjIyMmJIFvY+FmWuhULBLF1T41vMPvU41JfROWD37ppnUfQ9K2uWU0un08zNzZmGeDAYNI+15030rxhkKr02s8WaBy5t6js0UtGbSSz6jOwSXnP2BBvlVT0XYPpCor5LHeBmcG9mxF+Ab8FT+/49bqoNC79OspdTjPMW+9nJNJNMMcQs/SxQwsc8/TeUW2mGmyr9zNO77qjCZPh5/pods4vkHuzgn/J7TDHJf8qf0PftLNXPuq/pXPIEOOMeI7w/g5sKVTzMMgQ/CwOeFLxEawfjgerttM4enPXJZxJwbAfcBtmc2+pcNNWsUo9KFppf0MZFRV3glEjsGQENVdoXli4WOSVbIdkua8l4uFwuksmkUTXWBSxHIscCXBXh6sK2xSp1wao8ZdfD9V7taFYRpZ4bNoyr3TtpLpXZDDjbaEp115aLuZdwM2wx3S4n7vf7TQlUpTENx2rNgjLQ7u7uBlYgYJh56qfZxt9m59kNcHvYcG1tjenpafL5PP39/aaBDxuzJvq/DZXa1PexnaNNAGmmM+t4tKDMzqZalXjt0ptdCmsuqyqg0jlj9122bOYSchF6YNFI5f8tzwOORMtb7OcEE+QJMMMIb3GAT/Nd+lm43jNeF26qPMxUQ/O8QIBvDX2Or5T+iNR/N8Az//0P6Pt3WbgIgWqeFgsqG9A8ezNPP96fKdFzusj629qABzgI08Ed7/s9XA9uqmw7dJr5sQRrlyJwLHJbXue2Ohe7LCT5E/uCB8xqYd1HelsqX6mJq+fSeuBAIGCoy3a0KChTKhQKrK6usrS0ZMoQNivHroU3937skoRd+7fLabYhk7FShqGmsiJl+33ote1ymfoqrZr1+vzkoO/FCexbqe/bUbbeR6lUMhmIGuxdXV1GyQEwWnT2Z6Slbb29vWaY1dbesg28HHSlUjEU5FKpZJaA6f7NJTw722mmHyubBBpet/lc0ntVf0/HJcakNmw2s7rsz8wenrQHiRVIKaDTLI2e4550GrcIH+UGg99FnnFOUcbHcSYoEKBAgHeYZIQZZhghSbe5/yjT7ObMuvDj6DVfp4rbyS5wlIzF2HqJT5D6owH4cpF/wW85wf77tKBVPA5N2Ndigcse53kfOHbB+b0fM3j53i/veN99GBthMlTibuZCt8exwB3IXAAymYzZda4IUxerLZ0SCASM89DvyhSkq6RsQRmIlIbtuQRdwNozfunSJVKpFHv27Glo1Gv2QY7MZgjp78o6RPvUBazFZmK0qecj9pgiUXDUAXp7e400vB19yrlpjmd+ft6oFsi4ut2OcKVNo65Wq/T397OwsEA6vfn10veDGxkwu+RiG2YZ30AgQH9/v5n7gA1GnvoLyWTSfC/a9KgMVhldJpMxx6PPVmSNWs2RrLclU4rFIufPnyedTjMwMGAyZu1SqVQqDTI+tnOxGX92X0UbKJsZYMqSVDLT+49EIuZ1bMep80OPEYNRAZlYdPV63TDJRHCo1WrE43Gjy7bVHcwZdjPBCT7Ddwis7zJJsECYDNOMmvLXUQ5QIECSWEMjf4LjvMCL/CWfv6Fzkeije12ocqY0QuqbA/Aa/L//0T/mka+cNnTiyJ+vkfj1eeZJ3NL7yROAZ1YcZ1LBcSBHcayypvwBhnCm/fu5KSrySfYagU2AXpaZZIoYSUY5zzgnN26PARzC0aXZXCHL2+pcNBGvqLOvr49wOGy4+PZ+cBnp5eVl0yyVtIpdj0+lUob2qx3lWndrR6ZyLvPz88zNzRldKtFbZVj0OnIuMlwqrckJ2vRfiQjqYrXZYjYdWhpS3d3dhEIhEzHrdhk9GTg1qbV5MhgM0t/fb2RK+vv7jXSOaNn3WvZyPdjZgF1msmdZpK2lUmahUDDLuYrFoqHbiknW29trzitlifl8vmGKPp1Ok06njUPXqoVgMEgmk2F+fp50Om2m9nt7ew11Xn2dvr4+kzE1MxYFBQ22QrKcT7FYNA5Cn4OyYc3v2JmGTQKQCoXUHxYWFlhdXTXbKMXIlKPNZrOsrq627N+0yvK3Ck4xjocqn+NFxjlFkhg/5FmmeJgSXryUqeKmjJcpJnFTxUuZIWbZz1HGOWkWbVVwNwxBTs+PUnstuLEJMgSdj6cZic8wmxqk+K0eeAWIwcd4hfQfQ+RxIAj8jzCcWyH/G4Fbkp7JEObtnXvw7KwyUp0hMrO+Y6VV++OL8N6e62ctzl5NN2V8HOUAZ9cHReMskyTG0/yYMc7yOV6kwuc5zCFnkdi2CFxKsKWci4x8rVZjZWXFLMjK5/PMzc1RLpfp7+9nYGCAZDLJ3NwcHR2OxIkid5fLRS6Xo1AosLi4yMLCgpETr9VqDeuAVTZQ7V4XtdvtZmxsjD179phBRztythvztuyHfRtg/q++TzKZNKU3lSn0oxLfwMAA4XC4gVIsB6O+wsrKCsvLy8apdXZ2GuVePZ8cdSQSadCk2krOBa6W5bfLj3YfoVKpmCn0eDxOX18f6XSaxcVF3G43iUTCGNRIJGLWUs/NzTEzM0M2mzWZowwzbAxSam12Pp8nlUrh8XgYHh5mx44dDAwMmCVtMsa2Q7PLqPY0vl3itNddK3DQ88lB2VmXRDrh6nLp2toa+XyelZUVo59XLpcbZPu1A8bv95uyreZ27J7lVnUswknGzS6TJDFe5QlOMc5eTnKI15likqPsp4s8T/AqI8yQYIFxTnKGMf6Sz3OcCU6//UjjtsdpnN813OiHtaMRzm3bB5c2bvuZ/+P7fOTxY/xBCT76d86G4svAs38O4d/I3LKuWYwkO44swhs4yUOl6Q4J4Ofh9J5tNyyHnWE3r3OIyrqDFZaJ80M+xgwjPMYRDvIGY5xliocdGZhRnPe4ybitzkWRooyFLi5ddFKF9fl8hvapKE7MHxluGRZRT3XxwsZ622q1SqlUYnl52TgVn8/H9u3bGR8fN6KZtkG2nYicix2ZNhtDvRdFkZrStlk7LpfLyLlroZhtMPRZ6Cefz7O0tGTKKYqGtQpXZRpbCVjYSs6l1WyPonO7aa7PUp+rPktRvWOxmFE0lrMuFousrKywuLjI4uKiidyVESnTVClTzlzn0PDwMLt37zaq3bDRD7Kb9QpgFITYGYaNWq1mVCh03tslMx2Lenf252PTi/WjrF40eLvvIjFOm4ZtP6/92s2f//2CIa7wMX5IhjBn2c0IMxzgKCPMUMLL0vp+k7/leearCScLeXn9wX7WI/j13ytAkqv1wQ7Cd0v/MV877CxXTrMxeM8QRjrGTYUEC5TwXqUgYMNNhaHUIvwHWsvEeIARWNnvvymndYUhfsTTLSVfFuhngX7cVBniCnkCuKnQsS1HLRRs8WwfHLfVuahMJCVibXEETHlM0iiSXgkGgw11dv2k02kymYwpLdTrdSOvIpaQJDlknAKBAKOjozz66KPs3LmzYQ+ILkKbNWQ34+2LV05LxiWfz5NMJs2SLztz0iBkX1+fmZMBGsob+XzeGAnAvEcNmdozLcLq6mpDlG4763sFN2IktZpz0fuQgbab+p2dnQ3NdJ/PZ/ox1WqVxcVFU2ZSprO0tNTA1FP2qPXU+Xye2dlZ5ubmKBQKeDweBgYG2LdvHzt37iQWi5mMQKVRqTaoT5fNZo0DatVwFzHDzlL1f3tdssqx9uNVipNoqb5jnfO2qKquJbvkJYembN+m8N8vWKCfaUZbRvK9LPGzvMQYZ8nTxbf5rNkvv7T+78prwxtZSwgnen8eCK2XpYqd8B3gJ9YTPw//6h/+GsHtzvUWBj63B/hlHErv45h5Gg9VBn6agu2wPNLaubipsLM6Ted/gJbEtgQwAjwHCy16OcvEr5rfmSfRUOqr4GahlKBacdMfXMBHiVd5gjPrCskFAtReDq6rBWz+SMNtdS75fJ50Om1W1KoB7/P5iMVipiGpGrUdKdqrYIvFoikHqBbu9/sZGRkhEongdruZn5837B+VMLZt28ajjz7KxMTEVfvqZTgUgSpSlGGyyQMqaelHjs52OLCxAKy7u5u+vj4jZyLHk8vluHLlitlPksvlGhZiKTLPZrOk02lDJPD5fGaeRcSAbDbL0tKS6WdtNegzU8lK5ZxkMgk471OUYzXBbRr78vKyOSc0ULi6umrIDeFwmO7ubrZt20Y87hgVrWWwHXNPTw+PPvooBw4coK+vz1ChAUPK0HeklQher9f0/2Ajw1EfTwGQ/m/32ZTV2oxDfR56Tu2d0XeuXp2yE/XmRK/XinDpqamUrPtoRfeWdTDZZbKv9FH5BWcy/ggHmSfBIQ4btphk6UVBzhDmCI9xlAMNJaLZ0pBjTP04mcoD0PErOXYnzuChymxpiNSZgcby1Cfh//rNT/HLw9/na83D+f2Q/qVOzrjHzJ8quEk/3knF7WaseoZwynFaSz0hqrhJrKRY7fET+cmaozumS3gSeAbwQL3fuX+rAc1ZBvlbnuck4w1/zxA277WCm7PzY9RedPpI2af6oLcOR13OeztYh6TLyd6W3oEWUjEfFLfVuVy8eJHx8XHi8bjJBuQgxHBRyUj7w3UhK9qTbtfq6qoxBor+tF8eMANw+byjGurz+UgkEiQSCTOHYKvH2s1OGzIQq6urpncjOrQyGPU87OlqwMy5iOFlX9AiMczNzbG8vEw+nyeXyxm5GM1B6H6Li4tUKhUzIZ5Op01pIxgMGtaQLdy4VaAsxeVycfz4cQYHB02WIjaXmE72YKQWY+k7to22Bm9rtZrJZvv7+81zqBQ2PT3N6uoq2WwWt9vN4OAgExMT9PX1GacSDAYNu0zHpeMWlF0r+5Q0j3bFiAVZLpcbaPca8rV10wDzHrTUbHV11fSHbAq0PiOdI9It0zZT+5xTsKRZGtiqGcyfwtd/i8IvBAiTMZnI0/yIT/ASMZKmbDTDCC/xCaq4G4ytkHptwMlanl//w36MYzG3f4sGaZRHf/Mn/PJT3+cPLMcSAfhVSH+lk1l3ozJzFQ9n3GPEWWLHdxdNg77vuSxEge9Cz88XnYzFep36r8J/2vO/UsbHx/ghj/FGy09jioevWf6yj6H2StAp/1VwpvH9Luf1KsArro2/M8+WzFySySSrq6smO7F1mWyDqnKAIlTtfCmVSmZvuRg+gNlmCRjHZdOb7fkVRaq6CG3KqM3cUimhVCoZA2Sr6/p8Prq7u03JzG7U6rXtUoSUAPT+xFrKZDImypZUiAyqTWcWgUBstHq9TjabNWWSe6kkdiuQoXS5nF0qS0tL5nu1+xhSqpYzUXapcqEieZfLZTaa9vb2EolEDF1cEb1KReqT6TMPhUINGmZ+v/+qcpY9hyOHodsKhYKhu4tCPjIyYmZNpGWn/faSi8nlcgwMDBCLxRoGgMV2y2QyJotThqMek93rs3tOOn8U+NiyN3ZJcuthBX4Cl/7vPXQ+nmYs7qj4eqgaafokMbMo7Fo6YudTo45x/STwEI4YcKzYKCmTBeYaHzfEFdJHYM36WxfAThoyFmG8dJLg6ZozeX8CR/X4P4F//uRXuMIQ+x9ymGuPn34bdgG/DnNDUb7HpzjKAaq48VIiT4BxTl41EJohTIEAeQJcODsOl9YDhrEie4ZP4qHKuQt7HScq9ttS00Fm1287Ag4lYfNx24Urr1y5YqJ+qcHKIKicIIqpDK8uMl1gpVKJvr4+I1+vLKRarZrBQrvkoIvOdk5iq9kXnN0M1yyA1uAuLCyQSqVMNOr3+xkYGDD7VJRRiVKti7qzs5NcLmdq/sFgkFrNWVU8MzPDhQsXzONKpRKhUIhUKmWOX1RWGTkxfuymbjKZZGVlhbm5uet88vcmmnsUcgxXrlyhUCiQSCSo1RxpH7HyVFrKZrMmANDvxWLR9EL8fj/Dw8MmALDZfgombAqx2HalUomlpSXTi1PT3SZg6LuVYwDM93r58mUuXrxIoVAgFosZmRr19FQ+VcCjtdWRSMRkrfbszurqqsnC3W636Vkq8JH2ma1MYR+nrq1cLsfy8rL5rO3PfMuh8l34xZ9jbSzCia88St8/vMhhDjHLEP3MEybLS3yCU+ylhI9zZydgyUXHaI7adNAxrseAh2DX598lQ5jFI9vhqJ/V4Rjd6+uBr4ev/Qws/m2Ivl/KcvzbwCw8evjE1dP5bwDz8N7v7eDbT34WNxX+ks/z5j9+ynFcIfjcv/wWL/L3wQ3/v6GH+Kf8HjOMmEzrDQ4ywwhfIHOVcznFXk689KjjIH7CepkLGPA7pbCjQYeMcOwGbygL8A63a2HYbXcup06d4tSpU3g8Hj7zmc8Y9k+xWDTqyKIULy4ukk6nzUW5uLjIpUsOR87tdpvGrD0t32wE7FmSZgkO/d9m98hJqQejRVUSMVRUq10wwWDQ7FtR1qFsSI+351rsso16TIDZEd/Z2Wkcq8fjMfvT7eMATD/CbnpHIhFT998KsNlitrE7fPiwcfhPP/00fX19lEolYrGYcQgqo6rUAxiWnZr6PT09pNNp04fTQK76Gno9UYFtwVKXy2UYZfZEv01Pt2nHKkP5fD4zeClhVJVRFfTIifX09JhzV0vkVJ7V+1TJNRqNGqq1jrNQKOD1eolGo+b81PmsjEY9Q5fLZQYor1y5YhzK1s1e3nR+zgC//TyL33qKf/XNr7DrsXcZYpYYSaYZpYqbcyf3wYvAGNQ8Qef/760/TRbO7d/NjuFpGAOOQTYXpjuYvKmj0GbIBWD0n0Hgu8A/xBmEtHEMRnMXcAcreKjyef6SF/6Hv+Ike/FQ5df4M8f6noaP/G/H+NMvfcGU177NZznJXiY4fn0F5hDwi8AAbNt3mjAZziyPUQOHpPB4i8ccw3E8FdYHKB/GcTCbv9Pljq05rlQqvPjii/T39/MLv/ALZsJeBhYwQ2GK1iVAWSgUmJubM2tgbfkMcEopoulqwVcoFDKzDIokbTHK5j0rYvLIEfT29poSlNhL9bqjjKyoV8cogUoRFeLxuDEMem4xyHThq0G8urpKpVJpGKIDDCXZXlKmCX/1p6R5JmO7lWDPXoiaWy6X+eEPf2hWNAwMDBjH0t/fb86HSCRCV1eXkZ3Xymz1HyQHYwcRtgSLAop6vW6ctC1jrwxDj7dZa3bZLJfLmXmm7du3m2xK53WpVDL/d7lchu2mmSV77bXKr36/n3g83jA8nMvlyGQyxsmEw+GGTAg2enoqn4qRODAwYGap7h+8DEem4Nn/gnO/u8+ZRdkPex55Gw9VOmI5ap8M0rP/Mm53lcUz2505jixOqeiP/cx8eYTQ/kWyS303/apf+w+Ay6kzJYBnHwL+ESz+cshIxACMT54k2F/D/9fwX5/+I0dGfw/wDOQmOwgeqTnDlwdxpvDfgshvrhHBkXv5b37pG5z+2W3XpB/v5RQPfuJNushziNfxUeIwh0gSc0qGn7j2ezj/+CjFx50tqGRxSA1//AXgm2x2U/+OORdhYWGBn/70pzzxxBMmqpNOmIynDITKBqpZLy8vm2lk9SFUCggGg0SjUdPgtrW8lH3Y+ma25hNg7idaq7IZ0YtFOpCRsKNh2BjGtCmizc+tOR4ZEZUtZMBsqraOVZPeWlGgCForDJqP417G9er+yvzA2Sj55ptvcvDgQWOA9f3ps9N3Y6820IyTPisZ4Fgsht/vJxwO09PTY2Tp7bKotkyqzGo3ynUOaC5L56MyZVHppSqg1RJ6z8pO9N3Z9GA7m5NunRxjKBQy9Hpbw05OT6VX7SQKhUKGhKJ+oRhnWzdjuRbmIfst+NqvwwPAF6H8iA8PecYTJ7HZu4sPbYcfsNE8Pwa1I0GyDwQ2ehJCCMfgJrnuvpMegC/Dm798tST+Sd84fJaNhn4FOACnDzoO49HoCQjC5ZEehvtXrp5x+S7sCV7i8pM9JIlRwtdwc3i9VBZjlYMcoYSXd5i87moBL2V8lNgZnYYnpwGnd3Npbo/T3D/Tw5Z3LuDMbJw4cYKRkRF6e3sN88vn85mBsI6ODmKxGNu2bcPv97OwsGAG36QjZe9l6e7uNj0XNdxXV1dZXFykp6fHlCQUgTYLD8IGpVTGLBQKNZTVxN5ST6BUKpn6v003FjTnIiMgbTCVYtRPEoVZDVu7bCLnChiygMgJa2trrKysGJWCex3NBq55QNUuO62srHD69GnGx8cbhlCb7xcIBMwaBPVDLl++TDqdNn0y7VgRa9Hj8bC8vGyUIy5dumT2AsHG3JHOEXtRGWAyiFgsZspYClpisVjD4KNKeTp/xPATGUHMMjmX7u5u44QAstmscRhSCNfj5WiV0SuL1f2DwSDJZNI4Tltt4ma/o3sbl51ezLFH4dK2a98tVoQH/E7lZw7HobwMvOYCD2QP9lLZPYuHKj1PXWZlYNjpZbwMZJ21xpF/Af/lb8L/st77jwCchkdnT3BuaKBBIFPIEib9C0nCT62x2uMn79AAuPxQj5GhYTtOw3+WDfpzBfg7GJ5dYfjJFd4bapR9OcBbJJg3DuMIHzPDmrH13pHtaLrIM8kUCRY4yV4WSJAk5qxAfhzHOZ8ZxvmAbNrCB8NdC3tVGtImwO7ubiPaVy6XDYsmEokYkcj5+XkjgREOh42QoWriMuJ+v59MJsP09LQx5A899JAhE2g9LGzQYhUV2uUuu5djkwZqtRq9vb3U63WzU8WeyxG7TY5QhkelOc1BKOoMBALEYjHA6SOInqzejcpxmhtSuS4cDjMwMMD8/PyWcC7XQrM8Sa1Ww+/3G2mgeDxuBg/tx6gk5Xa7SaVShpmYyWTM7Iw+a3tHvTLZtbU1Ll68SK1WI5VK8cgjj5g+j4QqxV5sfm0FA7Z+mM5pZdWAWc9tD0Ha7EY5Ab2fYDBosiR9zx0dHeZ8UM9JvRcxKDXrozKbMpe1tTVDZ7fJDdf7LrYOIsCj8Pg2+CJ412ddmrFteIalL8cpHulx+g3TbLQY/MD3XZx+9hEIrX8unjpsczlT+1k49//ah+tLBf7kN/4BX9v1f/EH5x222Pw/g8S/hl1fn+P0pz1XlbFK+Bw2WU/j8Ujg0keJuZ8pM7AnBX+NQ1nWZXwRx+EswAOfvcC7Q7tMBtO/Pm8PNDDj4izzND8mSYxXeBY3VUaYYTdneIJXSbDAIQ7zMs/zCs9aHxDAU+sHsHnZy11xLt3d3Tz88MMmlZdishrZ+psuRNiYERCDSxIvmheQI5AzqNfrpkQhppp2y9jRpHovzaUyGTtbOsOeafH5fESjUcApVan8IAeTyWSMsbR3zijqVf+nt7fXGBU1bCuVCsFg0AzHwcamTkmAqCyzVenINuwyj8pHg4ODPPXUU2bYVvfT7XYPRfpcmnuan5831HaxDlXy1KySGt/gzGOtra0RDAbZv38/sVjMZC96XbucqnXWgq0tpt9tI60+nu63trZmViuo/GrPfal/2NXVRSQSMb2daDRKLpcjlUqZ3kwkEjGkGD2vynbqRel4bMrz1nIi18Kj8PVt+L+0wlD0SsstleCUkcLRDPnnFkg+FSP1JwPw/fUbizhZyjHAY30mkoABh657xM8XD/4lnz39bdY8a7wJHAY6T8N/9d/D0CdmnXLYLaCEj1mGWB6Js+/Jc055zObnVHCozD0Q+9VkS9XlOMtM8g4n2csIM3yMH/JDPmbe99P8mEMcJkwG9zp1O77OSy7jdZztEk45MLu57uCuOBddOIFAwOzh8Hq9ZgeFrdukKeneXift8/v9ZgZF2UKzA7CVdmu1GgsLC5w4cYJIJMKuXbuMoYYNVVu7/2I3SlVGU1nDvjBlFMQ+splqGvhbXl42JT7YmPGwacoqxansJtaYImw1n4vFIplMxpAWFBFvFQejqNn+DG2nbUfVchxyrio32kGAykkul8t8Xlp3YKsgi+qu11EAIsYfOGshTp48yY4dO/D7/Q1kDsAw0BQc2OeZzj3buDfrv0lhWxmTZp9swoDup/cmYoI+O3sNtPTSRBaw56GaGYq2U7m/EIaHYGd0mkFmGecU04xeU04/QB6vr0TqqQHnD0dxGv1FrpptaYkj8Gn3d3nlyZ/jD34KH8UhnLEMwb+uEfjs+9t5X8LHykN+Z7Ayh+NQJLdfAc7D8PkVkjuv7r8oO1FmEiPJGGd4jpcJUGCck6ZU1owKbseBXgKyy0Dmlo/9ergjzuVnf/Zn2b59u7kIVSePRqP09fUZmY9isWik8cWOsjOLgYEBVlZWzAyKhscksyFD3dXVZZhi0puampoy5IG+vj5jyGyRyua5CNiY2JdBB4dGrPq2oliV0xTx6uJeXl42pRVFp3ImoVCoYT9LMBgkkVhPmS0FXs0/SMpDA5ypVIqZmZktteq4ec4FHAfz/PPPMzo6avoQkUjENOY1/S6jbTselaIU9Q8PDxOLxVhcXDTBh8pkcirVatWcgxp2TKfTXLhwgWPHjpHL5UxTvVKpNBhwla/s92JPxC8tLZn3oPMSNlZa25mxiAPKpHXO2sGLWIfqwSjbt5W7da7ZKwkUcLlcLubn581aiq2NL8FT2zas1gPAQ8416aPMAd4iTIYZRtjNGTKEuULj9LyHKnv2vU1mX5i5N3ZtjHicYYOiK8RwGF3bNm7/u7//SV74yf/Ji7/z953UZSfO8VRubtcKOEOWJZ+XaXYSY5Vd5+ccbvOD8F7/Dh44eAH+TzYczEXg38C+Xz3H20N7GvTDwBny/DTfA5xjmGSKCY6vC/A3HtM0o5xqko1xFJFfwZHi3Dzcdueyf/9+xsfHGRwcNCWJXC5noryVlRWKxSI9PT309vaaMpfWAuvCBhrul0qlTCQoJyMWlfbAuFwulpaWOHPmjBmOzGazpr9jzy/IIchYiTVmT+JrYE9yIisrK4ZuqohWygHqqUi6QxpgtjPTY+wpcGUqzaUW/c2Onm3jtVVgR8/6Xp977jkefvhhs2Wyq6uroX8gx6Hlbyob2cOwCkAk+6JelYgTmhGSwVW/oquri0wmw6VLl5ifn+fo0aNUq1V2795NLBYzjD3AzGY1919sIw8YjThRg/V33VfEDf1d2Ua1WjWDwsqMBDnF5rKtnJPOIw1a2s/fnC22cjL3flbzD+Bb29jzhbdblr+mGeW7fJpJpniBFxllmgxhs1HSxhSTnGU33Y+9CY85fzufGqV4sKeRPRaDnscvk3DPM5MbIevvg1fgr/7zX+db//t3+PWv/BXEgc/C6f3Xpg5fC2Ey7DoyB98GloE98MCBC85Q5uPAAZySXAVHd+x/g0f6T/P2b17tYGwn0sqpCCcZN5pkVTxOSexSmtsxpX/bnYvf7ycUChGNRo3gol1mEuOqXq+bJrpKBXbZAzDGQ9pkuVzO9FJU8rAdUqlUMn2WmZkZABP5S+ZfeztseRg787AjRjkjrWbWbIXej9g7mqOxt26KpmxHnIId1dqwjYPeu7YoZrNZ5ubmzNbFrQK7ea/3rYVqityV6QHGeSqblXNXRgcbpUtbkFTUYDl8UcB1bohp2NHRYQZWS6USCwsLTE9PmxKUSCbKaG1HYb8flW+j0ahRvtYx2qVbsRvtEqo9yKvHqD9kl+AU8NhBid4/YN639gwpk0qlUjfMWm7U6L/rGNvJti+cxkeZSaaMtL4N/T7GGY6yv+XTVNZNbzN2RqfhuelrvvxIcIbzX3RTLPbAEfjH/HPHubwE6cnOW3Is6s0kmHd6PcvrN5xe//EAX4b3HtrB+P4LuCpwun8be4KXuN5M5c1gnJNMcJwjPMbi4e3r8i+H2exFYXAHnIuMNGDKQooEZfgLhQKFQsEwr9TLsC9gZTPgGBpJ88ugi6YpA2PPqeiilIqwiAAqcdgsHh2zvaMFuCoLUaakx+rYdD/1lNSgBxqEBe1SnH7s4T29b/t3W4ZehmkrQ+9ZGYhWG9sK1PZ3aUuqNDepYUPSRc5YWalKjH6/32iYAYbSGwgEGB4eJpvNsri4yMrKCslkkkQi0fB9yeDreZVZ6DwAGphlcp62g1GmIZo5bHzPdrbS6vxo/uz0+dmflXpICnx0PPZ72OrYzRkWSBhn4qVMmAxlvJxl91VO51bQRZ7w+oCLLX7ppcxE9DhvPvUUHIW5P9jFa//kER5/6e339TpuKnSR5xoEN9PYf6tnY47mzSevnqm5VYwyzW7OOFsoj3G7lF+AO+BcJNGRSCSIx+PGEYjuKZkLbQQUg0uDijISLpfLOB7tfnG73UZZWKuA1ThV5Kipec06qKGqix4wZTDAGAJbvFDLofR6ksMHzMUt41AqlUxGZCvqynDYk9+2gbCpqTZBQcymUqlkGte5XI5IJGIMyVaD3cyvVqsNrCabri3lATXWlWHYZURBmUhzyUrGWr22cDhsehzq1ymz0XZRZb/QOFNjl77s2yRoqSzY/s7siX+byajs2+7f2ESA5pKW/tYchMhhqSIAmOfU8d2oob8lnM40XDo7Rmz3EcCZ5+giT4EACeZ5glfJE+DHPH3dYcIb4QBHeYJXAWfI8C32s0CCUaYJkCf2ZJI3Dh6kWnGzm7M3/bwOW6ti5mESLNDz74qtl4RVgCOw+6ELTEU/uEMByNPFMr1UcW98Pr3wAT6qG+K2O5eZmRkSiQQjIyMmYlMDVfVoNVYXFxdNSUDMMTW9AdNn0LBkvV43de1YLGbq4XYpRBe8mu4aUJQj0EUuWQ97EZedoWjZlEoOdrQKG/V0NZo1tGYbI/sit39a6Z7JyaXTaa5cuWI+D713zS7ci7gVY+VyuZiammL79u309fXR399PIBAwZSrpdalHIpacylCAIUhoer7ZCSiTUYAgwVMFHnLSdpbS29tLMBhskAmyDb1t2FdWVshms0QiEaOabDsXm2XYnEE0Z+fNTqXVj+2oCoUCKysrrK6umsBMj2/1WV/ru7mnS2IAlb+Er3+e6r90rzfvj5IkxhEeI0mMJeIc5A28lHiFjxlZfhtxlnFTbamavEQv1aob3Bv9iwB5DnCUGEkSzOOmylf5Oolcios9ffQdzsKDkHffmCE2mrpE5wK8vSdMggUG/joFf0cj9bjh/d7Kh3N95OnidQ5xmEPkCawrSFccokIRbkdJDO6Ac0mlUmY3ivS7IpGISduz2axRPNaF2NnZabYyBoNBo0PmcrnMsifROMWQUcPWnq5Xc1gChmr0a1BNGYOyDGUfKqNpp4bdE5EUhx096jFyhrb+lD1gZ6O5rNGc0YATqWopWC6XM3pUUs5dWGi1wm5rwM7oZmZmWF5eNt9pKBQCMAwvt9ttnEsrwoOGDD0ejzk/9DjYYPwtLy8bqXoNFyYSCSNGKqq6nLdKrrYGndCcOWgWRc9t04CVwSqT0vdoT+LrfNT9ruVk7JKhrgMtGCuXy6YXCZjrovnz3po4YVR+bfrtDCNMM8qrPEEvy3yMV1ggwY95+qpnmOA4Xkr8rVnmsoHFd7fDErz1zH7OW1TmnUzzGb5thhYHDqcgB76fKTN3KEoJL9mb6Ld0poEF8OypMnA05aw2vpa8jAd4HM5Gd9zweW8GCyR4lSc4ybjpN1XxOFTso/NsWVVkwOynkByGaKAqJaj0pSZsrVZrkFHRJH8ulzPG3b7IJJevaFYGQQ5AF7xuU8/H7pfY92/+UcnKbvbbDkDPqya+om69Xztr0uu2ciqtXlvZVD6fN0ygarVq+lNbHXLM6XSapaUlBgcHG5Z9Sf5G35vdENf3rkn97u5uLl26xMLCwlWN8HK5bDaV2vIuivRV7pSUkBr5NjsLNsgDzb0OyfHofFK2pFKdTeSwZ2s0ya/zx943ZEN/0/kAmPNSjlPDotqCqfvapJhm3PMZi42frHHi8KOcPfQqk7zDELM8wavsXh+3H2KWMBn28xZeSmQIc4pxUwYKk2Gck5xivEFoEnAMfXJjV4rg9HKc72uEGafh/gAtWWg3xEXYFz3nNNFbOZbtOHtmPFDcD3kC6+9hL17KjHPSkWy5RZTwkiHMTGmE1NH1LZvrpTeHh3x77MgdcS6nT59m586dZke5BAR1YquUIHFBGQLpJAUCAUMbleEGGkogc3NzJJNJM5gZCATMRb66umqm30UGkBNTBKhoU3MCymgAY9jtXo0iS23FlFxIuVwmnU6TSqWMHL4UB1SWkZGxeyzqPYiyLEl13a6Jazkc7em4F3Er0bGM8EsvvcTw8DCJRMJInYTDYbPvRlmqBEDr9bqZ51BvLRgMEolEzBZPu2xmO/RmRe1cLsfs7CzpdJpt27Y1EAXsBrv6InbWYD+PDLo+Azk3sRB1rICZv0omk7hcLkOxl8aZrX9nZ0jJZNKscrZLudlslvn5+fuG7NEa/xy+8U+Y+vNJ9q/3Rj7BS1RxM8MIx5lgngTjnOQL/BkzjJAk1tCDmWSK40xc5Vw6x9KsDXRd85VnGOEsu/nlPd+/5n1uiGM4xKxWJa/twK/Cezt3UMVNngBTTHKcCd5iPwEKZn5lguPXfZmT7OUU43SRb7hv6tiAI36sbZQvw+2Q2hfuiHOpVqtcvnyZ2dlZEomEKV3Zab6MgwyC5g9kRLu7u40MuT0oJsOt7MS+wGWwtVZY0W8gEDDaUPYxSFrDLnsBJrqVIKEasmIuiSQg2Rcd9+LiIvV6ne7ubrMGwBYqhI2mtmY4Ll26REeHs/tDDsuOvldWVshkMszPb/7O6zuJ5sZ7R0cHc3Nz9Pf3m3knrVtQY1/rDVQatBvWykQkA7OysmKyQntQtVm8sVarGV0yiZBqmt8enpRTt2notgG36fIqh6nMCo1Z8traGktLSywuLppFcXZfUPe3f0QUWF1dZWZmhnq9Tk9PT8MKZB2f2+2mUChw7ty5q5zj1sYa/EWe17/yDPufPMoo5xniCrMM8RKfIEmMyfWdwl7KLaN8DRmeZLxhkn8sfoYWbRqDaUb5M36NI4cO8nulf8pY9UzLLZTOa1R4eOU0rhPWH8/jTN83qzDbOA0PXLzgWOU4vPzA8/w1P29uPstuynhv6FyOM8Ff8YIRrPRRdhxsZf31tWQs+1c4cgC3B3dM/uXdd9/lwIEDpslpR5Jer5dwOGwiUpWaarWaoSlrqlqsHrHB7D6ELS+u59F0vWRSstmscWI2u0iDmPaaYhkCO0PSDIYiUsAMM+rilgyHymI6BkXDNrPJzlzEmJNRFFXVppNWKpUt71hawe1284Mf/IDt27eTTqeJx+Omh1Eul80sjJiG2g0vyJDbunT6/vSdyUEo+LADCNjozWSz2atKmcpaCoWCkeBRZmKXNG1nYjMQdR4p+5Qjs2+3zxmVimFjgFLnl02D13CpyCQaUNaCPh3LjXDPz7kY/C/wrd/h+JMTHOQIQ1xhgX7OM8ohXudT65PqZbxGhbgZExxnnJPM008ZX8u5l1ao4Oav+Xn+H77/L/uOnsO9v3LVMKOPEl3kcf0ER4zyZnFx/UcYgpHfm7nqbqJHB8i3HJSs4jZlvAIBXufQxo1+Nix+dh7WHfHtwh3VFltYWCCZTNLT00MoFDIntBhbtVrNbNPTumO/329YYF6vl76+PtO41U4O1eDtC9zue9gsLOlz2RPe2u+hcpvd62gWMLTFC1tNQTfDdkpin0nCwx4alRQIYFhppVLJ9BnsPR73E+wMzu12m1XGKmtJNl+aczpHlpaWyGQyJoPV9+H3++nt7cXn8xkFaduZ6H6wQTtX9uPxeEwQYC+BA8fA53K5hk2Pds9MsM8H+1+dTyrLAQ2U50qlQiqVYm1tzeikKQiymWE6PpEIRG+Xzph6P7azuF7GsnWcioVLjqR8ngBV3IwyzQu8SGK96V7Gy6s8wVscYKGF2KObKh/lMDGSTDHJDCNGAr9wE9pgbqpwBHZOTl+VvYyWpp1lYAs4xvx6mcr1kKAlpfo4E+QJMMkU45wkTKYhQzvOBFNMtnzKnocus/LUMPwFbLbUSyvcMedSq9U4deoUw8PDV6m56sJzu90Ui0VT+lG2IoaQBCxjsZhpwFYqFdxut6FiqoEJGxe0yhSA0eQSpVeNWz2/NghqDsI2HqJJi+UjWRifz2eeR87EpqBKxFJZm9frZWBgwOyY0XGrpKfeTzabNU5YpR/V2+836Ps5e/YsfX19xONx03DX8KiCBDkIRfzqR6mvpkn/YDBomua2w7apyAoW5NyUKdklL32fOq/sXo+cic0+tOeZ7MxUz6WybvOgqCjFUtwWk01OUD1IW/LHVolQpqJtmK2yqGY0O8F739EU4PvnOfY/foSX/tEMAfLEWTaOJUmMAHlWiTHLYIOQZJIYGcLESDLOKUaYYe96g18T9q/yhDHqXsrESDZI+Y8ww2juApyGyOwazbyAjC9McE8KfDgM31ZzLDfCg/DmbzzIyzxHCR95ughQwEeJGUYMQ+44E3yMHzbM2+h2G3kClPDida+/j1cAfvo+DuzWcMecS71e58KFCxw5coS+vj6TrahXooVhGnaTowFMuUjS9eqZ2Mu87Jq2GuwyyDIMmuAW9VjGSRef5ip0sdoT1vZ8hab7s9kspVLJHIctpKkfycWI8aUo024G24ObzQ1jPYf0r1ZXV+/UV3ZHoQDg6NGjAGadgQy1shgtxpLKtCL4paUls3HSlt8JBoPGcdvrqr1eL7FYzHy3UlOWRIz93esHMBmmzlvYiP71nWnGSe9LTkZlTYmgKltWAKXvWz0mne86DrtEqzKpgjFlfPPz8ywvLzc4llaftdCcuWyNvsyfwVe/zN8c/CWqz7idSfd1THBivex1iiFmeZUnmWKSMl6OM8FR9vOsY13XVYNPMcQVR34ehx2myD9GkkMcppdl3uAgMZL8Pv8t/j8GhqDY03xc6yyyfhy6cSvOzSSOGOZ1KnE/Ofgo/4x/wjSjLJfipI4O0HfoIj7Lyc0wQp4AB3jrhp/WfKqf4mvrumnfAPgTbuto/jruaFmsUqlw4cIFpqeniUajBAIBU3rSsOPo6KhhDElsUhekshDYWB2s3+PxuJFc17yJ+jCFQsFMQ8spdXV1mWNSDX9hYYFCoWAIB4pGxV5bWVnB5XKZORnVt9U7sae+ZSg6OztNua1cLhMIBBp2p8v4NEuZwMZedJXtFhcX79RXdVegaH96epqVlRXDnFIG6Ha7icfjbN++nXg8TmdnpzGu6qvJCSiYsPfVd3V1Naw+0ErjQqFAR4ezREz3FVOwORu1WYVyRuB8j+Vy2ezxsZ2KLWxqOycFM3b/rvnzsGnPdpakYEREEGnMLS0tNYijtkKzA7meI7o3sQa8Dmd+jplnGqP0KwwxxSSf5rsc5A3AMcQL9JMkxmqLUlPYkpp/lld4zOHo4lnff+KlzBnGGOMsj/6LEw4d+e/DdLD1HMrA0RT8O1rSjdNf7uS33P/iuu9uhhGj5lwqemEOyiUvvE9BjmI24DTwp4H34E44FrgL+1zK5TJzc3P09PQYGRdlGYrGbOkXOSBbyBIaF0cpm1C5SuUUl8tl9KrkVMQ402CcHEMmk2FlZcVQomX8ZUhsFppKb3KMasKqKVsoFIykidhKquOHw2FTErQzJ9igvQINpT2VfO5n2NPj9XrdMLi088beo6KSpr4j7VrR+WTTg/Xc0quznYb+HovFzHln70nR96HXLJVKZgGd1CXkRJShplKpBn07OQRluza13J67UXNeQq+atZEz0+eioEf045WVFXOuSYpfx3x/Yx5ehPMvjDqik+vIEGaEGULry7FGmOFpfmTWAO+8gWENk2lwNsI4J50lWw8Ce6D4EC13t8wwQmZ/mMn977R8/j/jC41N9usgT4Diez3wHqQYIPN4mN2JM3iospuzTHCceMv0yEEJH+cu7IXXOp1xlqMArY/rduCOO5d8Ps/U1BSZTIZ4PM7OnTvZs2ePqbN3dnaSz+eNsVDpAjCGQaUBDbjBRiYjh6Hyxvbt2w1NtZkhZjeT8/k8yWSSfD5vLnK7jJFOp0mn08bIgVPbVnlEqr0S4Jyfnzdqzz6fz8z29PT0mIxL6wb8fr8p2Xm93qsG34rFoqGf3u+o1Zy99ocPH6ZarRKJRIhGo6ZPJwZdNpulq6uL3t5e+vsdOQ8FDTLidq/BXtYFjRmj3QO0AxMFKyp5pdNp870qk7G/k7W1NRYWFsz3bbPCpMqs/try8rLJuFQqVWk4EokYGno2mzWzT+Vy2Zx/hUKBhYUFlpeXTUB0+vRpmnH/Oplp+MG/p/jUxznxmR74ddgz/jYTHOczfIchrnCSvfSyzC9YtK2b3bnSjOd5GTdV3v3ZXQCGANCMKSb5Hp+65uvkCXByfhyvv2Sc4nw1QXIpxmhi2pS+Svi48PYDTvN9GpiD2mgQErCXk3yW7zDOSfIEOMxHjfM8zoRhv+Xpgu93OvMs08Cx08DfvK/3/35wx51LvV5naWnJTGPLAagckcvlzGBZPB43opPKTHK5nMkGmqNU22koKpWOmC3HogtU0WtHRwehUIhAIEAymTTDj2rQKqtJp9NmfYAasOVy2fSK7CxItfdIJGIcp3aMSDJ/eXmZer1u/q6SnCi46gdcvny5gXZ7v8F2AjL6586d4/Tp00xOTvLoo48aVQev12uyms7OTgYHB4nH48ax2GxB27DagQhsGF05Exlzu8yl88XOqL1eL0tLS1y+fNn0RmyDr78pY1Y/R0vwAFOuVWbb1dWF1+s1MzodHR2kUilKpZJxLjY7TeU0rfx2u92cP3/eUJJvdaZl687A/BSO/RSOPQhnPk/hzwNm18tR9vNjnibOMvt5i0mmCHyASXQxspo3QTZjN2cYZJYpHubcu/tazygehaInyImH1ps2l4AlOPfAPodhJmjYcQB4AXY88h4THOcF/ooyXr7Lp8kQ4igHrtJSq+B2lqG9h+NYjl4CvsftmsZvhbuy5li4cuUKs7OzJmNQf2R1dbWBKaQyiD0nYJcAAFN6UhnCpoS6XC5T67Zl+O0yizTMPB5Pg6qtLnANYqrxq+hTJZJQKGTIBtqD7vV6iUQidHd3m9KLKNQSwNR6Z/Vv7F7P2toaly9fvu9LYoK+C5tyffToUfr6+hgaGjKGWlpacgpi3alcpPKl+hgaULS3PNrORT/qhTRL/Oi5Y7EYvb29XLp0yUzY6zlsORjAUOntPT4q7YqQIocWCAQIh8NGQ69YLJr+n5hpynjEjtP6CMCcI++XVrw1HYuNE/AKZEphTvrGmWKSZeIcZwJw5E/GOWWcSxmvyTw8VPFSNtH+jTKbKm5K681/G3qecU4xwQmOcsDpc/yAa4tQvtb0+xHr/73Ar+DsUa44S8viLDHGWUaY4UU+11IjzdlX43EICq+x4Vxuw6bJG+GuOheAxcVFpqen6e3tbZiEVolLGYmkL5aWlqjVasRiMSKRiGmYikUEVzcoNdmuffa2I9Lmys7OTnp7e00NXA5Ge+olO6LSierqtVrN1OG7u7vp7u4mFAoZZyPFZ7GadF8JeYr+qqlvn89npsAl5ni/wzZutnEUY+vKlStcvnzZEDFUbtSckox4Nps1mWetViMcDhuSh9frpb+/32QPCkx0HhSLRVZXV1ldXb1qJUMgEDAbIvv6+hgeHmZpackEHyq76pwVZV2Oyh6S1HmWSCSM05DTk2acemx6nwqO9N5shyVH2kwG+dBh7iekfvcpvP9TmSkmTT/ETbUhY5FC8Bmc+ZQ4SzzMlKEfP7ZOArgWppjkCAev+vsIM0zyDjGSHOAtzrKbC5/cDXPr/Y4ijpOxBxlhY2K+2QE9Dv7HVyg+EIaKh0n3FE/zIwoE+DN+rUFdwMbpCxOw1AlzwPeBl9dwaMd3XuT2rjuXixcvmqHE8fFxIpGIqT/bchgrKyucP3/elEOkI6aygu007AhOg5Ozs7NcunQJ2JDoUBM1FosxMDBALBZj586dRi5EWYqGN7u7u82FnsvlCAaDLCwsmOVSagR3d3ebKFW9GOmNqQYvwyUGUjqdNlI3GhLcyqrH7xfN5TGXy8Xx48dNmTOVShkGmJyNvuNUKsXFixdZXl6mWq2aUmetVjMlVp0j9muoNzI/P8/MzIyRULF7ffF43Ihq7tmzh3q9TiwWI5lMmgxChAI5p1wux8rKiumt6Hk1xyJ5G527CjDs+Sr9q4xe6t9iiInBqB7kh6Ev1xovwzcqLBaf5W++vJ2OgRwjCU19zJhZlaMc4Lt82sjuh8lwYn0wcYLj7OfoNbOXDGGmmOQVnr3qtjjLTDHJE7zKIQ7zAi/i3lHle1/9FNlLfU55LAnsp9HqzuFkGGdwVg5X1m9/YH07psPIJ8E8HqocZ+KajiVDGH7QCd/BSVSKr+DIu9wdRY+77lwApqenyefznD59mn379jE6Ompoporg5ufnWVxcNM32er1OOp2mo6PD6HXZ8hvQuHNDA2h2SUzGQyWp7du3E41GTfbkdrtNyUUKvWtra6yurhrmmkovy8vLhjkmho/KcC6Xyyga2zV8GUWxjM6fP2/k9D/ssMuWHR0dHD9+3DSuH374YXp7e80sjOahMpmM6WVoJsRWObAdl228lVmo5FQqlRpKrDL2Il309PSwd+9eurq6mJ+fNyUwLYmzZ15CoRBut5vZ2VmT5Ug+RgOSolvbFGdbkFLHtby8zNzcnNEms0kfW3LSftPxCnyzAN98htrBIBf+8AECz+WZZpReluiiwBSTLNCPe51mnKeL40wQI3ld5hXAAv3XVENeJs4ycQLkGecko0zzKb6LN1hianyS2fEhqngY56S5P0B+PMD8/n6Kr/Q4zXvRly/BKjF8lMlUw3jdZWYZuqq3UsLHbGpwnW7sh68C2b/BqYXdXZmoe8K5gCMNs7S0RDqdNuwZRZ3gqMhWq1XDINNcgcfjobu722QvzTV72JgXaB4Wc7vdRlZjeXmZSCRi9Mv6+/uN8Vd209HRYfoskpURdVUDlclk0sxPZDIZM7RpH4Mcm2r8uVyO06dP35eaYR8EzQ35M2fOGH24Q4cO0dPTQzweNyVGDSXaw49ut5tgMNiwdE5lKztzAa7a22KvwFYgo+w0EAgQj8dN5tFMStBjpZlnU9sXFxcJBoNEo1EqlUqDXpo915LNZllYWDB/P3funCG72FlK27HYOOz8HHkUvvFpzh8cpSua5wy78VA15a8AefbzFtPs5Cy72c1ZDvDWdXsu/SwwxOw15VXAKZtNcJxneYUxzlLgx1xhyMjKSFhT2U+APDuj05wY7dmwxhXgNZg7uIvo6BypIwPwOCTcV9uH5VKc4l84dGW+A2T/hDs1x3Ij3DPOBRwnsLS0xJUrV0gkEoZxo8hfjB1Foqq7qxHfXFIR7ItREahtuEQhlmCiZg2U9ai/kslkjBNppkKrXCZhTAlRitnWrEGmyFQMo5WV27MN7m7gdrCP9Hm7XC5TEkqlUiwvLxtnrka8pHhEYdZ+GLvp3moy3T5mOwtW/0REAk3+i8GmCXstmBO7CzCSQurVqb+2uLhoshQpRtiqDXbGrcwsm8027B3aesOPdxJn4GUoTvdQeCTQoBnmXp8TOcBREiwwwgzjnCRG8rrPGCZDqMUMjI0MYd5hkr2cZIgrZufM/LrG2STvMM3Oqx7XuS3N2gORjSb/NPANSBUH4D1YeWiYlYPDZt+LwXvAH7G+SO0d4PJ1j+9O4p5yLuBszztx4oS5WBOJhCk9qaadz+dNHVwRqQy2MgLVtgEzAa0L1m7oy9jncjkWFhaIRCIkEgnTvNdjVlZWzFyBaudyKHoeOZQzZ87w5ptvGocyOjraoCYgw7a4uGjoyLZe1FbHZjmWVhRlyQIdO3bMDFhKnaFaddZRq0QVCoWMFp1k6NVwFwNMQYmdwdgswube3fLysjnnRNgQy089kOZdKs0ZmMvl4tKlS5w7d84EKOPj4ybDtTEzM8Pi4qJp+Dcf0/U+661LMd4MpKH4Xfj1T3Pitx9l4D87R7flPNxUmWGEGEk+zXfNJP5mYIpJHmaKIa7QzwKf4CXDTpMuWDN8/hJrIRyLXMRxMslXMEOPr3XCH08CT139PlEZrIKjXnBv4J5zLvV6neXlZX70ox8xNzfHjh07CIfD9Pf3Mzo6ahhBovqKMSNmjmYA/H4/Q0NDJvuxZxFqtVrDWmMZ9+XlZUMR1UpdRZtiBikTsXfAlEolcyy5XI433nijIZp87733Wl7k7YizNVoZRbsJX6vVuHDhAufOnePgwYPs3buX/v5+0+hX8KDnUclMzXDY2G4ajUaNUbcNuz03BTRQ1FdXV83KbClJ2HRhscc0k2JTnP1+P8VikXfffdeUZgHeeeedBoHLZod0pyjG99c5+SYcm4IvfZK5bz7G3PPAV4o8OHycN3iMo+w3/REvZc6ym3eaSl69LDPJ1A2zGhtlfLzDJLvXacNeo1wGpxhvWVbLnulzJui1ITL5Xef4GzDP+oavLYF7zrkI9XqdkydPcvLkSR599FG8Xq+R4ne5NnShRN3UDIqci8oW9sItwESZYgPZUv3qk+TzecLhsDEa0DhspwawSAJyLpVKhSNHjlzz/dzv2KwouXkW5Vr38Xg8vPXWW7z++ut88pOfNMGENMmU/aoXNjs7a7IXu48GG7tdVCJtHqxsZm3Z5TD78fauIrv0qfksgGPHjpnM186Wmt+7/qb73Ki30vwcbYATyX8PjnwPjvwDeGAn+X8QIECeKm4quM3ul+NM8B0+27DfZTdnGWL2Kudiz8k0o4qbE0xwkDec1cgW3FRxU214jQruxkVeS/Nc7Vi2Hu5Z52JjcXHR9D1KpRJ9fX0ARnK/UCiYiXYZE3BIAJp1kMQ6bGiDyXnYzkU9EM1G6ML2+XwmC9LraXGUDI5q423cPrQywl6vl5WVFdNAj8VixGIxisUiyWTSZJSaL1JGU6vVDNPQPj+SySS1Wo1IJGIo8SrJKYDROgR7m6nk/sUUVLCiuRtRnpt7dbYzaHYuzaXB5vvZeL9O5cMQ+Dj4KXxxJxeSD+D/4gq90WUWSPBdPk2YDDOMXLU4bJk4RzhImAz9LBCggJsqJy47A5rbhmfoIt/SyeTpooq7gSQwyRTTjHKEg2aYc3p5p5OQvAwsnQdev42fwZ3DlnAuMzMzzMzMsLS0xPbt23n88cfNZLvYNfrRBVkqlVhaWjIT3JJpX11dNYOSmpFQxCoqcTKZJBKJGGeiQTVtvMzn80alWPMoly9fvqpe/mHDnajxt4reOzo6OHbsGLWas7I4HA4zOTlpGIUaklQAonNEe30ABgYGjKhoR0cHV65cIZ1OMzg4SCQSaZhL0nCtFneJ8qxenLLiTCbD3Nwc6XSaZDLJuXPnWr6HZgdi396KeNDG+8UZ4Gvw279E8Q8f5tLXeqj8hrvlUi4hSYwf8zQAH+OHTPIOk0xy3DNB7ZUglzx76PnM5auYXHkCTPEwY5xldJ29pZ0x+znKPAnOspsruSHW/ijiSOEn/waH7XZ/YEs4F2F6epq5uTkjpd7d3W1mC2znon6IGrC1Wo1AIEA0GiUSiRjBSUWQNitMul75fN7I8qfTaSPHUSwWzcDj+fPnzY6VD7tjgTtn+Fq9jj7/I0eOmEFGZSLqu0Bj/6JWqxkxUmWmoi3rtlgsRjAYBDYMv84PZScqz66urhrJllKpRDqd5tKlS1y5coX5+fmGrORWNMCudZ92Gez94t/A3N/Al3+Huf276D50/RKUHEyMJM/zMiPM0J+YZ25uF8xB5tkwiXijc6niZoaRBsd1ir28zPNUcZt5leyZPvh9oPIt4MImv8+7iy3lXMAZaDt79ix79+41Io+qr6v+rcaqZgfEJJNT6uzsNEKWmj+QfplEBMXO0YzD0tKSMRyrq6ssLi5y5coVoy/Vxp2HHeXb1N9arcb58+cZHx83jXd7pUPzIK0tIup2uwmFQiYI0QClSByiw6ucpmZ9JpNhYWHBbL1cXV011OW5uTmgMQvZjFLUZs23NGdNHw4UgL+Bv/g5lg710sv1r+MkMaaYJIYz4DzELHMP7YIQrCXDlOK+hmVebqoNvRppnUm1uIKb05fHnb1dlZ/QWuFya2PLOReAubk5fvzjH7Nv3z62bdtGX18fwWDQOBtlICpNSKKju7vbDMCpBKZ6e2dnJ+Fw2GiDAaRSKbNEbG5uzqggLywscO7cOSPX0sbdQavGvwzk6uoqb7/9NtVqld7eXrP62J68l7ORrpici8/no7+/3zAFRfAAh2UWCATMniE5IJVGpQ6QyWS4cOFCw4K3axlx+/dbNe6bSfv+8OEd+MYDLF7ayeKXtrPrE+82OIhmnGQvM4wwwgwJFtj23GkunR2DMy4yu8MNj9WQZpgMR9lvNMmmc6Nkj/U5jLBvAsfe4E6sHL4bcNVv8qy61yIaSXGMjY2xY8cOwxRS3VxMIQ2h+f1+4nEnFZVk+8LCgpm0ljJtMBg0j7VXx547d47Lly+TTqeZnp42A3tbDbfTiMgp361zpTmSV0b72GOPsWvXLlPe6urqIhKJ4PP5DDnD5XKZ80fZzOzsLHNzcwQCAQYHB02PThRmETny+TzLy8tcvnzZLIs7fvy4yY7hxnvs7+b11XxOSCvtdsDl+tpte+73h04gDHwRfiUCIRxxyS/Bg4+0LpepQV/Fzcn5cWrfCcLjsOuRDefkpcxBjhAjyVvsZ5le3n7jcfgK64OSh3Gcyp1VKt4s1Otfu+F9tqxzERR9ijX05JNPMjAwYBaPqS6uqWrNK4ia2tHRYe4vaqki0mQySTqdZm5ujp/+9Kdm0HErR3n3s3NpRjPbam1tjUgkwsc//nHi8Th9fX1mQHZtbY1oNEoikTDEjfn5ec6fP0+pVGJwcJCRkRGzewcwQpm5XI5MJsNPfvITQ0vfav0Q+7z4cDkXG53r/4aB34LfBr5aJNqbJPXagEMT3u/MyQgn58epfd0JWviSs7DMZo6dT41S/ENLnoX/D1vVodi4GeeyJctiNmypl0KhwMsvv0wikeDv/b2/RygUMhe32EJimaXTabLZrBEOBEfAUg39lZUVfvrTnxqGTxtbB7ahtBv4+u7/7b/9t/T39/Pxj38cl8vF4uKi0Xjr7OwkEokYOrEy2FQqRXd3d8NrLC0tcfjwYU6fPm3Kser7XW/w8V50PG19MtiYbl8Bvgbf+Dl46BCphwbgj3EUjL/kp/T5jYVhtco6dfkY8DIkx7txW/r5xVd64A9PA396R97BvYQt71xaIZfLcerUKTOjILFBn89nmEPFYtE4F62MtcUFtemvja2Ha+mGNSsyXLx4EcAM3apPov5KPp832aoESzXzIq2xVCplzhvYWOdwI8dxLzkW2NrZ+O3DO/ClQ06ZrDgPJGAAzk3v27hLEsexvAb8ABa/vr3Rqp6B+4lefCvY8mWxm8Hg4GCDAbBnW2q1mtn/8WHAh6ks1gw7y23+/86dO032YcsKieJ+4cKFBv03nUNyXK1WKG+1+RQd74e3LHYjjAIP0jomn8apfd072l63Ex+KstjN4MqVK3f7ED5UuNsN6ma0MvJ22aparTI9PQ00Sq3ofvq9Wea+eW6lGffSZ3CzaGcw18M094qc/VbAh8K5tHFnca8Z1etNv0PjymM7o7mWw2glQfNBcK854zba2Ay0nUsbWwYf1AhfyxnY2Yn+vV4EvxmOoNnRtdHG/Ya2c2ljy+BORvfNr3WzO1Ru5fnbjqWN+xkdN75LG218ONDK2Ntlsuv97YO81t0uibWdXBu3A23n0sam4l4wVLfzGOyh3TbaaOPaaJfF2thU3AtG94Mcw73gHNto435A27m0senYyuynu7k24G6g+bu6V46rja2PdlmsjU1F8xKszX7u5p/3+/hbfZz97wfFZn1Gm3k87Yytjc1GO3NpY9MgOftWmxbh+lHx+zVurR7X6nVaNeXfz/1v5jhv9fVv9b0374VpxWy72QzkWt9VG218ULSdSxubBulqQeMOeBvXMnyt9ps0P9et4lYes5lGtdlxvV/ncT0HcaPtlM1/u5n7t4kKbWwm2s6ljU1DIBAw2zrhaodxs2g17Ph+jN6tPOaDRP83etyNMrbNlI651edqpTjQRhubgXbPpY1Ng/aY1Gq1q7KWzZJKuVPYTON+O15ns6DvqKOjg87OTrNQr402PihuWhW5jTbaaKONNm4W7cyljTbaaKONTUfbubTRRhtttLHpaDuXNtpoo402Nh1t59JGG2200camo+1c2mijjTba2HS0nUsbbbTRRhubjrZzaaONNtpoY9PRdi5ttNFGG21sOtrOpY022mijjU3H/x+wq8qoEtfVrAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "diffusion = diffusion.to(device)\n", + "n_epochs = 200\n", + "val_interval = 40\n", + "epoch_losses = []\n", + "val_losses = []\n", + "scaler = GradScaler()\n", + "\n", + "for epoch in range(n_epochs):\n", + " diffusion.train()\n", + " autoencoder.eval()\n", + " epoch_loss = 0\n", + " progress_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=70)\n", + " progress_bar.set_description(f\"Epoch {epoch}\")\n", + " for step, batch in progress_bar:\n", + " images = batch[\"image\"].to(device)\n", + " labels = one_hot(batch[\"label\"], 6).to(device)\n", + " optimizer.zero_grad(set_to_none=True)\n", + " with autocast(enabled=True):\n", + " z_mu, z_sigma = autoencoder.encode(images)\n", + " z = autoencoder.sampling(z_mu, z_sigma)\n", + " noise = torch.randn_like(z).to(device)\n", + " timesteps = torch.randint(0, inferer.scheduler.num_train_timesteps, (z.shape[0],), device=z.device).long()\n", + " noise_pred = inferer(\n", + " inputs=images, diffusion_model=diffusion, noise=noise, timesteps=timesteps, autoencoder_model=autoencoder,\n", + " seg = labels\n", + " )\n", + " loss = F.mse_loss(noise_pred.float(), noise.float())\n", + "\n", + " scaler.scale(loss).backward()\n", + " scaler.step(optimizer)\n", + " scaler.update()\n", + " epoch_loss += loss.item()\n", + "\n", + " progress_bar.set_postfix({\"loss\": epoch_loss / (step + 1)})\n", + " epoch_losses.append(epoch_loss / (step + 1))\n", + "\n", + " if (epoch + 1) % val_interval == 0:\n", + " diffusion.eval()\n", + " val_loss = 0\n", + " with torch.no_grad():\n", + " for val_step, batch in enumerate(val_loader, start=1):\n", + " images = batch[\"image\"].to(device)\n", + " labels = one_hot(batch[\"label\"], 6).to(device)\n", + " with autocast(enabled=True):\n", + " z_mu, z_sigma = autoencoder.encode(images)\n", + "\n", + " z = autoencoder.sampling(z_mu, z_sigma)\n", + " noise = torch.randn_like(z).to(device)\n", + " timesteps = torch.randint(\n", + " 0, inferer.scheduler.num_train_timesteps, (z.shape[0],), device=z.device\n", + " ).long()\n", + " noise_pred = inferer(\n", + " inputs=images,\n", + " diffusion_model=diffusion,\n", + " noise=noise,\n", + " timesteps=timesteps,\n", + " autoencoder_model=autoencoder,\n", + " seg = labels,\n", + " )\n", + "\n", + " loss = F.mse_loss(noise_pred.float(), noise.float())\n", + "\n", + " val_loss += loss.item()\n", + " val_loss /= val_step\n", + " val_losses.append(val_loss)\n", + " print(f\"Epoch {epoch} val loss: {val_loss:.4f}\")\n", + "\n", + " # Sampling image during training. We use the last segmentation of our loader\n", + " z = torch.randn((labels.shape[0], 8, 16, 16))\n", + " z = z.to(device)\n", + " scheduler.set_timesteps(num_inference_steps=1000)\n", + " with autocast(enabled=True):\n", + " decoded = inferer.sample(\n", + " input_noise=z, diffusion_model=diffusion, scheduler=scheduler, autoencoder_model=autoencoder,\n", + " seg = labels)\n", + " plt.figure(figsize=(5, 3))\n", + " plt.subplot(1, 3, 1)\n", + " plt.imshow(images[0, 0, ...].detach().cpu(), cmap=\"gist_gray\")\n", + " plt.axis(\"off\")\n", + " plt.subplot(1, 3, 2)\n", + " plt.imshow(decoded[0, 0, ...].detach().cpu(), cmap = \"gist_gray\")\n", + " plt.axis('off')\n", + " plt.subplot(1, 3, 3)\n", + " plt.imshow(batch[\"label\"][0, 0, ...].detach().cpu(), cmap=\"jet\")\n", + " plt.axis(\"off\")\n", + " plt.show()\n", + "\n", + "progress_bar.close()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6f62fb1b", + "metadata": { + "lines_to_next_cell": 2 + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "jupytext": { + "formats": "ipynb,py:light" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.16" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/generative/2d_spade_ldm/2d_spade_ldm.py b/tutorials/generative/2d_spade_ldm/2d_spade_ldm.py new file mode 100644 index 00000000..e41c2c35 --- /dev/null +++ b/tutorials/generative/2d_spade_ldm/2d_spade_ldm.py @@ -0,0 +1,462 @@ +# --- +# jupyter: +# jupytext: +# formats: ipynb,py:light +# text_representation: +# extension: .py +# format_name: light +# format_version: '1.5' +# jupytext_version: 1.14.4 +# kernelspec: +# display_name: Python 3 (ipykernel) +# language: python +# name: python3 +# --- + +# + +# Copyright (c) MONAI Consortium +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# http://www.apache.org/licenses/LICENSE-2.0 +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# - + +# # SPADE LDM + +import os +import tempfile +import matplotlib.pyplot as plt +import numpy as np +import torch +from pathlib import Path +import zipfile +import gdown +from monai.data import DataLoader +from tqdm import tqdm +from generative.losses import PatchAdversarialLoss, PerceptualLoss +import numpy as np +import monai +import torch.nn.functional as F +from generative.networks.nets import SPADEAutoencoderKL +from generative.networks.nets import SPADEDiffusionModelUNet +from generative.losses.adversarial_loss import PatchAdversarialLoss +from generative.networks.nets import PatchDiscriminator +from torch.cuda.amp import GradScaler, autocast +from generative.networks.schedulers import DDPMScheduler +from generative.inferers import LatentDiffusionInferer + +# INPUT PARAMETERS +input_shape = [128, 128] +batch_size = 6 +num_workers = 4 + +# ### Data + +# The data for this notebook comes from the public dataset OASIS (Open Access Series of Imaging Studies) [1]. The images have been registered to MNI space using ANTsPy, and then subsampled to 2mm isotropic resolution. Geodesic Information Flows (GIF) [2] has been used to segment 5 regions: cerebrospinal fluid (CSF), grey matter (GM), white matter (WM), deep grey matter (DGM) and brainstem. In addition, BaMos [3] has been used to provide white matter hyperintensities segmentations (WMH). The available dataset contains: +# - T1-weighted images +# - FLAIR weighted images +# - Segmentations with the following labels: 0 (background), 1 (CSF), 2 (GM), 3 (WM), 4 (DGM), 5 (brainstem) and 6 (WMH). +# +# _**Acknowledgments**: "Data were provided by OASIS-3: Longitudinal Multimodal Neuroimaging: Principal Investigators: T. Benzinger, D. Marcus, J. Morris; NIH P30 AG066444, P50 AG00561, P30 NS09857781, P01 AG026276, P01 AG003991, R01 AG043434, UL1 TR000448, R01 EB009352. AV-45 doses were provided by Avid Radiopharmaceuticals, a wholly owned subsidiary of Eli Lilly.”_ +# +# +# Citations: +# +# [1] Marcus, DS, Wang, TH, Parker, J, Csernansky, JG, Morris, JC, Buckner. Open Access Series of Imaging Studies (OASIS): Cross-Sectional MRI Data in Young, Middle Aged, Nondemented, and Demented Older Adults, RL. Journal of Cognitive Neuroscience, 19, 1498-1507. doi: 10.1162/jocn.2007.19.9.1498 +# +# [2] Cardoso MJ, Modat M, Wolz R, Melbourne A, Cash D, Rueckert D, Ourselin S. Geodesic Information Flows: Spatially-Variant Graphs and Their Application to Segmentation and Fusion. IEEE Trans Med Imaging. 2015 Sep;34(9):1976-88. doi: 10.1109/TMI.2015.2418298. Epub 2015 Apr 14. PMID: 25879909. +# +# [3] Fiford CM, Sudre CH, Pemberton H, Walsh P, Manning E, Malone IB, Nicholas J, Bouvy WH, Carmichael OT, Biessels GJ, Cardoso MJ, Barnes J; Alzheimer’s Disease Neuroimaging Initiative. Automated White Matter Hyperintensity Segmentation Using Bayesian Model Selection: Assessment and Correlations with Cognitive Change. Neuroinformatics. 2020 Jun;18(3):429-449. doi: 10.1007/s12021-019-09439-6. PMID: 32062817; PMCID: PMC7338814. +# + +directory = os.environ.get("MONAI_DATA_DIRECTORY") +root_dir = tempfile.mkdtemp() if directory is None else directory +root_dir = Path(root_dir) +print("Temporary directory used: %s " % root_dir) + +gdown.download( + "https://drive.google.com/uc?export=download&id=1SX_MCzQe-vyq09QYxECk32wZ2vxp9rx5", str(root_dir / "data.zip") +) + +zip_obj = zipfile.ZipFile(os.path.join(root_dir, "data.zip"), "r") +zip_obj.extractall(root_dir) +images_T1 = root_dir / "OASIS_SMALL-SUBSET/T1" +images_FLAIR = root_dir / "OASIS_SMALL-SUBSET/FLAIR" +labels = root_dir / "OASIS_SMALL-SUBSET/Segmentations" + +# We create the data dictionaries that we need +all_images = [os.path.join(images_T1, i) for i in os.listdir(images_T1)] +np.random.shuffle(all_images) +corresponding_labels = [ + os.path.join(labels, i.split("/")[-1].replace(i.split("/")[-1].split("_")[0], "Parcellation")) for i in all_images +] +input_dict = [{"image": i, "label": corresponding_labels[ind]} for ind, i in enumerate(all_images)] +input_dict_train = input_dict[: int(len(input_dict) * 0.9)] +input_dict_val = input_dict[int(len(input_dict) * 0.9) :] + +# ### Dataloaders + +# + +preliminar_shape = input_shape + [50] # We take random slices fron the center of the brain +crop_shape = input_shape + [1] +base_transforms = [ + monai.transforms.LoadImaged(keys=["label", "image"]), + monai.transforms.EnsureChannelFirstd(keys=["image", "label"]), + monai.transforms.CenterSpatialCropd(keys=["label", "image"], roi_size=preliminar_shape), + monai.transforms.RandSpatialCropd(keys=["label", "image"], roi_size=crop_shape, max_roi_size=crop_shape), + monai.transforms.SqueezeDimd(keys=["label", "image"], dim=-1), + monai.transforms.Resized(keys=["image", "label"], spatial_size=input_shape), +] +last_transforms = [ + monai.transforms.CopyItemsd(keys=["label"], names=["label_channel"]), + monai.transforms.Lambdad(keys=["label_channel"], func=lambda l: l != 0), + monai.transforms.MaskIntensityd(keys=["image"], mask_key="label_channel"), + monai.transforms.NormalizeIntensityd(keys=["image"]), + monai.transforms.ToTensord(keys=["image", "label"]), +] + +aug_transforms = [ + monai.transforms.RandBiasFieldd(coeff_range=(0, 0.005), prob=0.33, keys=["image"]), + monai.transforms.RandAdjustContrastd(gamma=(0.9, 1.15), prob=0.33, keys=["image"]), + monai.transforms.RandGaussianNoised(prob=0.33, mean=0.0, std=np.random.uniform(0.005, 0.015), keys=["image"]), + monai.transforms.RandAffined( + rotate_range=[-0.05, 0.05], + shear_range=[0.001, 0.05], + scale_range=[0, 0.05], + padding_mode="zeros", + mode="nearest", + prob=0.33, + keys=["label", "image"], + ), +] + +train_transforms = monai.transforms.Compose(base_transforms + aug_transforms + last_transforms) +val_transforms = monai.transforms.Compose(base_transforms + last_transforms) + +train_dataset = monai.data.dataset.Dataset(input_dict_train, train_transforms) +val_dataset = monai.data.dataset.Dataset(input_dict_val, val_transforms) +train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=num_workers) +val_loader = DataLoader(val_dataset, shuffle=False, drop_last=False, batch_size=batch_size, num_workers=num_workers) +# - + +# Sanity check +batch = next(iter(train_loader)) +print(batch["image"].shape) +plt.subplot(1, 2, 1) +plt.imshow(batch["image"][0, 0, ...], cmap="gist_gray") +plt.axis("off") +plt.subplot(1, 2, 2) +plt.imshow(batch["label"][0, 0, ...], cmap="jet") +plt.axis("off") +plt.show() + +# ### Networks creation and losses + +device = "cuda" if torch.cuda.is_available() else "cpu" + + +def one_hot(input_label, label_nc): + # One hot encoding function for the labels + shape_ = list(input_label.shape) + shape_[1] = label_nc + label_out = torch.zeros(shape_) + for channel in range(label_nc): + label_out[:, channel, ...] = input_label[:, 0, ...] == channel + return label_out + + +def picture_results(input_label, input_image, output_image): + f = plt.figure(figsize=(4, 1.5)) + plt.subplot(1, 3, 1) + plt.imshow(torch.argmax(input_label, 1)[0, ...].detach().cpu(), cmap="jet") + plt.axis("off") + plt.title("Label") + plt.subplot(1, 3, 2) + plt.imshow(input_image[0, 0, ...].detach().cpu(), cmap="gist_gray") + plt.axis("off") + plt.title("Input image") + plt.subplot(1, 3, 3) + plt.imshow(output_image[0, 0, ...].detach().cpu(), cmap="gist_gray") + plt.axis("off") + plt.title("Output image") + plt.show() + + +# SPADE Diffusion Models require two components: +# - Autoencoder, incorporating SPADE normalisation in the decoder blocks +# - Diffusion model, operating in the latent space, and incorporating SPADE normalisation in the decoding branch + +autoencoder = SPADEAutoencoderKL( + spatial_dims=2, + in_channels=1, + out_channels=1, + num_res_blocks=(2, 2, 2, 2), + num_channels=(8, 16, 32, 64), + attention_levels=[False, False, False, False], + latent_channels=8, + norm_num_groups=8, + label_nc=6, +) + +diffusion = SPADEDiffusionModelUNet( + spatial_dims=2, + in_channels=8, + out_channels=8, + num_res_blocks=(2, 2, 2, 2), + num_channels=(16, 32, 64, 128), + attention_levels=(False, False, True, True), + norm_num_groups=16, + with_conditioning=False, + label_nc=6, +) + + +# To train the autoencoder, we are using **a Patch-GAN-based adversarial loss**, a **perceptual loss** and a basic **L1 loss** between input and output. + +perceptual_loss = PerceptualLoss(spatial_dims=2, network_type="alex") +perceptual_loss.to(device) + +# + +discriminator = PatchDiscriminator(spatial_dims=2, num_layers_d=3, num_channels=16, in_channels=1, out_channels=1) +discriminator = discriminator.to(device) + +adv_loss = PatchAdversarialLoss(criterion="least_squares") +adv_weight = 0.01 +# - + +recon = torch.nn.L1Loss() + +optimizer_G = torch.optim.Adam(autoencoder.parameters(), lr=0.0002) +optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=0.0004) +# For mixed precision training +scaler_g = torch.cuda.amp.GradScaler() +scaler_d = torch.cuda.amp.GradScaler() + +# ### Training the autoencoder + +# We used the exact same approach as the one from the 2d_ldm_tutorial to train the autoencoder. + +## Loss weights and number of epochs +kl_weight = 1e-6 +n_epochs = 100 +val_interval = 10 +adv_weights = 0.01 +autoencoder_warm_up_n_epochs = 10 +perceptual_weight = 0.001 + +# + +autoencoder.to(device) + +# Loss storage +epoch_recon_losses = [] +epoch_gen_losses = [] +epoch_disc_losses = [] +val_recon_losses = [] + +for epoch in range(n_epochs): + autoencoder.train() + discriminator.train() + epoch_loss = 0 + gen_epoch_loss = 0 + disc_epoch_loss = 0 + progress_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=110) + progress_bar.set_description(f"Epoch {epoch}") + for step, batch in progress_bar: + images = batch["image"].to(device) + labels = one_hot(batch["label"], 6).to(device) + optimizer_G.zero_grad(set_to_none=True) + + with autocast(enabled=True): + reconstruction, z_mu, z_sigma = autoencoder(images, labels) + recons_loss = recon(reconstruction.float(), images.float()) + p_loss = perceptual_loss(reconstruction.float(), images.float()) + kl_loss = 0.5 * torch.sum(z_mu.pow(2) + z_sigma.pow(2) - torch.log(z_sigma.pow(2)) - 1, dim=[1, 2, 3]) + kl_loss = torch.sum(kl_loss) / kl_loss.shape[0] + loss_g = recons_loss + (kl_weight * kl_loss) + (perceptual_weight * p_loss) + + if epoch > autoencoder_warm_up_n_epochs: + logits_fake = discriminator(reconstruction.contiguous().float())[-1] + generator_loss = adv_loss(logits_fake, target_is_real=True, for_discriminator=False) + loss_g += adv_weight * generator_loss + + scaler_g.scale(loss_g).backward() + scaler_g.step(optimizer_G) + scaler_g.update() + + if epoch > autoencoder_warm_up_n_epochs: + with autocast(enabled=True): + optimizer_D.zero_grad(set_to_none=True) + logits_fake = discriminator(reconstruction.contiguous().detach())[-1] + loss_d_fake = adv_loss(logits_fake, target_is_real=False, for_discriminator=True) + logits_real = discriminator(images.contiguous().detach())[-1] + loss_d_real = adv_loss(logits_real, target_is_real=True, for_discriminator=True) + discriminator_loss = (loss_d_fake + loss_d_real) * 0.5 + + loss_d = adv_weight * discriminator_loss + + scaler_d.scale(loss_d).backward() + scaler_d.step(optimizer_D) + scaler_d.update() + + epoch_loss += recons_loss.item() + if epoch > autoencoder_warm_up_n_epochs: + gen_epoch_loss += generator_loss.item() + disc_epoch_loss += discriminator_loss.item() + + progress_bar.set_postfix( + { + "recons_loss": epoch_loss / (step + 1), + "gen_loss": gen_epoch_loss / (step + 1), + "disc_loss": disc_epoch_loss / (step + 1), + } + ) + + epoch_recon_losses.append(epoch_loss / (step + 1)) + epoch_gen_losses.append(gen_epoch_loss / (step + 1)) + epoch_disc_losses.append(disc_epoch_loss / (step + 1)) + + if (epoch + 1) % val_interval == 0: + autoencoder.eval() + val_loss = 0 + with torch.no_grad(): + for val_step, batch in enumerate(val_loader, start=0): + images = batch["image"].to(device) + labels = one_hot(batch["label"], 6).to(device) + with autocast(enabled=True): + reconstruction, z_mu, z_sigma = autoencoder(images, labels) + recons_loss = recon(images.float(), reconstruction.float()) + val_loss += recons_loss.item() + # We retrieve the image to plot + if val_step == 0: + reconstruction = reconstruction.detach().cpu() + plt.figure(figsize=(5, 3)) + plt.subplot(1, 3, 1) + plt.imshow(images[0, 0, ...].detach().cpu(), cmap="gist_gray") + plt.axis("off") + plt.subplot(1, 3, 2) + plt.imshow(reconstruction[0, 0, ...], cmap="gist_gray") + plt.axis("off") + plt.subplot(1, 3, 3) + plt.imshow(batch["label"][0, 0, ...].detach().cpu(), cmap="jet") + plt.axis("off") + plt.show() + + val_loss /= max(val_step, 1) + val_recon_losses.append(val_loss) + print(f"epoch {epoch + 1} val loss: {val_loss:.4f}") + +progress_bar.close() + +del discriminator +del perceptual_loss +torch.cuda.empty_cache() +# - + +# ### Training the diffusion model + +# Likewise, we use the same approach as in the 2d_ldm_tutorial. + +scheduler = DDPMScheduler(num_train_timesteps=1000, schedule="linear_beta", beta_start=0.0015, beta_end=0.0195) +optimizer = torch.optim.Adam(diffusion.parameters(), lr=1e-4) +inferer = LatentDiffusionInferer(scheduler, scale_factor=1.0) + +# + +diffusion = diffusion.to(device) +n_epochs = 200 +val_interval = 40 +epoch_losses = [] +val_losses = [] +scaler = GradScaler() + +for epoch in range(n_epochs): + diffusion.train() + autoencoder.eval() + epoch_loss = 0 + progress_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=70) + progress_bar.set_description(f"Epoch {epoch}") + for step, batch in progress_bar: + images = batch["image"].to(device) + labels = one_hot(batch["label"], 6).to(device) + optimizer.zero_grad(set_to_none=True) + with autocast(enabled=True): + z_mu, z_sigma = autoencoder.encode(images) + z = autoencoder.sampling(z_mu, z_sigma) + noise = torch.randn_like(z).to(device) + timesteps = torch.randint(0, inferer.scheduler.num_train_timesteps, (z.shape[0],), device=z.device).long() + noise_pred = inferer( + inputs=images, + diffusion_model=diffusion, + noise=noise, + timesteps=timesteps, + autoencoder_model=autoencoder, + seg=labels, + ) + loss = F.mse_loss(noise_pred.float(), noise.float()) + + scaler.scale(loss).backward() + scaler.step(optimizer) + scaler.update() + epoch_loss += loss.item() + + progress_bar.set_postfix({"loss": epoch_loss / (step + 1)}) + epoch_losses.append(epoch_loss / (step + 1)) + + if (epoch + 1) % val_interval == 0: + diffusion.eval() + val_loss = 0 + with torch.no_grad(): + for val_step, batch in enumerate(val_loader, start=1): + images = batch["image"].to(device) + labels = one_hot(batch["label"], 6).to(device) + with autocast(enabled=True): + z_mu, z_sigma = autoencoder.encode(images) + + z = autoencoder.sampling(z_mu, z_sigma) + noise = torch.randn_like(z).to(device) + timesteps = torch.randint( + 0, inferer.scheduler.num_train_timesteps, (z.shape[0],), device=z.device + ).long() + noise_pred = inferer( + inputs=images, + diffusion_model=diffusion, + noise=noise, + timesteps=timesteps, + autoencoder_model=autoencoder, + seg=labels, + ) + + loss = F.mse_loss(noise_pred.float(), noise.float()) + + val_loss += loss.item() + val_loss /= val_step + val_losses.append(val_loss) + print(f"Epoch {epoch} val loss: {val_loss:.4f}") + + # Sampling image during training. We use the last segmentation of our loader + z = torch.randn((labels.shape[0], 8, 16, 16)) + z = z.to(device) + scheduler.set_timesteps(num_inference_steps=1000) + with autocast(enabled=True): + decoded = inferer.sample( + input_noise=z, diffusion_model=diffusion, scheduler=scheduler, autoencoder_model=autoencoder, seg=labels + ) + plt.figure(figsize=(5, 3)) + plt.subplot(1, 3, 1) + plt.imshow(images[0, 0, ...].detach().cpu(), cmap="gist_gray") + plt.axis("off") + plt.subplot(1, 3, 2) + plt.imshow(decoded[0, 0, ...].detach().cpu(), cmap="gist_gray") + plt.axis("off") + plt.subplot(1, 3, 3) + plt.imshow(batch["label"][0, 0, ...].detach().cpu(), cmap="jet") + plt.axis("off") + plt.show() + +progress_bar.close() + +# -