From 18e47e3a454409de9e95315e41bd75a5d26f8f82 Mon Sep 17 00:00:00 2001
From: virginiafdez <virginia.fernandez@kcl.ac.uk>
Date: Tue, 6 Jun 2023 09:02:29 +0100
Subject: [PATCH 1/7] Code for SPADE VAE-GAN added, trimmed. Tests added
 (although at the moment, 3 /4 get executed). Addition of SPADE norm block and
 auxiliary KLD loss.

---
 generative/losses/kld_loss.py             |   6 +
 generative/networks/blocks/spade_norm.py  |  80 ++++++
 generative/networks/nets/spade_network.py | 316 ++++++++++++++++++++++
 tests/test_spade_vaegan.py                | 113 ++++++++
 4 files changed, 515 insertions(+)
 create mode 100644 generative/losses/kld_loss.py
 create mode 100644 generative/networks/blocks/spade_norm.py
 create mode 100644 generative/networks/nets/spade_network.py
 create mode 100644 tests/test_spade_vaegan.py

diff --git a/generative/losses/kld_loss.py b/generative/losses/kld_loss.py
new file mode 100644
index 00000000..4b7e6f31
--- /dev/null
+++ b/generative/losses/kld_loss.py
@@ -0,0 +1,6 @@
+import torch.nn as nn
+import torch
+
+class KLDLoss(nn.Module):
+    def forward(self, mu, logvar):
+        return -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
diff --git a/generative/networks/blocks/spade_norm.py b/generative/networks/blocks/spade_norm.py
new file mode 100644
index 00000000..68991f0c
--- /dev/null
+++ b/generative/networks/blocks/spade_norm.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+import torch
+import torch.nn as nn
+from monai.networks.blocks import Convolution, ADN
+import torch.nn.functional as F
+
+class SPADE(nn.Module):
+    """
+    SPADE normalisation block based on the 2019 paper by Park et al. (doi: https://doi.org/10.48550/arXiv.1903.07291)
+    Args:
+        label_nc: number of semantic labels
+        norm_nc: number of output channels
+        kernel_size: kernel size
+        spatial_dims: number of spatial dimensions
+        hidden_channels: number of channels in the intermediate gamma and beta layers
+        normalisation: type of base normalisation used before applying the SPADE normalisation
+    """
+    def __init__(self,
+                 label_nc: int,
+                 norm_nc: int,
+                 kernel_size: int = 3,
+                 spatial_dims: int = 2,
+                 hidden_channels: int = 64,
+                 norm: str | tuple= "INSTANCE",
+                 norm_params: dict = {}
+                 )-> None:
+
+        super().__init__()
+
+        if len(norm_params) != 0:
+            norm = (norm, norm_params)
+        self.param_free_norm = ADN(act=None, dropout=0.0, norm = norm,
+                                   norm_dim=spatial_dims,
+                                   ordering="N",
+                                   in_channels=norm_nc)
+        self.mlp_shared = Convolution(spatial_dims=spatial_dims,
+                                      in_channels = label_nc,
+                                      out_channels = hidden_channels,
+                                      kernel_size= kernel_size,
+                                      norm = None,
+                                      padding=kernel_size//2,
+                                      act="LEAKYRELU")
+        self.mlp_gamma = Convolution(spatial_dims=spatial_dims,
+                                     in_channels=hidden_channels,
+                                     out_channels=norm_nc,
+                                     kernel_size=kernel_size,
+                                     padding = kernel_size//2,
+                                     act = None
+                                     )
+        self.mlp_beta = Convolution(spatial_dims=spatial_dims,
+                                     in_channels=hidden_channels,
+                                     out_channels=norm_nc,
+                                     kernel_size=kernel_size,
+                                     padding = kernel_size//2,
+                                     act = None
+                                     )
+
+
+    def forward(self,
+                x: torch.Tensor,
+                segmap: torch.Tensor) -> torch.Tensor:
+        """
+        Args:
+            x: input tensor
+            segmap: input segmentation map (bxcx[spatial-dimensions]) where c is the number of semantic channels.
+            The map will be interpolated to the dimension of x internally.
+        Returns:
+
+        """
+
+        # Part 1. generate parameter-free normalized activations
+        normalized = self.param_free_norm(x)
+
+        # Part 2. produce scaling and bias conditioned on semantic map
+        segmap = F.interpolate(segmap, size=x.size()[2:], mode='nearest')
+        actv = self.mlp_shared(segmap)
+        gamma = self.mlp_gamma(actv)
+        beta = self.mlp_beta(actv)
+        out = normalized * (1 + gamma) + beta
+        return out
diff --git a/generative/networks/nets/spade_network.py b/generative/networks/nets/spade_network.py
new file mode 100644
index 00000000..d28a069d
--- /dev/null
+++ b/generative/networks/nets/spade_network.py
@@ -0,0 +1,316 @@
+# 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.
+
+import torch
+import torch.nn as nn
+from typing import Union, Sequence
+import numpy as np
+from monai.networks.blocks import Convolution
+from monai.networks.layers import Act
+from networks.blocks.spade_norm import SPADE
+from monai.utils.enums import StrEnum
+import torch.nn.functional as F
+from losses.kld_loss import KLDLoss
+
+class UpsamplingModes(StrEnum):
+    bicubic = "bicubic"
+    nearest = "nearest"
+    bilinear = "bilinear"
+
+class SPADE_ResNetBlock(nn.Module):
+
+    def __init__(self,
+                 spatial_dims: int,
+                 in_channels: int,
+                 out_channels: int,
+                 label_nc: int,
+                 spade_intermediate_channels: int = 128,
+                 norm: Union[str, tuple] = "INSTANCE",
+                 kernel_size: int = 3,):
+
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.int_channels = min(self.in_channels, self.out_channels)
+        self.learned_shortcut = self.in_channels != self.out_channels
+        self.conv_0 = Convolution(spatial_dims = spatial_dims,
+                                  in_channels = self.in_channels,
+                                  out_channels = self.int_channels,
+                                  act = None,
+                                  norm = None,
+                                  )
+        self.conv_1 = Convolution(spatial_dims = spatial_dims,
+                                  in_channels = self.int_channels,
+                                  out_channels = self.out_channels,
+                                  act = None,
+                                  norm = None,
+                                  )
+        self.activation = nn.LeakyReLU(0.2, False)
+        self.norm_0 = SPADE(label_nc=label_nc, norm_nc=self.in_channels, kernel_size=kernel_size,
+                            spatial_dims=spatial_dims, hidden_channels=spade_intermediate_channels,
+                            norm=norm)
+        self.norm_1 = SPADE(label_nc=label_nc, norm_nc=self.int_channels, kernel_size=kernel_size,
+                            spatial_dims=spatial_dims, hidden_channels=spade_intermediate_channels,
+                            norm=norm)
+
+        if self.learned_shortcut:
+            self.conv_s = Convolution(spatial_dims = spatial_dims,
+                                      in_channels = self.in_channels,
+                                      out_channels = self.out_channels,
+                                      act = None,
+                                      norm = None,
+                                      kernel_size=1,
+                                      )
+            self.norm_s = SPADE(label_nc=label_nc, norm_nc=self.in_channels, kernel_size=kernel_size,
+                                spatial_dims=spatial_dims, hidden_channels=spade_intermediate_channels,
+                                norm=norm)
+
+    def forward(self, x, seg):
+
+        x_s = self.shortcut(x, seg)
+        dx = self.conv_0(self.activation(self.norm_0(x, seg)))
+        dx = self.conv_1(self.activation(self.norm_1(dx, seg)))
+        out = x_s + dx
+        return out
+
+    def shortcut(self, x, seg):
+        if self.learned_shortcut:
+            x_s = self.conv_s(self.norm_s(x, seg))
+        else:
+            x_s = x
+        return x_s
+
+class SPADE_Encoder(nn.Module):
+
+    def __init__(self,
+                 spatial_dims: int,
+                 in_channels: int,
+                 z_dim: int,
+                 num_channels: Sequence[int],
+                 input_shape: Sequence[int],
+                 kernel_size: int = 3,
+                 norm: Union[str, tuple] = "INSTANCE",
+                 act: Union[str, tuple] = (Act.LEAKYRELU, {"negative_slope": 0.2})):
+
+        super().__init__()
+        self.in_channels = in_channels
+        self.z_dim = z_dim
+        self.num_channels = num_channels
+        if len(input_shape) != spatial_dims:
+            raise ValueError("Length of parameter input shape must match spatial_dims; got %s" %(input_shape))
+        for s_ind, s_ in enumerate(input_shape):
+            if s_ / (2 ** len(num_channels)) != s_ // (2 ** len(num_channels)):
+                raise ValueError("Each dimension of your input must be divisible by 2 ** (autoencoder depth)."
+                                 "The shape in position %d, %d is not divisible by %d. " %(s_ind, s_, len(num_channels)))
+        self.input_shape = input_shape
+        self.latent_spatial_shape = [s_ // (2 ** len(self.num_channels)) for s_ in self.input_shape]
+        blocks = []
+        ch_init = self.in_channels
+        for ch_ind, ch_value in enumerate(num_channels):
+            blocks.append(Convolution(spatial_dims = spatial_dims,
+                                      in_channels = ch_init,
+                                      out_channels= ch_value,
+                                      strides=2,
+                                      kernel_size=kernel_size,
+                                      norm = norm,
+                                      act = act))
+            ch_init = ch_value
+
+        self.blocks = nn.ModuleList(blocks)
+        self.fc_mu = nn.Linear(in_features=np.prod(self.latent_spatial_shape) * self.num_channels[-1],
+                                out_features=self.z_dim)
+        self.fc_var = nn.Linear(in_features=np.prod(self.latent_spatial_shape) * self.num_channels[-1],
+                                out_features=self.z_dim)
+
+    def forward(self, x,):
+        for block in self.blocks:
+            x = block(x)
+        x = x.view(x.size(0), -1)
+        mu = self.fc_mu(x)
+        logvar = self.fc_var(x)
+        return mu, logvar
+
+    def encode(self, x):
+
+        for block in self.blocks:
+            x = block(x)
+        x = x.view(x.size(0), -1)
+        mu = self.fc_mu(x)
+        logvar = self.fc_var(x)
+        return self.reparameterize(mu, logvar)
+
+    def reparameterize(self, mu, logvar):
+
+        std = torch.exp(0.5 * logvar)
+        eps = torch.randn_like(std)
+        return eps.mul(std) + mu
+
+class SPADE_Decoder(nn.Module):
+
+    def __init__(self,
+                 spatial_dims: int,
+                 out_channels: int,
+                 label_nc: int,
+                 input_shape: Sequence[int],
+                 num_channels: Sequence[int],
+                 z_dim: Union[int, None] = None,
+                 is_gan: bool = False,
+                 spade_intermediate_channels: int = 128,
+                 norm: Union[str, tuple] = "INSTANCE",
+                 act:  Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
+                 last_act: Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
+                 kernel_size: int = 3,
+                 upsampling_mode: str = UpsamplingModes.nearest.value,
+                 ):
+
+        super().__init__()
+        self.is_gan = is_gan
+        self.out_channels = out_channels
+        self.label_nc = label_nc
+        self.num_channels = num_channels
+        if len(input_shape) != spatial_dims:
+            raise ValueError("Length of parameter input shape must match spatial_dims; got %s" % (input_shape))
+        for s_ind, s_ in enumerate(input_shape):
+            if s_ / (2 ** len(num_channels)) != s_ // (2 ** len(num_channels)):
+                raise ValueError("Each dimension of your input must be divisible by 2 ** (autoencoder depth)."
+                                 "The shape in position %d, %d is not divisible by %d. " % (
+                                 s_ind, s_, len(num_channels)))
+        self.latent_spatial_shape = [s_ // (2 ** len(self.num_channels)) for s_ in input_shape]
+
+        if self.is_gan:
+            self.fc = nn.Linear(label_nc, np.prod(self.latent_spatial_shape) * num_channels[0])
+        else:
+            self.fc = nn.Linear(z_dim, np.prod(self.latent_spatial_shape) * num_channels[0])
+
+        blocks = []
+        num_channels.append(self.out_channels)
+        self.upsampling = torch.nn.Upsample(scale_factor=2, mode=upsampling_mode)
+        for ch_ind, ch_value in enumerate(num_channels[:-1]):
+            blocks.append(SPADE_ResNetBlock(spatial_dims=spatial_dims,
+                                            in_channels=ch_value,
+                                            out_channels=num_channels[ch_ind+1],
+                                            label_nc=label_nc,
+                                            spade_intermediate_channels=spade_intermediate_channels,
+                                            norm=norm,
+                                            kernel_size=kernel_size),)
+
+        self.blocks = torch.nn.ModuleList(blocks)
+        self.last_conv = Convolution(spatial_dims=spatial_dims,
+                                     in_channels=num_channels[-1],
+                                     out_channels=out_channels,
+                                     padding=(kernel_size-1)//2,
+                                     kernel_size=kernel_size,
+                                     norm = None,
+                                     act=last_act
+                                     )
+
+
+    def forward(self, seg, z: torch.Tensor = None):
+
+
+        if self.is_gan:
+            x = F.interpolate(seg, size=tuple(self.latent_spatial_shape))
+            x = self.fc(x)
+        else:
+            if z is None:
+                z = torch.randn(seg.size(0), self.opt.z_dim,
+                                dtype=torch.float32, device=seg.get_device())
+            x = self.fc(z)
+            x = x.view(*[-1, self.num_channels[0]]+self.latent_spatial_shape)
+
+        for res_block in self.blocks:
+            x = res_block(x, seg)
+            x = self.upsampling(x)
+
+        x = self.last_conv(x)
+        return x
+
+class SPADE_Net(nn.Module):
+
+    def __init__(
+            self,
+            spatial_dims: int,
+            in_channels: int,
+            out_channels: int,
+            label_nc: int,
+            input_shape: Sequence[int],
+            num_channels: Sequence[int],
+            z_dim: Union[int, None] = None,
+            is_vae: bool = True,
+            spade_intermediate_channels: int = 128,
+            norm:Union[str, tuple]  = "INSTANCE",
+            act: Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
+            last_act: Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
+            kernel_size: int = 3,
+            upsampling_mode: str = UpsamplingModes.nearest.value
+
+    ):
+
+        super().__init__()
+        self.is_vae = is_vae
+        if self.is_vae and z_dim is None:
+            ValueError("The latent space dimension mapped by parameter z_dim cannot be None is is_vae is True.")
+
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.num_channels = num_channels
+        self.label_nc = label_nc
+        self.input_shape = input_shape
+        self.kld_loss = KLDLoss()
+
+        if self.is_vae:
+            self.encoder = SPADE_Encoder(
+                spatial_dims = spatial_dims,
+                in_channels = in_channels,
+                z_dim = z_dim,
+                num_channels = num_channels,
+                input_shape = input_shape,
+                kernel_size = kernel_size,
+                norm = norm,
+                act = act)
+
+        decoder_channels = num_channels
+        decoder_channels.reverse()
+
+        self.decoder = SPADE_Decoder(
+            spatial_dims=spatial_dims,
+            out_channels=out_channels,
+            label_nc=label_nc,
+            input_shape=input_shape,
+            num_channels= decoder_channels,
+            z_dim = z_dim,
+            is_gan = not is_vae,
+            spade_intermediate_channels = spade_intermediate_channels,
+            norm = norm,
+            act = act,
+            last_act = last_act,
+            kernel_size=kernel_size,
+            upsampling_mode=upsampling_mode
+        )
+
+    def forward(self, seg: torch.Tensor, x: Union[torch.Tensor, None] = None):
+
+        z = None
+        if self.is_vae:
+            z_mu, z_logvar = self.encoder(x)
+            z = self.encoder.reparameterize(z_mu, z_logvar)
+            kld_loss = self.kld_loss(z_mu, z_logvar)
+            return self.decoder(seg, z), kld_loss
+        else:
+            return self.decoder(seg, z),
+
+    def encode(self, x: torch.Tensor):
+
+        return self.encoder.encode(x)
+
+    def decode(self, seg: torch.Tensor, z: Union[torch.Tensor, None] = None):
+
+        return self.decoder(seg, z)
diff --git a/tests/test_spade_vaegan.py b/tests/test_spade_vaegan.py
new file mode 100644
index 00000000..8ea62b9f
--- /dev/null
+++ b/tests/test_spade_vaegan.py
@@ -0,0 +1,113 @@
+# 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 networks.nets.spade_network import SPADE_Net
+import numpy as np
+
+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]]]
+CASE_3D = [[[3, 1, 1, 3, [64, 64, 64], [16, 32, 64, 128], 16, True]]]
+
+def create_Semantic_Data(shape:list, semantic_regions:int):
+    '''
+    To create semantic and image mock inputs for the network.
+    Args:
+        shape: input shape
+        semantic_regions: number of semantic regions
+    Returns:
+    '''
+    out_label = torch.zeros(shape)
+    out_image = torch.zeros(shape) + torch.randn(shape)*0.01
+    for i in range(1, semantic_regions):
+        shape_square = [i//np.random.choice(list(range(2, i//2))) for i in shape]
+        start_point = [np.random.choice(list(range(shape[ind]-shape_square[ind])))
+                       for ind, i in enumerate(shape)]
+        if len(shape) == 2:
+            out_label[start_point[0]:(start_point[0]+shape_square[0]),
+                      start_point[1]:(start_point[1]+shape_square[1])] = i
+            base_intensity = torch.ones(shape_square) * np.random.randn()
+            out_image[start_point[0]:(start_point[0] + shape_square[0]),
+            start_point[1]:(start_point[1] + shape_square[1])] = base_intensity + \
+                                                           torch.randn(shape_square)*0.1
+        elif len(shape) == 3:
+            out_label[start_point[0]:(start_point[0]+shape_square[0]),
+                      start_point[1]:(start_point[1]+shape_square[1]),
+                      start_point[2]:(start_point[2] + shape_square[2])] = i
+            base_intensity = torch.ones(shape_square) * np.random.randn()
+            out_image[start_point[0]:(start_point[0]+shape_square[0]),
+                      start_point[1]:(start_point[1]+shape_square[1]),
+                      start_point[2]:(start_point[2] + shape_square[2])] = base_intensity + \
+                                                           torch.randn(shape_square)*0.1
+        else:
+            ValueError("Supports only 2D and 3D tensors")
+
+    # One hot encode label
+    out_label_ = torch.zeros([semantic_regions,] + list(out_label.shape))
+    for ch in range(semantic_regions):
+        out_label_[ch, ...] = out_label == ch
+
+    return out_label_.unsqueeze(0), out_image.unsqueeze(0).unsqueeze(0)
+
+class TestDiffusionModelUNet2D(unittest.TestCase):
+
+    @parameterized.expand(CASE_2D)
+    def test_forward_2d(self, input_param):
+        '''
+        Check that forward method is called correctly and output shape matches.
+        '''
+        net = SPADE_Net(*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)
+            self.assertEqual(False, True in torch.isnan(out) or True in torch.isinf(out)
+                             or True in torch.isinf(kld) or True in torch.isinf(kld))
+            self.assertEqual(list(out.shape), [1, 1, 64, 64])
+
+    @parameterized.expand(CASE_2D_BIS)
+    def test_encoder_decoder(self, input_param):
+        '''
+        Check that forward method is called correctly and output shape matches.
+        '''
+        net = SPADE_Net(*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)
+            self.assertEqual(list(out_z.shape), [1, 16])
+            out_i = net.decode(in_label, out_z)
+            self.assertEqual(list(out_i.shape), [1, 1, 64, 64])
+
+    @parameterized.expand(CASE_3D)
+    def test_forward_2d(self, input_param):
+        '''
+        Check that forward method is called correctly and output shape matches.
+        '''
+        net = SPADE_Net(*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)
+            self.assertEqual(False, True in torch.isnan(out) or True in torch.isinf(out)
+                             or True in torch.isinf(kld) or True in torch.isinf(kld))
+            self.assertEqual(list(out.shape), [1, 1, 64, 64, 64])
+
+    def test_shape_wrong(self):
+        '''
+        We input an input shape that isn't divisible by 2**(n downstream steps)
+        '''
+        with self.assertRaises(ValueError):
+            net = SPADE_Net(1, 1, 8, [16, 16], [16, 32, 64, 128], 16, True)
+
+if __name__ == "__main__":
+    unittest.main()

From 390eb58e921ad0ec9b87eda63c4c95d5d1c0a324 Mon Sep 17 00:00:00 2001
From: virginiafdez <virginia.fernandez@kcl.ac.uk>
Date: Tue, 20 Jun 2023 22:11:51 +0100
Subject: [PATCH 2/7] Added SPADE network code, tests and jupyter notebook for
 2D

---
 generative/networks/nets/spade_network.py     |  4 +-
 tests/test_spade_vaegan.py                    |  2 +-
 .../2d_autoencoderkl_tutorial.ipynb           | 41 ++++++++++---------
 .../2d_autoencoderkl_tutorial.py              |  1 -
 4 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/generative/networks/nets/spade_network.py b/generative/networks/nets/spade_network.py
index d28a069d..ebf601e6 100644
--- a/generative/networks/nets/spade_network.py
+++ b/generative/networks/nets/spade_network.py
@@ -15,10 +15,10 @@
 import numpy as np
 from monai.networks.blocks import Convolution
 from monai.networks.layers import Act
-from networks.blocks.spade_norm import SPADE
+from generative.networks.blocks.spade_norm import SPADE
 from monai.utils.enums import StrEnum
 import torch.nn.functional as F
-from losses.kld_loss import KLDLoss
+from generative.losses.kld_loss import KLDLoss
 
 class UpsamplingModes(StrEnum):
     bicubic = "bicubic"
diff --git a/tests/test_spade_vaegan.py b/tests/test_spade_vaegan.py
index 8ea62b9f..3354d4d6 100644
--- a/tests/test_spade_vaegan.py
+++ b/tests/test_spade_vaegan.py
@@ -90,7 +90,7 @@ def test_encoder_decoder(self, input_param):
             self.assertEqual(list(out_i.shape), [1, 1, 64, 64])
 
     @parameterized.expand(CASE_3D)
-    def test_forward_2d(self, input_param):
+    def test_forward_3d(self, input_param):
         '''
         Check that forward method is called correctly and output shape matches.
         '''
diff --git a/tutorials/generative/2d_autoencoderkl/2d_autoencoderkl_tutorial.ipynb b/tutorials/generative/2d_autoencoderkl/2d_autoencoderkl_tutorial.ipynb
index 11d059c3..2b398ee5 100644
--- a/tutorials/generative/2d_autoencoderkl/2d_autoencoderkl_tutorial.ipynb
+++ b/tutorials/generative/2d_autoencoderkl/2d_autoencoderkl_tutorial.ipynb
@@ -72,7 +72,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 1,
    "id": "350736c2",
    "metadata": {},
    "outputs": [
@@ -80,29 +80,30 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "MONAI version: 1.1.dev2239\n",
-      "Numpy version: 1.23.3\n",
-      "Pytorch version: 1.8.0+cu111\n",
+      "MONAI version: 1.2.dev2304\n",
+      "Numpy version: 1.23.5\n",
+      "Pytorch version: 1.13.1+cu117\n",
       "MONAI flags: HAS_EXT = False, USE_COMPILED = False, USE_META_DICT = False\n",
-      "MONAI rev id: 13b24fa92b9d98bd0dc6d5cdcb52504fd09e297b\n",
-      "MONAI __file__: /media/walter/Storage/Projects/GenerativeModels/venv/lib/python3.8/site-packages/monai/__init__.py\n",
+      "MONAI rev id: 9a57be5aab9f2c2a134768c0c146399150e247a0\n",
+      "MONAI __file__: /home/vf19/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/monai/__init__.py\n",
       "\n",
       "Optional dependencies:\n",
       "Pytorch Ignite version: 0.4.10\n",
-      "Nibabel version: 4.0.2\n",
-      "scikit-image version: NOT INSTALLED or UNKNOWN VERSION.\n",
-      "Pillow version: 9.2.0\n",
-      "Tensorboard version: 2.11.0\n",
-      "gdown version: NOT INSTALLED or UNKNOWN VERSION.\n",
-      "TorchVision version: 0.9.0+cu111\n",
+      "ITK version: 5.3.0\n",
+      "Nibabel version: 5.0.0\n",
+      "scikit-image version: 0.19.3\n",
+      "Pillow version: 9.4.0\n",
+      "Tensorboard version: 2.12.0\n",
+      "gdown version: 4.6.3\n",
+      "TorchVision version: 0.14.1+cu117\n",
       "tqdm version: 4.64.1\n",
-      "lmdb version: NOT INSTALLED or UNKNOWN VERSION.\n",
-      "psutil version: 5.9.3\n",
-      "pandas version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "lmdb version: 1.4.0\n",
+      "psutil version: 5.9.4\n",
+      "pandas version: 1.5.3\n",
       "einops version: 0.6.0\n",
-      "transformers version: NOT INSTALLED or UNKNOWN VERSION.\n",
-      "mlflow version: NOT INSTALLED or UNKNOWN VERSION.\n",
-      "pynrrd version: NOT INSTALLED or UNKNOWN VERSION.\n",
+      "transformers version: 4.21.3\n",
+      "mlflow version: 2.1.1\n",
+      "pynrrd version: 1.0.0\n",
       "\n",
       "For details about installing the optional dependencies, please visit:\n",
       "    https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies\n",
@@ -115,7 +116,7 @@
     "import shutil\n",
     "import tempfile\n",
     "import time\n",
-    "\n",
+    "from pathlib import Path\n",
     "import matplotlib.pyplot as plt\n",
     "import numpy as np\n",
     "import torch\n",
@@ -1229,7 +1230,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.9.16"
   }
  },
  "nbformat": 4,
diff --git a/tutorials/generative/2d_autoencoderkl/2d_autoencoderkl_tutorial.py b/tutorials/generative/2d_autoencoderkl/2d_autoencoderkl_tutorial.py
index 53ccf898..39e44730 100644
--- a/tutorials/generative/2d_autoencoderkl/2d_autoencoderkl_tutorial.py
+++ b/tutorials/generative/2d_autoencoderkl/2d_autoencoderkl_tutorial.py
@@ -42,7 +42,6 @@
 import shutil
 import tempfile
 import time
-
 import matplotlib.pyplot as plt
 import numpy as np
 import torch

From 97737b19a4b4a7b4778d482c3660f83741e515a9 Mon Sep 17 00:00:00 2001
From: virginiafdez <virginia.fernandez@kcl.ac.uk>
Date: Tue, 20 Jun 2023 22:23:10 +0100
Subject: [PATCH 3/7] Added SPADE network code, tests and jupyter notebook for
 2D

---
 .../2d_spade_gan/2d_spade_vae.ipynb           | 937 ++++++++++++++++++
 .../generative/2d_spade_gan/2d_spade_vae.py   | 330 ++++++
 2 files changed, 1267 insertions(+)
 create mode 100644 tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
 create mode 100644 tutorials/generative/2d_spade_gan/2d_spade_vae.py

diff --git a/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb b/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
new file mode 100644
index 00000000..c7c29aaf
--- /dev/null
+++ b/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
@@ -0,0 +1,937 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "1f7ba8ce",
+   "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": "102909fb",
+   "metadata": {},
+   "source": [
+    "# SPADE VAE-GAN"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d4cbc3c",
+   "metadata": {},
+   "source": [
+    "This notebook creates a mock SPADE VAE-GAN based on the paper \"Semantic Image Synthesis with Spatially-Adaptive Normalization\" (2019) by Park T, Liu MY, Wang TC, Zhu JY. More information available at: https://github.com/NVlabs/SPADE"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e059c423",
+   "metadata": {
+    "scrolled": true
+   },
+   "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",
+    "from generative.networks.nets import MultiScalePatchDiscriminator\n",
+    "import numpy as np\n",
+    "import monai\n",
+    "from generative.networks.nets.spade_network import SPADE_Net"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e76296e7",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Temporary directory used: /tmp/tmpy_otj3u5 \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": 8,
+   "id": "2483148a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# INPUT PARAMETERS\n",
+    "input_shape = [128, 128]\n",
+    "batch_size = 6\n",
+    "num_workers = 4\n",
+    "num_epochs = 100\n",
+    "lambda_perc = 1.0\n",
+    "lambda_feat = 0.1\n",
+    "lambda_kld = 0.00001\n",
+    "loss_adv = 1.0"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3f2448ba",
+   "metadata": {},
+   "source": [
+    "### Data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2c91eec2",
+   "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.”_\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’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.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "dc560f7e",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Downloading...\n",
+      "From: https://drive.google.com/uc?export=download&id=1SX_MCzQe-vyq09QYxECk32wZ2vxp9rx5\n",
+      "To: /tmp/tmpy_otj3u5/data.zip\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 384M/384M [00:06<00:00, 62.8MB/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'/tmp/tmpy_otj3u5/data.zip'"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "gdown.download(\"https://drive.google.com/uc?export=download&id=1SX_MCzQe-vyq09QYxECk32wZ2vxp9rx5\",\n",
+    "               str(root_dir / 'data.zip'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "cd7dd6ec",
+   "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": 11,
+   "id": "d48987b9",
+   "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",
+    "             [os.path.join(images_FLAIR, i) for i in os.listdir(images_FLAIR)]\n",
+    "np.random.shuffle(all_images)\n",
+    "corresponding_labels = [os.path.join(labels, i.split(\"/\")[-1].replace(i.split(\"/\")[-1].split(\"_\")[0], \"Parcellation\"))\n",
+    "                        for i in all_images]\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": "9916ca5a",
+   "metadata": {},
+   "source": [
+    "### Dataloaders"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "8ab79cdc",
+   "metadata": {
+    "lines_to_end_of_cell_marker": 2
+   },
+   "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'],\n",
+    "                                                     roi_size=preliminar_shape),\n",
+    "    monai.transforms.RandSpatialCropd(keys = ['label', 'image'],\n",
+    "                                             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'],\n",
+    "                             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),\n",
+    "                                        keys=['image']),\n",
+    "        monai.transforms.RandAffined(rotate_range=[-0.05, 0.05], shear_range=[0.001, 0.05],\n",
+    "                                     scale_range=[0, 0.05], padding_mode='zeros',\n",
+    "                                     mode='nearest', prob=0.33, keys=['label', 'image'])\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": 13,
+   "id": "98d14e75",
+   "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": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "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'); plt.axis('off')\n",
+    "plt.subplot(1,2,2)\n",
+    "plt.imshow(batch['label'][0,0,...], cmap = \"jet\"); plt.axis('off')\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "63de4490",
+   "metadata": {},
+   "source": [
+    "### Network creation and losses"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "fa17d864",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "8f126b17",
+   "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": null,
+   "id": "6af2779b",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "255c90c7",
+   "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": "code",
+   "execution_count": null,
+   "id": "eaa62145",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "c18dbad8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def feature_loss(input_features_disc_fake, input_features_disc_real, lambda_feat, device):\n",
+    "    criterion = torch.nn.L1Loss()\n",
+    "    num_D = len(input_features_disc_fake)\n",
+    "    GAN_Feat_loss = torch.zeros(1).to(device)\n",
+    "    for i in range(num_D):  # for each discriminator\n",
+    "        num_intermediate_outputs = len(input_features_disc_fake[i])\n",
+    "        for j in range(num_intermediate_outputs):  # for each layer output\n",
+    "            unweighted_loss = criterion(input_features_disc_fake[i][j],\n",
+    "                                        input_features_disc_real[i][j].detach())\n",
+    "            GAN_Feat_loss += unweighted_loss * lambda_feat / num_D\n",
+    "    return GAN_Feat_loss"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "89989c34",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "net = SPADE_Net(spatial_dims = 2,\n",
+    "                in_channels = 1,\n",
+    "                out_channels = 1,\n",
+    "                label_nc = 6,\n",
+    "                input_shape = input_shape,\n",
+    "                num_channels = [16, 32, 64, 128],\n",
+    "                z_dim = 16,\n",
+    "                is_vae = True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "5b8b676f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "discriminator = MultiScalePatchDiscriminator(num_d = 2,\n",
+    "                                             num_layers_d = 3,\n",
+    "                                             spatial_dims = 2,\n",
+    "                                             num_channels = 8,\n",
+    "                                             in_channels = 7,\n",
+    "                                             out_channels = 7,\n",
+    "                                             minimum_size_im = 128,\n",
+    "                                             norm = \"INSTANCE\",\n",
+    "                                             kernel_size = 3\n",
+    "                                             )\n",
+    "\n",
+    "adversarial_loss = PatchAdversarialLoss(reduction = \"sum\", criterion = \"hinge\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "36ea4308",
+   "metadata": {
+    "scrolled": false
+   },
+   "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=VGG16_Weights.IMAGENET1K_V1`. You can also use `weights=VGG16_Weights.DEFAULT` to get the most up-to-date weights.\n"
+     ]
+    }
+   ],
+   "source": [
+    "perceptual_loss = PerceptualLoss(spatial_dims = 2,\n",
+    "                                 network_type = \"vgg\",\n",
+    "                                 is_fake_3d = False,\n",
+    "                                 pretrained = True)\n",
+    "perceptual_loss=perceptual_loss.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "3b57abd3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "optimizer_G = torch.optim.Adam(net.parameters(), lr = 0.0002)\n",
+    "optimizer_D = torch.optim.Adam(discriminator.parameters(), lr = 0.0004)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b8fde71b",
+   "metadata": {},
+   "source": [
+    "### Training loop\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "918eac0a",
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████| 15/15 [00:08<00:00,  1.74it/s, kld=378, perceptual=0.395, generator=2.04, feature=0.206, discriminator=3.69]\n",
+      "  0%|                | 0/2 [00:00<?, ?it/s, kld=356, perceptual=0.371, generator=2.1, feature=0.203, discriminator=3.62]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████| 2/2 [00:00<00:00,  3.18it/s, kld=252, perceptual=0.362, generator=2.1, feature=0.204, discriminator=3.61]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.18it/s, kld=279, perceptual=0.395, generator=2.15, feature=0.202, discriminator=3.7]\n",
+      "  0%|                 | 0/2 [00:00<?, ?it/s, kld=284, perceptual=0.405, generator=2.18, feature=0.18, discriminator=3.6]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████| 2/2 [00:00<00:00,  3.25it/s, kld=184, perceptual=0.421, generator=2.2, feature=0.196, discriminator=3.36]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.14it/s, kld=207, perceptual=0.421, generator=2.32, feature=0.214, discriminator=2.83]\n",
+      "  0%|                | 0/2 [00:00<?, ?it/s, kld=198, perceptual=0.426, generator=2.3, feature=0.221, discriminator=2.82]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████| 2/2 [00:00<00:00,  3.47it/s, kld=125, perceptual=0.414, generator=2.33, feature=0.222, discriminator=2.82]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 3/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.17it/s, kld=131, perceptual=0.384, generator=2.31, feature=0.219, discriminator=2.68]\n",
+      "  0%|                | 0/2 [00:00<?, ?it/s, kld=117, perceptual=0.382, generator=2.38, feature=0.23, discriminator=2.57]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████| 2/2 [00:00<00:00,  3.38it/s, kld=87.2, perceptual=0.403, generator=2.35, feature=0.221, discriminator=2.59]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:07<00:00,  2.12it/s, kld=170, perceptual=0.353, generator=2.46, feature=0.17, discriminator=2.51]\n",
+      "  0%|                | 0/2 [00:00<?, ?it/s, kld=203, perceptual=0.38, generator=2.46, feature=0.179, discriminator=2.38]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVUAAACFCAYAAADrRWu1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABtV0lEQVR4nO2deXhcddn+P5PZk9kyWZulSdOmNF2gpIWCtFBBLAiyyFY2qQpSEBQVQV/wJQiKCAjiQpXyUqSIICgo/gBBKbIvLS2FJm26JE3S7MlkZjKZZGZyfn+cPN+eSVJasGlSnPu6ejVz5syZM2d5zrPcz/2YNE3TSCGFFFJIYb8gbbx3IIUUUkjh04SUUU0hhRRS2I9IGdUUUkghhf2IlFFNIYUUUtiPSBnVFFJIIYX9iJRRTSGFFFLYj0gZ1RRSSCGF/YiUUU0hhRRS2I9IGdUUUkghhf2IT6VRraurw2Qyceedd+63ba5ZswaTycSaNWv22zZTGInUcf70YdmyZZSWlo73bhwwTCijumrVKkwmE+++++5478pBi4l2DCORCFVVVSkjOYQPP/yQiy66iMLCQux2OwUFBVx44YV8+OGH/9F2f/KTn/DUU0/tn53cC15//XWqqqoIBAIH5PsONkwoo5rCpw+RSISbb755n43qscceS19fH8cee+zY7tg44M9//jOVlZX885//5Ctf+Qq/+c1v+NrXvsZLL71EZWUlf/nLXz7xtg+0Ub355pv32ajef//9bN68eWx3agLBMt47kEIKRqSlpeFwOMZ7N/Y7tm3bxsUXX0xZWRn//ve/ycnJUe9961vfYtGiRVx88cW8//77lJWVjeOe7n9Yrdbx3oUDioPKUx0YGOB///d/mTdvHl6vl4yMDBYtWsRLL720x8/cfffdlJSU4HQ6Oe644/jggw9GrFNTU8PZZ5+N3+/H4XAwf/58/vrXv47lTzmgWLZsGS6Xi6amJs444wxcLhc5OTlce+21JBIJtZ4xF72347Z48WIWL1486ndJ/qyurk4Zj5tvvhmTyYTJZKKqqmqP+zpaTnXx4sXMnj2b999/n+OOO4709HSmTZvGE088AcDLL7/MggULcDqdHHLIIbz44otJ26yvr+fKK6/kkEMOwel0kpWVxTnnnENdXd2I75fvcDqdFBUVceutt/Lggw9iMplGrP/ss8+yaNEiMjIycLvdnHLKKXsM4++44w4ikQi/+93vkgwqQHZ2Nr/97W/p7e3lZz/72ajH0oiqqipMJpN6bTKZ6O3t5aGHHlLHeNmyZUnr1tTUcO655+LxeMjKyuJb3/oW0WhUbUPO/apVq0Z8n/GcVVVV8b3vfQ+AKVOmqO8b7Vju6XcYr7Nf//rXlJWVkZ6ezuc//3kaGhrQNI1bbrmFoqIinE4np59+Ol1dXUnbfPrppznllFMoKCjAbrczdepUbrnllqTrWSDf4XQ6OfLII3nllVdGvX77+/u56aabmDZtGna7neLiYq677jr6+/v3+NtGw0HlqQaDQVauXMn555/PZZddRigU4oEHHmDJkiW8/fbbzJ07N2n93//+94RCIb7xjW8QjUb5xS9+wfHHH8/GjRvJy8sD9BzXMcccQ2FhId///vfJyMjg8ccf54wzzuDJJ5/kzDPPHIdfuv+RSCRYsmQJCxYs4M477+TFF1/krrvuYurUqVxxxRVJ6+7LcdsX5OTkcN9993HFFVdw5pln8qUvfQmAQw899GPvf3d3N6eeeipLly7lnHPO4b777mPp0qU88sgjXHPNNSxfvpwLLriAO+64g7PPPpuGhgbcbjcA77zzDq+//jpLly6lqKiIuro67rvvPhYvXsymTZtIT08HoKmpic9+9rOYTCZ+8IMfkJGRwcqVK7Hb7SP25+GHH+aSSy5hyZIl3H777UQiEe677z4WLlzIe++9N8IY/u1vf6O0tJRFixaN+vuOPfZYSktL+fvf//6xj83DDz/MpZdeypFHHsnXv/51AKZOnZq0zrnnnktpaSm33XYbb775Jvfeey/d3d38/ve//1jf9aUvfYktW7bw6KOPcvfdd5OdnQ0w4kGxL3jkkUcYGBjg6quvpquri5/97Gece+65HH/88axZs4brr7+erVu38stf/pJrr72W//u//1OfXbVqFS6Xi+985zu4XC7+9a9/8b//+78Eg0HuuOMOtd59993HVVddxaJFi/j2t79NXV0dZ5xxBpmZmRQVFan1BgcHOe2003j11Vf5+te/TkVFBRs3buTuu+9my5YtHy+1ok0gPPjggxqgvfPOO6O+H4/Htf7+/qRl3d3dWl5envbVr35VLduxY4cGaE6nU2tsbFTL33rrLQ3Qvv3tb6tlJ5xwgjZnzhwtGo2qZYODg9pnPvMZrby8XC176aWXNEB76aWX/tOfOaYY7RhecsklGqD96Ec/Slr38MMP1+bNm6def5zjdtxxx2nHHXfciO+/5JJLtJKSEvW6vb1dA7Sbbrppn/Z/tON83HHHaYD2hz/8QS2rqanRAC0tLU1788031fLnn39eA7QHH3xQLYtEIiO+54033tAA7fe//71advXVV2smk0l777331LLOzk7N7/drgLZjxw5N0zQtFAppPp9Pu+yyy5K22dLSonm93hHLA4GABminn376R/720047TQO0YDCoadrIYym46aabtOG3bkZGhnbJJZfscd3TTjstafmVV16pAdqGDRs0Tdt97o3HTTD8/N1xxx1Jx2NvGP475LtycnK0QCCglv/gBz/QAO2www7TYrGYWn7++edrNpst6R4d7ZxefvnlWnp6ulqvv79fy8rK0o444oik7a1atUoDkq7fhx9+WEtLS9NeeeWVpG2uWLFCA7TXXnttn36rpmnaQRX+m81mbDYboD9Zurq6iMfjzJ8/n3Xr1o1Y/4wzzqCwsFC9PvLII1mwYAH/7//9PwC6urr417/+xbnnnksoFKKjo4OOjg46OztZsmQJtbW1NDU1HZgfdwCwfPnypNeLFi1i+/btI9bb23EbD7hcLpYuXapeH3LIIfh8PioqKliwYIFaLn8bf5fT6VR/x2IxOjs7mTZtGj6fL+m6ee655zj66KOTIh6/38+FF16YtC8vvPACgUCA888/X10zHR0dmM1mFixYMCIdFQqFAJTnvCfI+8Fg8CPX+yT4xje+kfT66quvBhjXc3rOOefg9XrVazl3F110ERaLJWn5wMBA0r1oPKdy7y5atIhIJEJNTQ0A7777Lp2dnVx22WVJ27vwwgvJzMxM2pc//elPVFRUMGPGjKRzevzxxwN8ZIpxOA6q8B/goYce4q677qKmpoZYLKaWT5kyZcS65eXlI5ZNnz6dxx9/HICtW7eiaRo//OEP+eEPfzjq97W1tSUZmIMVDodjRIiWmZlJd3f3iHX3dtzGA0VFRUl5RACv10txcfGIZUDS7+rr6+O2227jwQcfpKmpCc0w7KKnp0f9XV9fz9FHHz3iu6dNm5b0ura2FkDdcMPh8XiSXouxFOO6J+yr8f0kGH5Op06dSlpa2kfmQscakydPTnot525fzumHH37IjTfeyL/+9a8RDyE5p/X19cDI82exWEakZ2pra6murt5jGqOtrW1ffpK+/X1ecwJg9erVLFu2jDPOOIPvfe975ObmYjabue2229i2bdvH3t7g4CAA1157LUuWLBl1neEn5GCF2Wzer9szmUxJxkkwWqFgf2BP+7+n5cZ9u/rqq3nwwQe55pprOProo/F6vZhMJpYuXaqugY8D+czDDz9Mfn7+iPeNXhHoRmHSpEm8//77H7nd999/n8LCQmWUhz9EBPvjGA/f9lh+157wSc9pIBDguOOOw+Px8KMf/YipU6ficDhYt24d119//Sc+p3PmzOHnP//5qO8PN/QfhYPKqD7xxBOUlZXx5z//OekiuOmmm0ZdXzwKI7Zs2aKeUkJdsVqtfO5zn9v/O3yQYm/HDXQvd7TUgXgHgj3drAcSTzzxBJdccgl33XWXWhaNRkfwLEtKSti6deuIzw9fJkWg3Nzcfb5uTj31VO6//35effVVFi5cOOL9V155hbq6Oi6//HK1LDMzc1Qu6PBjDHs/zrW1tUnR3NatWxkcHFTnVMLh4d/3Sb5rrLFmzRo6Ozv585//nMRn3rFjR9J6JSUlgP5bP/vZz6rl8Xicurq6pILp1KlT2bBhAyeccMJ//PsOupwqJHshb731Fm+88cao6z/11FNJeZi3336bt956i5NPPhnQb4rFixfz29/+lubm5hGfb29v35+7f9Bgb8cN9IuwpqYm6Rht2LCB1157LWlbUlkfz+4bs9k8wqv+5S9/OcILW7JkCW+88Qbr169Xy7q6unjkkUdGrOfxePjJT36SlIISjHbdfO9738PpdHL55ZfT2dmZ9F5XVxfLly8nPT1d0ZVAP8Y9PT1JHm5zc/OoTQIZGRkfeYx//etfJ73+5S9/CaDOqcfjITs7m3//+99J6/3mN78Z9btg/M7paHZgYGBgxL7Onz+frKws7r//fuLxuFr+yCOPjEh7nXvuuTQ1NXH//feP+L6+vj56e3v3ef8mpKf6f//3fzz33HMjli9evJg///nPnHnmmZxyyins2LGDFStWMHPmTMLh8Ij1p02bxsKFC7niiivo7+/nnnvuISsri+uuu06t8+tf/5qFCxcyZ84cLrvsMsrKymhtbeWNN96gsbGRDRs2jOlvnYjYl+P21a9+lZ///OcsWbKEr33ta7S1tbFixQpmzZqVlONyOp3MnDmTxx57jOnTp+P3+5k9ezazZ88+YL/n1FNP5eGHH8br9TJz5kzeeOMNXnzxRbKyspLWu+6661i9ejUnnngiV199taJUTZ48ma6uLuXBeDwe7rvvPi6++GIqKytZunQpOTk57Ny5k7///e8cc8wx/OpXv0radnl5OQ899BAXXnghc+bM4Wtf+xpTpkyhrq6OBx54gI6ODh599NEkKtTSpUu5/vrrOfPMM/nmN7+paFvTp08fUZidN28eL774Ij//+c8pKChgypQpSQW8HTt2cNppp3HSSSfxxhtvsHr1ai644AIOO+wwtc6ll17KT3/6Uy699FLmz5/Pv//9b7Zs2TLieM6bNw+AG264gaVLl2K1WvniF7+ojO1Y4zOf+QyZmZlccsklfPOb38RkMvHwww+PeHDabDaqqqq4+uqrOf744zn33HOpq6tj1apVTJ06Nckjvfjii3n88cdZvnw5L730EscccwyJRIKamhoef/xxnn/+eebPn79vO7jPPIEDAKED7enfzp07tZ/85CdaSUmJZrfbtcMPP1x75pln9kjZuOOOO7S77rpLKy4u1ux2u7Zo0SJFITFi27Zt2pe//GUtPz9fs1qtWmFhoXbqqadqTzzxhFrnYKdUZWRkjFh3ODXn4x631atXa2VlZZrNZtPmzp2rPf/886PSgF5//XVt3rx5ms1m2yu9ak+UqlmzZo1Yt6SkRDvllFNGLAe0b3zjG+p1d3e39pWvfEXLzs7WXC6XtmTJEq2mpkYrKSkZQUN67733tEWLFml2u10rKirSbrvtNu3ee+/VAK2lpWXEvi5ZskTzer2aw+HQpk6dqi1btkx799139/j73n//fe3888/XJk2apFmtVi0/P187//zztY0bN466/j/+8Q9t9uzZms1m0w455BBt9erVo1KqampqtGOPPVZzOp0aoH6XrLtp0ybt7LPP1txut5aZmaldddVVWl9fX9I2IpGI9rWvfU3zer2a2+3Wzj33XK2trW3Uc3bLLbdohYWFWlpa2l7pVR91fw4/noD2pz/9KWn5aNf0a6+9ph111FGa0+nUCgoKtOuuu07R6Ybfo/fee6+yGUceeaT22muvafPmzdNOOumkpPUGBga022+/XZs1a5Zmt9u1zMxMbd68edrNN9+s9fT07PH3DceEMqopjC/2dLH/t+Nb3/qW5nA4tHg8Pt678rEhRrW9vX28d2XCIJFIaH6/X7v00kvHZPsHVU41hRTGGn19fUmvOzs7efjhh1m4cOF+Z1CkMPaIRqMj0gK///3v6erqGrXNen9gQuZUU0hhvHD00UezePFiKioqaG1t5YEHHiAYDO6Rx5zCxMabb77Jt7/9bc455xyysrJYt24dDzzwALNnz+acc84Zk+9MGdUUUjDgC1/4Ak888QS/+93vMJlMVFZW8sADD3wqpQj/G1BaWkpxcTH33nsvXV1d+P1+vvzlL/PTn/5UdWfub5i04b5xCimkkEIKnxipnGoKKaSQwn5EyqimkEIKKexHpIxqCimkkMJ+xD4XqkymqjHcjRSGQ9Oq/uNtjHeP9n8b9ld5Ijc3l2g0qoRBNE1Lncv9DDmmFotlv7fbpjzVFFKY4EgZ1P0POaZjUadPUapSSGGCYX/d6KMZ4/8Wss94PohSRjWFFD6l+G8xoKPB+NsPtIFNGdUUUkjhU4d9NaSp8D+FFFIYE/wnRmhPn/1v9ZRTRjWFFFJIwp5C549jJP9bDSqkjGoKKaRgwHBj+EmM43+zQYUUpSqFFFL4DzCaJzsRKGDjadhTRjWFFCYwxto4mEymJCMor/dEx9pbVX34+3va1oHAeBnWVPifQgqfcuxLIWm0kdXDjWhaWlrS8tE809E+Y9ze/sDHze1+1O8fC4P/KTKqTsA69HfQsNw69F5wxCdSOLCwWq1Jnovxgh4cHFQXudw0g4ODYzp3/mDAf3LT7+2zezM2VqsVs9mMyWQiLS1NnRfjNNPBwUFlOMWgJhIJYrGY2o6c2/2Fj2ug92Q8x8qDPsiM6snouxwHnk1+64zrYfHQ39esAuqGXpwJ98yEa54FcoeWdQHJo5RT2P/IysrC6/Vis9lIT0+nsrISt9uN3W4HwOv1kpGRwcDAAPX19YTDYWw2GyaTiXg8TmtrK++//z7xeJx4PE5PTw/RaHScf9XBg+GGZ09GxPigs1gsypg6nU68Xi9utxubzUY8HicYDOJyufD5fMTjcSKRCBaLBafTSTQaJRKJEIlECAQChMNhNE0jHo+TSCSSHpz74/d83M8eqDTEQWBUPcB3gGfhmQWQj25TX1yg//8B8EQVLIfyJfo46VrLMugY+vhsqDhrHdW+k0GmIj8F3JoyqmOFGTNm4Pf7mTVrFtOnTycnJ4esrCwyMjJUCBmPx3G5XKSnp6NpGoFAgN7eXkwmE2azmcHBQXp6eti5cyeRSISuri7ee+89duzYwc6dO8f7Jx6UGG5YjB6fxWIhLS2N7Oxs5s6di9PpxG63k5OTg9vtxmKx0NPTQ0dHB2lpaeTm5tLf309vby+apuF2uzGbzbS0tNDa2kpBQQEdHR1Eo1FlYAcGBhgcHPxE7bMHE6Ngn5X/x0+l6grytV76+tPJtbdiITkc7MdOW28uNscAXZYewIq1I4/YTz1w57OUaFOoP3EGvAgshIpX1tGPne3nzIInAO4DWg/8z9oLDkaVquLiYi699FJKS0vx+Xz4fD4yMzNxOBzYbDbS0tIYGBggHo/T39+v9s9sNmO1WpVHKu+ZzWYSiQQmk4n+/n42btzI3//+d+rq6mhoaKC7u/uA/r69YX/d+Dk5OfT39yuVqv2J4deE2WzGbDZjt9vJyspiypQpVFZWkp6ezsDAAG63m8zMTDweD6FQiJaWFjo7O3G5XGiaRmZmJgMDA9hsNrKzswmFQmzZsoWBgQEyMjJIJBJs3ryZ2tpaWltb1e8aLQU0GoanhPb37zeZTASD+zc1OIE91S8Cf4P1eWSyjkx7AIDq5ythJfA5qLh8HXb6Cb+ZA/cAnyuEuRA7A3gVoBqYonutV6EbVsBOPxV/Wke1KRdKr4C61cDWA/rrPm2YOXMmixYtYtGiReTn56sw3mq1qtDPWA0eHBxU4aB4r4lEgoGBAQYGBlTeTm56m81GWVkZpaWlhEIhLBYLbrebrq4uwuHwOP/6gwPDq/FpaWlYrVZyc3OZNGkSxcXFVFRUUFpaqrxOyZmmp6djt9tJJBIkEgnS0tLUewUFBcRiMVwuF3l5eSQSCSKRCG63m7y8PPLy8sjMzGTdunV0dHQQiUTUuRdjKdeBEUbP+uM2IaQEVZJgBfzw7jzomEfRYbXJb98D/BQ4Cjouz8ZMHFYDz9wHi6/gJ3d8m/8xXQY8DpTqn3kqBqXrYP6Ckd9Vt3boOxeg51yfA2Jj9eM+dbBarVRUVHDllVcyb9483G43Tqcz6WZJJBL09fVhsVgYHBzEbDajaRqxWCypiDE4OEgkEknyUmUbAOnp6cyePZupU6disVjYunUr1dXVtLW1EQwG2bZt20EVJo4l9lSYkQeYGMqsrCyOPvpo5s6dS35+PoWFhfh8PiwWC9u3b6elpQWr1YrNZsNmsymjCuDxeAgGg9hsNrKysgDw+Xwccsgh9Pb2Anr0kpeXR25uLhkZGdTX19PY2Eh3dzf9/f0qcpGIxOiVDvdQh7MN9nSux5snO8GM6rlwxky4CirmrdvjWqcf9ihPLzyf9hMnw4udlGsbaFtxJj2nwhKeJ6I5udX0eXh1Memso6JkI/2aCzMbkrZTpnUADmA22zfPghlvQfYN0PEksHFMf+mnBV/+8pc54YQTmDNnjio6xeNx5XmIR9Pf309fXx+JRAKn06kMZ39/P/F4POlGsdvtyvACxONxZYynT59Oeno6TqeTiooKCgsLqa2tpa2tjd7eXpqbm8fzcExYGL1Cq9WK3W6ntLSUvLw8srKysNlsaJpGNBolkUioomBvby/9/f0EAgGysrJIT08nOztbnUerVWfc2O12BgcHaWtrIxqN4nA4CIVC1NXVEY1GsVqt5OfnY7FYyMvLo76+nrq6Ovr6+giHw+oBazzvxgeuPAz2lBM2LhtvTDCjWk7FX9YRx0z14ZVwLVRcONK4FtDM2hdmksDMkaaNWKjHZh9Q79sZgPmLqThmnWFZP6DnYLcfPguuhZwLd9JePhlWQcUx66g+aQHUAIGzIJ4yqh8Fn8/H4YcfzvTp0ykpKVEFJ/E4jKGcUG9isRjxeByLxaLCemMaQIolFosliQuZSCSIx+Mq92c2m5UhdjqduFwuwuEwhYWFWCwWGhoaxvHITBwYjY484CwWC3a7nYKCAqZNm8aUKVOwWq309/cTiUTYuXOnqto3NDTQ3t6uttfd3Y3b7cZqtWK1WlW0EQ6HlUFMJBKEw2H6+vowmUyEw2HC4TDxeJy0tDRcLhcOh0Ot29PTo1JEoBt8oW/JP7lGBBN9EsIEMapzgBORsDuBBdbfBxcdQ/XySghHYGU6FV/TjeTrfIZLWfnRm2yEbny0bJsCcRPMCILLo78X7oSLsmi/aDvwf7CyiuqFFuAFmHGiTs0KVMG7f0WnXwXB9U0IV+3/n34QwWQy4Xa7OfHEEykvL6ekpIQpU6aQmZlJLBZTRYjBwUFFm5LXg4ODRKNRZQwdDofKrQqv0XhDSZhppOKAbhwikQj9/f20t7erIoPL5aK8vJxJkybh9XrJz88nJyeHWCxGMBhUxa+8vDzq6urYvHnzfh+jMVEwmjdnMpmw2Wzk5eVRVlbGlClTKCgooKCggL6+PoLBoIoo6uvrcTqddHZ20traitPpVA9AeSimp6eTm5tLWloaXV1dtLS04HK5lPfa19eHzWZTD9Kenh6VAnI4HOrc9Pb20tfXR3V1NX19fUkerXjOvb29BAIBFdWIsZ2ohnX8jaqlCuYCVVBxim40zcQh+wp4BtYumMmJiRfouiddX/8i2GDKIqGZ97jJ0iGOastvy2B5I9xTBM95WLtkZtJ680ybgONg1avAMXDqobvfzAcWnqZnB/KBa4DlVbvfjwIfrAI+h56//fQ3F7hcLi6++GIWLVrElClTlEcqXkZ/fz/9/f1YrVZlJK1Wa1JYJ9V9uWni8TixWExxHG02m/JGxUMF3ThIakHYAE6nk9zcXOWx+nw+EokEFRUVuN1u0tPTsdlsWCwW+vv7aWhoYNeuXUyfPp3Zs2fzwAMPjOfhHDMMr5hLZOB2uykvL2fmzJn4fD5cLhfxeJze3l4SiQRdXV0MDg7S19dHa6vOiBkcHCQQCGC321UaRkLxgYEB0tPTFUVOPGGn04nH4yGRSKi8qcvlUsZRqHQ+nw/Qc+Xl5eUkEgkyMjKYNWsWmqaxa9cuurq66OnpQdM0enp6MJlM9PX1qWtqPNtg94RxNqoe+KPOIzXCQgJW7X5tM/fDta1Uf79yaInTsHYn1aZKIAJn6EtmsgnejEFpEI4qglM1ONvEvBs3Dfv+WrixHH66EOJvwTNBmH2iqm/RAmRD+cMb9H16R1/cj51AwkeXxQmWIoj7gT4+zQWutLQ0TjnlFGbNmkVxcTE+n4/BwUEGBgaIxfTfLRV8CQutVisWi36JieGVNMDAwEBSy6Mss9vtKq9qDPvkBrVYLCqEFQ8qEokQi8Ww2+3K25X3/X4/Xq+XwcFB3G438XiclpYW4vE4y5cvZ82aNWzdulUZ74mAT2IkhlfH5YGXlpaGzWbD7XZTUFCA2+3G6/WSlpZGLBYjLS2NcDhMf3+/epDJcofDgcfjSXrwJRIJrFYrXq8Xj8eD0+kkFoupcD8ej9PZ2YnNZsPhcNDf36+GGGZkZCjvVOhzXq8XALfbrfiuU6dOJRaLkZ2dzZYtW/B4POTk5FBbW0swGCQ9PZ1AIDCiU2uiGNfxM6quKkpCNdjYwK7+AnqeyNeXz4WKWclG9i98iYiWnrTMPMRXXaN9gYtYTeNny/nnXz6j3n+j5Aju1b7Jox9+Faa9DNcshhnD9uHScpKzCFZG4M0fU/v8DVQs0fep+u96rpea++Gpy4YMuQU4F3jk4xyBgwZOp5PTTz+dCy+8kIKCgqQqsLHAJJ6p3ITiUQidSgzowICe/zabzaqdUdIAcmNHIpGkz8diMXWTS4pAPOKOjg76+vrIzs7G5/PhdDrVul6vV4Wu6enp5OTkUF9fz7p164jH4yxZsoQlS5bw/PPPA1BTUzNux9mIfTEQe+uQku4oj8dDeXk5WVlZ2O12ent7lZfndDqVtypRgqQK3G43ubl6F2JfXx+BQEDltrOzs8nKysJisRCLxdQ/gLa2NlXIcjqdymg7HA5cLhfd3d0Eg0HC4TB+vx+/3096errKmWdmZhIMBrFarRQVFdHS0kJGRga5ubns3LmTeDxObW0t7e3tKj20r8fMiE9J778VOBN4HJ6D+sNn6B7pfPQ85lXA2ej0UgNsDGBjgNHgJsTTnA4vJS+/k2t50nQo8Cy4ToZ7gsDPh94tBS4BVgC5MPssKB1OtwK21gLXYZ2vh/bVd1XCte9DzaEw4zx4ESq0dVTffBE0Aiu/iM4akG1PvKaCj4v58+czb948Fi5cSHZ2tsqrGY2q3KByUxhDMiMFR25yuZjFq9U0TYXp6enpxGIxenp6iMfjDAwMKE80KysLl8tFJBJRNKq2tjZ27NhBRkYG2dnZ6p/T6cRisSg6F+hGPD8/n8zMTPLz8+np6aGpqYmuri7OOuss/H4/3/3ud8ftWAuGi5J8nM/IeZCGCofDQXp6OoODg7S3t6sw3uVykZGRgcViwWazYTabFWFfKHFy7MTrlOgkHo8rtoBU77u6umhra1Ptq4ODg3R0dOD1evF6vbS2tmK1WsnMzKS/v59gMEgsFmPXrl2YzWZ8Ph8Oh4O+vj46OjpIJBL09vYSDodVaqisrIxp06YRCARwu9289tprxOPxpFy9HIvxxAGU/nOC5QasHUWw9SY9tF5fBX8E8uHJF77APadfnvyRGogkhfr7jic/vAiuORRwwzSgyAOuKvigCpgGc036PlG0W07AiKHX3mgn07K2EsINt8Il2musPWQml2iPwK/0dSpuWkfF/etIa5kxbNsHL9LS0sjMzOTMM8/koosu4pBDDlGFg1gslsQhlVya3MzGf3LTyo0rIan8Ew6kw+FQPebBYBBN0ygsLKSgoIDMzMykm6y9vZ0dO3ZQW1tLS0sLfX19RCIREokEfr8fj8eDw+FA0zRV1BIDLh5rWVkZc+bM4dBDD0XTNLZu3cquXbtwuVzjfOQ/OdLS0pIMqt1uVx6gNFDYbDYGBgYIBAI0NzfT1NREOBxWx8fo+YmHL+G70+nEZrOpar0YTwnxLRYLTU1NdHd3Y7VaKS4uVk0EWVlZ6iE5efJk/H4/Pp8Pv9+v9k++JxAI0NfXp9gC8lCQZoTs7GwWLVrEEUccQWFhoWqRnSg4QJ6qB7gU4s8SC5wE95jgV2/BjVX62zfCWU1/hg8cuz8yQ4Np1fztktM4j8c+2dfOAOiC9S+A70SogvJZG6idvxDCwIxl+nrr1wDHkBT+z9b3u8DeRPVvK+FOwAGn8TcAHiq/AtCfiNW3V+qe6rUxmL8Q3t3EbkGXgxOHHnooV1xxBYcccggOh0N5A4AS3BDalLGfX7qiJJwfrj41mt6m0KmsVivhcBiz2UxxcTE5OTkkEglyc3MpKSlRxS6Hw8Hg4KBqhe3v76ejo0NRsgCVp5X0ghhU8ZDFiLjdbqZNm4bdbqevr48vfOELPP744wf+gBvwSUNSCfnFuGZmZpKenq6KidLPb7FY6OvrUx5gIpFQnqeRiC/HSR5KmZmZKo9uLFpZLBaV8hFPGPTCZn5+Pps3byYSieD3+4nH49jtdsrKyujr60PTNMxmM+np6UQiESWYI0ZS0gESsXR0dJCenk5BQQHHHnss1dXVbN68merqagYGBiaEqtkBMqryNU54zgS/uh1Yxtpb9Gr8D7iNf5i2AYWw/jyqz6zUG5voU7nTjw2HBsubgAWwMg+egVXfPY8ITq6cvYqKB9dR/ZVKSh6sof6KxXoKQrAKePVZVBJ2ORymvclXeFAxC86qXc2TplKqnQshugqog7lVVLyzjuoPK2H2FwE/8NAn2/9xxLHHHstnP/tZRYkRA2nMecqNKjeisdhkrNgbw1HjMrlpYbe3KwZ40qRJFBQUqDBUCisAoVCI9PR0ZSyKi4tJS0ujtbWVbdu2EY1GVeU5Go0q70dufiMHUryu0tJSXC4XmzdvJisri6lTp7Jt27bxOfgfA8MfUGJMJQqw2+2qw81ut+NwONSDToxgf3+/SgXIA1EecuKlBoNB1RYsDzZpJZY8qcPhYNeuXXi9XsUXljTB7Nmz2bJli4oSNE0jKysLp1OP5np7e0lLS8Ptdqt9EyMrBj89PV3tSyQSUZSueDyO0+mkq6uL9vZ2lYcfTxwAo3oF/DEPlnYCTpgP+do5tDjz1Bo3cxNXa1l80fRP3eN7KsID2qUUsIssOkds8Q9cwFzWs565nMFfWM/hvM5n+DZ3KyP8ytT5LJq9liM3vswk/kX21zq55JrHwQ7PP7gEgHkPruX+3q/j/P4AZSVbdjcIfM1OhEOwGHICv+IbpNOnXv8PP+FSLZc4Zl7nGG4z/QjXUp0oXTFrHdV1h0Lpz/b3wRxzuFwujjvuOKZPn05nZydtbW24XC7lyQi31MgZNOZNxfMwtkRKCsB4sRsLWkZkZGTgdruV0RWDLEbXarUqAnpGRoaqHtvtdkKhENFoVDUHCEdSjL/RWzYyBaRdMz8/X3l044mPmxM0Vvm9Xq966EyaNEmxKTIzM8nJyVEhuMPhUKpgUtwTkRQxtpJW0TSNzs5OVfEfHBykt7dX5a89Ho861uKRSrpHjHBubi7bt28nHA7j8/lwu934/X5cLhcWi4Wuri5lpEOhkGIGCJ1KqHNynQUCAfx+Pw6Hg+LiYmbMmKFSU1II3RvGii1wAHKq98Ey0PVL18FRkEkAoo1cNZSUtDFAAc04Al2QDbybznQ2k0vbCE/1Rm7lLtN5XPzYE9xluoFF/1zL1S+v5FGTjX5sar10+iAKb5tyOJZXmMo2nVvaDwt4m6devoCZbMLeDxxl5bO8xHk8xgm8yPa7ZpFJgMYzy6l+pBLQOD3x1xG/LJc2CmhmAW/BYghn5xBBZyk4fCEONoqV1Wrlggsu4KijjsLj8WA2m1V3jLHlVOg1In4Si8UwmUwqhyc8U/FwJXQTDqvf7yczM1Pl9yTsk5tBqv/RaFRxX/v6+lSbq3Auhc5jLJgZ1Z2MhTDxgGR/Zd+FX+lwOPD7/crYT1SMprIkuWmz2Yzf7yc3N5fc3Fx8Pp8qPCUSCeXdCUtCjG92djZ+v1/RrWT9SCSi8q3RaJRdu3Ypbiqgwm2fz6e0c4VCByRFJ3a7XT1Y5RzJucnKyiItLS2poChGWq4leWAYO7lisZgy2qKGJg9y+GQFv/2BMfRUnXD29bq8XvQFePE0PY/pgx09pcBa3nj6RDh99yfu936dgQW6YbTvodpvJgFHleu0Jh6Hs8/jje65HD17PXB30rpVtddTZaqkgWLuXv4/+sIo/GD5PQD84FH9f+0RE9wFJIC58Ktrr6J6WiU89RY8VQuXXkTXSYXwwui/VIpYLLyd+m3X4cjuJurzo+eSD56mgMzMTD7/+c8rQveUKVNIJBLqRpGwT4ogsLtjym63k5aWpgyXtD3KjReNRikqKmLatGmKMtPd3a28CwnHJRUgxth4kxqlAoUKJK+lY2pgYIBgMIjb7VbhsBhVY15VHg4yjQB0jYFQKKRu7omI0QRGxNsWtoPkpwFFjwKIRCJ4vV4cDocSnE4kEkr2T/LiAwMD9Pb20tnZicPhUJ77zp07yc7OZsqUKcpghcNhVQwzmUxEo1F6enoUk0O+W+hbYvwl+ujp6VEPgi1btqhzIqkH2K0BIEXNUChELBYjEomoFmVZd7goy3hgDI3qYihC70bynagbnTUxuNRK9I9+WHUia09P7nC62PQoFFmh8VWe1W4kl7YRW93FJHhzB9aOLGLvnsfnlzzN0a+th3xGaK1+htfh2tu5e/le3HxjXWI7aI9ncPnp9/C7d78F8+tg5b2w8Jt7/Li+3wCHwrSNRLEAEXRx7aqP/u4JhK9//esqzNI0LakSbjR+0mooN4yE1uL1ieck4Zoo+peVlZGbm6sMpoSX4qGK1yUcVwnPAWVgJfQXj1U8GZPJRH5+PvF4nEAgoPZNtiv7IsR2YRxId9bAwAChUIjOzs4JPV1guBcmDw7JV0ohqqioiMmTJ2Oz2ejt7aW3t1eR7+PxOF1dXUSjUTo7O8nMzCQvLw+3201fXx8DAwMUFRUxZcoUfD4fb775Jvn5+eTl5WE2m1WKRsJ9ob9JJBONRhWLIxgMqutBWlKN3VexWIzm5mZMJpPaT0lbGMV2xLA7nU5ycnLYuXMnO3bsUO3IGRkZexzbcqBbWsfQqPr1Ds571nBycxfPmqYB8Mr9X0nKTSbBYaW8YQO1zoV73Or9fJ15vk3EVkH5dzfweu9noBEefuHsEVxWMwm4M4JphQZxuOYbt3H3Nbs9VgULmE7W9IK9BfLP2c4Snt/3n+qwUtGwjmrTyTrfdg3A+8Bb+76NccaMGTOYPHmyMmzGHmtj7lQ6mgBlYAFVDDJW8mW5VI59Pp8ybhLWi1crIZ94kWIwjT3gkpuVbivJ30rhTFofhalg9E6NxTZjvtfYEZaRkaHC4fb29nEveOwJww2HeH6iZyrFIIfDof4Z500ZlaDS0tIIBoP09vaq8wOoImVmZibl5eVs27aN4uJiVdDyeDwqOpC0TnZ2NoFAALPZrApGPT09SYZfzoNU8c1mM729vcrA9vb2EgqF1PkZnnOX7y4rK6O7u1ulcSQ1MBEM6xgZ1avhuSw46S0qNA8FfMDxmu45rOIrAFzMw7gJJX9sPtSa3gNmJuVSNzOdf/I59fqW7mv5Yead1J50mC48fU0tm86bqbenGuAjwJPa2SQw8xYLuOv2G7mn/wdQB83P+sj/UQ/sQj8KVcAM+O7Dt3KXKYuHuEJPXaw+Dy7aBEv38aevWQ2cCKsPhYv+vM9HbLwxZcoU8vL04uHg4KCq/hoHuwnPUcSKRSBDcmVGFSqbzYbT6VQFCfE0BgYGCIfD9PT00N/fr7wY+Q5jJ5aEi0aNAUknGDuv5DstFgter1elGyRnKp8RIynetORWrVarqpBv2bIFl8s1ri2P+/LdYiTESErrbklJicoLyzGW4yj5SNDng5lMJlXwA9SDTP6ORCI0NDQoYylFInm4SncV6IXCwsJCZSSbm5uT0jfiVQvXVXr5MzIy1EPT6XSqCEYKibIvxujG6/UyefJksrOzVU7dbrerfd9T6H+gDOsYGVWrHvYvXcBDzOFI04tw6u5qP8/UMldbr4fnBjz1yhLO+Pvz3HLKtUlV/6sSv6bLVah7vs8EuUJbyXXdNzOHjVz87hOwqpyz9dkoIyAUKBsD3DUbNadqkjuAts0E/wtEQbvZhOk+jQaK4blLuGbJbdxjOhp8i+HVmbx9zJy9/+w7gfBFVNy0jh09VqLMQdcEmPhTBRwOh/IAAdUZJZAqvsBY9RcvRMZqiNESQyoXu4T64hnJ9xonAEh+VIxrKBRS6lgej0cZDNkf6c4xGnfp9BGjatQmkM+JMZBUgBgJKYaNN0bLDQ43CGIknE4nmZmZav8zMjLo7+9XpHun06ny5Onp6WRkZJCTk6O8/4yMDHw+H9nZ2aqHXzqeBgcH8Xq9zJ49W1GfpGjkcrno6uqiv79fFaJcLpdqGZYCZygUUmIooqVrvG6EHmcymcjMzFSfk0hFjL/QuCwWCy6XS1Hndu3apdStGhoaVJpq+HEzFq5k2cHVpjo3CKzhyOc2AhG8T7QA0LM6H55p1ZWohqGYBtaeoudZf8L/8KT7IpgG/neb4Fao+O46qs+v5D73d5gdeoefmW7SO07rYN6tm3ijdu4e21mN2waY98dNmC7X0PKGDupf4bi/PcfjxZfAT+EC/sA9fB3+CGuPmTnqNhXiusxgxXd3axZYLAn9jVHywhMRRtqSUQRFPCGBhPjGMFI8Wgn7pcIrraJSQJGQXMJ8YweQhP3icckNLamH3t5eHA6H2gf5rORXjRV9YQ0Y15UCldzI8p6IvshyuSGN6lsTFXIMhaIkxaZQKITb7VZG02KxJBndeDyOw+EgOzsbTdMUH7itrU2dT7PZTE5OjjJE6enphEIh+vv7aWtrU3OrnE4nkUgE2J0CEqMr/FKhb4VCIaUHIPlS8VzlwSvGVI69XBtyXYgQi8mky0cODAyQl5dHMBgkIyODrKws9RvHC2NEqaoGHgOsOpH+3XR6HB56luXDc3Cy1sYC3gZgABsXsZpz+JOiWP2IH/KkqUj3/NZDIr77pi5/dAOENeawkbSWXn6342K0b5lgrt7vv694+5Q58C40rfCrZS91ncwVDT+HZ/R87NvaYt5esg8e6jXQYprC1s5palFxRgPceB56j+woQi0TCBkZGZSUlCjjA6hJmeJdGqv64gXKDWvstJJ/EqpJ3lM8DrmZJL1gtVqVkr8oSwkVyNiR1dvbS3t7O729veo7BLLdrq4uuru7VfXe2A8vkLBfFJdkPTH6EppOnjz5QB3+jw1jA0VaWhoejwePx4PL5SIzM1OxM7Kzs5VR83g8uN1uEokE3d3ddHZ2KqUwIdXv2rVLqfELzUxEWKR9tLOzk46ODnbt2qWiDaE4CQVLJqxK9JCZmak0dyVqMFLXpDFBjKsI4hjbneWhKPlioXoJj1Ym9crnjPoTxuN2IDAGnmohLF4Aa4LgOpGK09dRvbYSVqWz9pKRHl8IN9WmQqjKY3vVTBKamacXnQ8r9MF+1csrk9a3kIA7TTx6zldxrOziL5zJZdHVPPyns7n45Cf4n2d/sk97aSZBfsN2iv7eiYYJLHCIfz21Tx/GWY+uJoFZrbc3PHvHYk4OrCH2hAeGyRdgOQ3iW5nInNWcnByOOOIIYKTAsZEwb9Q3dTgcWCwWZXDFyElYZ5yOKp1M4v0ZJf2kiCLeq2zH4XAoD0ioXJIOkM+K6rx4peLNSKVZbrzhUwgk5yodRrKteDyuREbEK54oMIar8qAQb93Ynut0OsnLy8Pn82E2m5UuqhhGobrZ7XZ6enpUykSYEMZUi6RgpKDY29urKFDSYGHsrBuuf2s0+jNmzFAPWHkoGulWEpGIHqsYYPkOeUCDrr8qwiudnZ2qMCb7abxuxyM3PgZG1QlHAWv8EP451Xd9R6+ID6GBYl5hEW5CTGczF8x5CmbooiTVVZUcadoIBCl6RRSeNtHjWAcXXUQcMxYSeK9qoWd1PtGT/Dz7ppsF2hre+sViLv6Yv+bH3MjX3vwDvb9Iw+WIw68fh2mH8eTKi3iSIeWpO2HtCbsfBn/hDPpIliH8In+j4v51VJtiVE9bAD50cWuAeIyJbFAFRuMppGpjtdhYFTYWNIzFLGEKyI0gHqTAWE2X0E/yrkbCvrE335gbk06eYDCouJZSLJF8nqgW9fb2qhycUczF6N0YearGsFW85ImCPXlcxhyxFAONHrwo8H/44YdqyoHkvMUoGg2VULImTZpEZmYmAM3NzWpirVDgxBiKZy9Rh9HzF88SUPuVkZGhcuThcJhgMIjdbldpCknlOJ1OotEofX19dHZ2qmhFZl35fL6knGsopBe8Ja87mpd6IDEGRnUr/PRZoBY4BgzsqBBuzrjseVg5dKN8YIIPfgy33gDoMnojMVToWf1jOlctI8/citseomf9kP4q1ewQdepnYN5rm/jbMSdQwN4HwOXSCtPA5WgDbobFVWg/MMFQ0X7S37bR8lCZWv97/Ix/mXJ0T1ywZgd3PXcjVy35GdV8DT5XNfTGHLjxLODHe92P8UZPTw8ffvghn/nMZxTdSXRIjTOjYLeKvITzYrQAlSIQniLo/NZQKJRUMZYZSLm5ucpLNXqjkiKQMF28MAlBm5qa8Pv9ZGRkkJGRocJdTdNoamqiubmZUCiEzWZTkoDSbSO6oNLSKp6VGBuXy0VOTs44nIXRsSfjYCy+hEIhJd4sPFEZ1JeWlkZnZyexWExNSpDClFT9+/r6FMlfClNisNxut1K1kgq8UJmMVDb520iBMoqFS3txIBBQedyuri5gd+eVGMRoNKquEZEkNMpAms1mPB4PfX19qvAmY8vlPMoxGo0JMNYGd4wKVY1AIXywQO+DX6uH8It/8Bas1HAEuokW+fndrIv5q3Yaz5jeotq1gIpvjWJU35wHgXkA+MwfArryPsho6W/SbuqkRiuBa+6HhU4atOJ9MqoFNHPcJc/x8rJDeFZbw0kvm+BReHVFJYvOWQsmuEfT4/k7uZZ/mSbD6kOThhFW18+B0lf5FZfAsixYWqW/4UCne/Ed4D7YEzd3AqC7u5t///vf+P1+dZO4XC51Y0lBSkJ4IKkQBLtDdAm/IpGIyrG1t7cTCoWwWq2EQiFcLhezZ89WhtBopIVQLp1A4gmLkRUP1uPxqFZXKYS1t7crUQ2n00lWVpbix0oBDVCG1OiNijcUj8dVkWciwqhhAPpvaGlpobu7W4X1wvmMx+N4PB7VhZSVlYXP58Nut+NyuZgzZw4ej4eOjg41Y0pEWKRrSRgdIkwOet99S0sLfr9feYexWAyXy5VkVC0WCz6fD4/Ho1pkW1pa1LmxWCxEo1FFh5JJDj09PXR1deH3+ykqKiIWixEIBFTzQDQaVQ9VoVMZOc4fhdEYFPsbY2RUm4DLAKh+ulIPh1cDL0KJtpl0IlSH3azgcr7NPQS0y3m1GKoduvF1LO1iircOgJIFNdT/VleL2v7bWfrmOwACcNKh4AKeyeIknoPPzeCVF+btublgGAL4ePnHJ3GXdiUnLX9ZX+iFE3tewLu6hef+dJJiE2xmOlx16IjprhUlG6kmDtPyKH9wg+rqipBO/VUzOFjaVF9++WVVPZ08eTKTJk1SfE0jH9KYX5WwX4yeFChsNpuSaWtra1OzhsRLnTlzpvIoRFZO8qlCUpftSCOC5FfT09PJy8tTavGSdujr61OdPeK9yBwmMTTScy40IglTYXexS1SQJirx3wh5CITDYTwej+pI8nq9hMNhOjs7mT59OkcccQQ7duxQoip5eXlEo1FqamooLS0F9OMqufHu7m418sRmsxGNRtE0XZu2paVFFYukyCgPPJPJhN/vx2KxKCEUOT/hcFilWLq7u1VhTeQAhXEgeXGv16s6u2R8S09PD93d3fT09BAOh3G5XOoaEuGc4XSq8cAYdlT9GGafC7wG05bpY0eOAtuQEhS3WlnnXMjFsxfqzKPGKliuvxW1VFG9OBNOMkEA6KgybPdzwELIPhQs4FrVzoaMQ2kjj3+/sGifDSrACQ+8Ds/Ad065D4A/rziZs57+f+CDG7RreY+5XPm9VVx3x82sO3whhv6DZNy5GGZD7dWHDUkWMrTff0XPp05cL1WgaRrr16/HbDZTXl6u2hZtNpuqpotOqkjmwe7ZUSLTJhe0LItGo8o7CAQCeL1eCgoKkgodYqQlXJTcqISD4j3GYjFyc3MpLCxUXo2EhD09PcRiMdXbLjlCKeIYdQNkmXBrxYAGg0F27txJfX39uI65NuaS91RsMeZVY7GYmgsVCARwOBxMmjRJRRPSXiopEMlZh0IhNm7ciN/vV96vRAcDAwO0tbXhdrvp7e1l165ddHd3J4nphEIhpXQleVFJM0ixsLu7m+7ubiWeY7fbCYfDKrcqqmLSlSWpAI/Hg8lkSiL1GyONQCCQpOsrWhLCMx4vMRUYU6MaQ81s2vpzCH+H/Du2U2tqg1tPpOKGdXTf4KOtVZoCvsdg/uuQfaI+uTT8CHAy8CLMrSLtuV4G12TA0id1ltKQ1Om6jEqeMrVQQQvXu9brRbIOYP1aKNXTBt6aFnpm5+8e6GeAdrkJVoHpfE3PKJzxKlDID613Dqn/v8rP7vxfKIL8O7aP+kuFn1p9UqXeXOBA9847TuNgyKkKmpqaANi1axeJRELJq4ksXHt7e5KSlNyIEm4XFRUp/ctYLIbFYlH9+Fu3biUSiTBjxgz8fj+hUEip/YtxFBEOCdVlIqpAQlHhWxq7oiTPJl5oRkaGCgfFgMoDQW7+UChEe3s7gUBAjfbYvn07ra2t6liMJ/ZmWI0IBoNKLs9isVBcXExWVpairU2ePBmLxaIMnWgc9PT00NbWpvKvg4ODSvEpFouxbds2BgcH2blzJ5s2bVLXg/BaJSUk3rJENVIwlNE3ck48Hg/hcJhwOIzValX5Xtjd0SV5bZF2FE9ZUkJut5uOjg62b9+O3W5X22xubqanp0ed6+FE/wOFAyRS7YRsSGAB1kHgRECXAMzMC6i1qrFCRyt6TnYruspTBRXvDYXc50H1qrPAMJvNR4AgQz/kVtCqTfAbME2/iTU7rmQAG5//7CuwNcKptX9P2qu/rT4XjofaZUX4E03kmVtBS6d68xT46dBKSxeqoX9G9GNn+xWzYBnkLNhJ+1cmA+/rHnTSRI6JX/kfjng8zvbt2ykqKqKgoICysjKV+0xPT6e3t1eNzRBvSEYM9/f3K68yMzMTi8VCXV0dbW1tii/pdDqVQTRSnqQqLR6qzC0y0p4GBweVByzhr7EF1dhcIJ81jv0YGBhQBavOzk527txJc3OzKqhJiDvRwn+jYTUaW2MzRjQapb6+noGBAXJzc5k0aRImk4nu7m7y8/NVV5Uct2g0SkZGhqLHRSIRtm7ditfrpaysDL/fTyAQoLW1lc7OTkWqFxaAyARGIhFaW1tpbm4mOztbnXcjZ1XEw00mE1lZWWo4YFZWluK+RqNRVUATD1QYAZ2dnUpXQFgbEkGJGLl40MPzzgcaY2hUhdoRAyphmYabEO2nXg93vkVDVRnhFTn6CJLFVipeWoeulL8KXYDVini61aYL4Rmr7qE+twamLVbfci9Xcz630QRwTSOmizT4OsCPWTzlrd2pBeAZ08ngWwCBe4EQG7Ry5jq3QDQGPEYX5w1t9f2hfSmCVS9QLZywFVbKL9fzpgPYYMUqWDGHdsqBNeAaWm9i1jg+EmLQTCYTRx55JDNnzqS4uJhJkyYxefJkVRmXCrPX62XDhg10dXUl5cDEYxE1IwkRhfokpPSMjAyi0Sg7d+5MkhM00qzE4MViMXJycpg6dSoOh0PdYNKgIBxG+aymaeTk5FBUVKRGwQgVKxwOEwgE1ARWmRAKKI5rfn4+9fX1E1pXFXa3DhvDeskfd3V1qZSIeOegp2UkzE9PT6etrY1IJEIgEFB5WWkTzs3NJS0tTYXoco7y8/Npb29ny5YtTJkyBYCOjg4V1ovnLx6p3W5XxUKhcUkjiWg8yP7JSBaHw6EKUWazPr1VUgZ2u53c3Fzl4YrBzs3NTfJ8x8uwjp1RPekGfUTJra1QlQdvwvY3Zw2F1M8Sfq4Krq1F90hPBqBEs1H/2+th+ZPAkUAdrLoMllVBTdWQBzhHN67qB+hezIkrgOWPw+ogUAWuG6Dur3DRaeCogpVr4dp5elj+zDfhTYCHDEfAiv6iD51TZQVygUuHlv0MljvZdsZVHJK3GTchSrSjqK+YATVBfZ0wQwpVAE/CtLNg63fYPcV1YsJut3PmmWdy/PHHq0otoDpcbDYb/f39STenjMzo7e1VRHpA0XHkhjGOwwBUi6FI0vX09ChhFpEaFE+qra2Nuro6IpEIvb295Ofnq1BTuKp+v94RJ16N5FEHBwdpbGzEbDYr8RAJjdvb21Xu2MjrbG9vJxgM0tfXR05ODm+++eYBOwf7AmM4a9RKmDx5Mk6nk76+Ptxut6KQCW1MPqtpmvLWpTkgLS2Njo4Ourq6klT8GxsbldyjRAbyMMzIyMBms7Ft2zbVDBAIBJSmQzgcpqOjQ1HXcnJyKCgoUHPAxNuUh60UE6X4JXKOkl+V/S0sLCQYDKrcbFpaGgMDA7S3t6NpGocccgjd3d3s3Lkzidkx/LgdhJSqQph9Ga4n2inOaKB6ZaWe5ywdens+ML9KN653lsMfyyl5SY/n04kMdVGdNSSh16p/bnkVnKFBowmwJu31lfyGXwM312hD24aK+9Yxk024CLHqWhOEYbV2FmuZxwm8yDlX/Ymo714Oa6tF22Rie3E+R/EW2bzHrv4CehxVeophRoQK7T29kn+Fvs+5ebvzqulE9Fbapzxw6slUnG6gWn37LLhnE5w0E56b2GLVOTk5HHvssapVFXZP0hQ1Klkm4brVaiUnJ0dxDyUMlwqvGFYpGkgLoaZptLe3q8JGYWEhgGp5NRYrSktLOeqoo1QeVyrRoHdcZWZm4nK5lPqS9KgLM0CMivSMi2q9jEIWXqZx+3l5edTX1497BfmjYDQMZrOZ3NzcJJ6meHkOh0PlJCVHPjg4SHNzM+3t7UorQHLNwWBQjSiJRqM0NTURiURob2+nra1NdVg1NzergqBIJGqaruAfjUbVvLBEIoHb7VZ8WIfDQU5ODuFwWD2EZb+FsSFRhXBh5fdmZ2ermVTd3d1JQwnl/GZkZJCfn09jY+Mej9uBwBgYVT/cqve+Vz9UCS33wUlfBEcRROENbS5HL1+vO6hDXUehhJv6llIoGoD5HiAGa94C3obFFTD7ZLixH2ocwErd+xvyVgP48BCGZVB+9wYW8Darj7iMapdOz3qIK/QVrUAcTtBeJHq2H/gSpiVVaAtMlDlaaD9zMu2uyTD/BTg7n7cPmcORjo1Um0pgZRbcGCW/cJc+CgaIY2Zb6zRyTtlJ9ikdI46C69Z2wvdUw6t7EWOZAJCeamOV1Ui4NwqQSKeMVNRFhV/mGiUS+ihp2ZbNZsPn86lwTUJE46wp4ywjYQLId4hxkDBUQlf5XsnXCRldqs8ul0t5zZJTFe9FKEFS5DI+DIQcL/Pu93Xe0YHAaJ1VJpOJnJwcSktLlUKVLO/v71ek/p6eHqLRKF6vl+zsbMLhsOKaut1uYLfkoxyf5uZmNE3D5/MRDAbV+RbdWY/Hg8/nU80SXV1d9PX1qTlUoVBI5cWj0Si1tbW43W7liYp6lqSWRG5QOuekyBaJRKivr8fv9yvt3XA4nLQ/XV1dKj3wKWxTNaAFKLoCGjup6FtHtamS73EHJXfUUP/DGcy+4R0+WHUEXTMKh7inT8O7XwSa4IyFULNQpyZ9UDWkrD8EQ86ysncdoR/n8p1JJlgP0XK49J2VI7Ra5z29ibLTP6SAZta+oBu6eZM2sWzFb1i1/kq0FSaeXvF5znjueTgJjmp9k3/0LeJOruUfPzwdTnLQUlcGoe1kEqCPdAbzf0u75TsQg/YNk2Hl7u/z39Okd1T9FHQu1sTVVpULXC5Ao3qUGCQxSsYbVgpCErYL4TwWiymeonijiUSCmpoatm/fjsPhUDOSjBQfKSpJLlPU/41tsC6XiylTpqjwT/KqHR0d9PT0qFzrwMAAHo8H2N36KoUuSS+IFqs8IGw2m5qk2tvbSywWY+3ateNzUobho1pVRQ1f9GSlQCR5bCPtSDifJpOJtrY2urq68Pl8Kh0jhkgEbmRkSWFhoeIB22w2NecqPz+foqIi7HY7jY2NSsVfHmh+v5+BgQFaWlrYunUrgUCAjIwMXC4XWVlZKpUgnXEZGRl0dnYqIZ+MjAzi8Tjt7e00NjaqQqdR1Dw9PR2v16u86b11VI01xsaoWnb/769rostSCNTDH+HVE0/Ujdot+irzoptgq0aV9n2qTMvhxnQuumUNq03lVGjr9ND7gard274GPXUwVEMIL8vhi396nGeKz4G5cOPf/of5rMVOf5IM4PDRLQBnNa/moduvYOb1m7iOX3H68n+geU38WTuZs875f2z901Ru4wfcdssP2HjLHJbNeYyW+mIySwLEMYPlOzAf2j+cDCuAxXDkeS/z9onH0fVB4e4vKj0U6iauUQUUrUmKVVIgMEKMnYTSRgEUEc7o7+8nHA4r7qGxOm82m+nu7qahoYGysjIKCwuTjKpsWwya0WMG3Th6vV41Ulryb0ICDwQCdHV1qUJFLBZTFW9R+Jd9isfj6sEgLbUWiwWPx0NOTg42m42WlpYxP+4fhb0ZBXnAibcvx0OKQaL4JblHeZBIjtxkMtHV1aU8dPEUJY1i1MmV14CaSZaVlUV2djZer1d5xfLA1DRN/W02m/H5fIpZIVGBRBxyvQFKsFyuATHiVquV1tZWBgYGFE9ZrhuJaIxjfmQ0OXxaxqnEh/0/hJzzdtK+cpik2nLg2rt1gzokVJLNsHA6H1yLh3K0dZVwa0xnXfEiZJ/MM6Zz9NyrBW413Qw8AquWjaqKZcT/8BM6rs/metN3OEX7f8xavh164EvLn+XoP/2LK02ruEu7ksWsYQ4b9a6w0lqqn6mEU4NwD3BGDE6yQhQcP+2imAbe9hmPxe0QuH4fD9z4QPr7jZqj8r9cmMYbSvr4jSIlUomWkE2k3kTdyO12U15eTm5uLtFoVFWLhU0AKGJ5X1+f+qyx00a0AWT/jPoEMgZFPBwREJEiiOSGw+GwMjByQxrHrshyoyD3gca+SNZJqkT22ThmRgp/ojwlzRQDAwO0traqh5zkM2VOlNfrTWrhFV2GQCCgxlqLwZRUTmNjo+rEstvtZGZm4vV6kx6KUtwSpkAgECASiajzJikf8bQBFe0MDAyQn5/P1KlT1aicRCKBy+UiFArR0dHBwMCAkiiUiGP4A8lIszoIC1Wjbb2R6kcqyblwJ7zYyW+4khN4kQseeGponePg1SlQGoUVcM/RP0AKO609uXBqFWGqqF6YA9dAhbYRgOqck6HjMeCLVO+YyYzl9Zje1KBmGade8qd92sWZbOJljmC26Tn88XQ6/1kEf4bXl59AsbaF7z70G2Wc1x42kyNa3mGwDljv4Y3DhkSxq/VtzVu0iSezLxoi/8fgVitwMgTe/8+P5RjCeJFJUclqtSptSuO4EvFcpMBhrLIK3UXWFxK4eH9CqWlqalLUJmOoZuSUCq9UiihivKV7CMDv96tw0GKxMGnSJCwWCy0tLSq0F2EV2G20hVsr0w5k2729vTQ0NKjc5HjmU/cldBXDKsdMjoN44VlZWapFVIyczI2y2+2qmUIG/onmghSA5CHrcrnUTLFAIKC8T4lSOjs7VX7UeM0IDxlQtDuPx6OEbIQXLK3Ioi8g/Fd5qEpIn5+frzRdu7u7lXxgR0eH0jgQucfRGicO4kKVAXEwmxMcp23iZZOV9osyYFkWv+/8MqVZdfB99Fyqax4Vx6yjukk3Xre/cTXXm365ezuLq7jupZt5jPOo/+IMOAuqH6mEjlfRp/WtpMJUq3uMR8HvtIuZx95zYZuZzn2mS4AuoJUuy1ZMMzS861tw20M0VpTrYb0B7+QdAXnJy+YdvWmIovUk+drhZBJgR08pUWph4QJ4dWJTqsRzEeNllMWTirKsJzeTeBdGbU+hT4ksn/BSJXQUo2o2m2lpaaG3t1cZAgllJc8q/FOjDqvc4OKViJaqiFxbrVZFsRJCv5DV5caS1IC0sUpoHIvF6Orqora2Vo0jef/98XkYfpIWSzmuLpcLm82mOqbcbjddXV10dHQobQDxLMVwZ2Rk4HQ66e3tVSG1kOk1TSM/Px+n00kgEGDz5s2AzhgR3rIYYOmiA5I0dOVaEg6thOfSKivXj1HxXx6WklYQ5TNRsJLx2ZMmTWLHjh3K2Et79Hg2b4yZUY2QrvP4r4ef8x3QYF6xGJ8hdGhYO0JMyzLMcFqFyrcqrIc8WvkcL/LAMzOo/mEl/BH88Sl0WeLo5NDHeOXZuz9W738f6fBMFtrfsmla4adoUSes0ug5Kp8eVz6rqs/Tw/6PwG+4Et6MwDXpcM9W4HDDu+5h3VUTF2IQjYpQcqGLkr+xP9toTCUMNYqsiGcr64qBlrDSyBgQAyI3nsjXifEWTwZIUreXCQTCXRTjLA8Io7iGMVyW0FgMgOT2REcgNzeXpqamCatUZYSRxRAOh3G73bhcLurr69mxYwexWAy32013dzctLS2KlWEy6WLUwi31eDwqfSJ0t0QiocZRS1EJdKK/pIOMDRfGVI1MUBADLQ0aOTk5pKenKxaIRCryPcKFlvMo0ZE0boRCIfx+v2Jm9Pf3M2fOHOXBOp3OJJ3YPR2zsUwBjFlOtf6IGdAI13KH3n0EHN3wL94wrcdsWcZc3oNLTcSe8xC/UD9B+YW7aLGUcb3zl8CzVP/6ZIq+UUtjkZ/vun+jDxPkx3BrIWXaEVzOCq7ntKEvdX6sXRzAxtd++AcloF24sovfvLKMOqbws/UWqLqBYvYuqvHA7VfpHvfyGEy7nnR0ecJEfPxych8XRi6qQHJzRnV3MVLiUUgeVcJ2ycOKARUWgdGgyXbEKzbyRCV9YCyUGQVXhIZllCQ05keNHoq01RqV6GWZeGYCY7FN2ls7OkbS5CYK5LfIMQ2Hw6rPXqhIXq83id3g9XpVUUrOiYiRd3R0MDg4qFgAco7EoEUiEaVGJYZPNBtgd3HJOKNKjm9HRwft7e2KbifFQCH7y/kSvQGJiuR3AkkqZOFwWE02EDaCFN+GMzw+RZSqjXA2QAXwHNebqoCsofcaeVj7DcU8hpsQZfd/yPacWdR+/7Cht1sp0WqoN81goWbhVdMmGhfPpGRjDaGEe2gby+jKLmT7t+F61y+BTrjzRJ787hf22Uu9m2+z2noZLAdt7dBBfxeuePchOAp+xj9YeNML+IY4qXvFpRoVJRvhG7sXxbJjQCk8t4mJTPwH6O3tpa6ujuLiYuVlCl1JPEnJ3Um+DpKpV/K+eKjicUjDgFTdjUP+5HOSu5MQUninsNvDlFZHt9utUgVSFRYvbTg1y8h5lfyu5IrlppZCWiQSoaamRhVlxlOlSrC3yj/oD7/29nZl7GQstXj8koLJz89XkYYoSMl0BOPkVMmXymcBNTFVZBUzMzOZNGmSOjdGzrJR0GZwcFDJP3Z0dKgGkMmTJ+NyudToFKHKGYtM8rCUcyasEBGpzsvLw2QyEQgEVBpINFeNYirjgTFyp06E9R6Y+zhUZVFx05CKk+lwLn7sCXDAU6cv4U+cA+27PzXP9CH1J+cB73MDP+bklWsgrncupZsjar1Ei5keR5a++xdlwa2w67sFahz13tCHk+Niz7Fm+clgEJ56Z8VsTux/AZ7P5xf8p6T9Pjg1C56Z+LJ/XV1dvPfeeyxYsCBpYql4oUaOqnFkhqxnrLYaFYKMeVdj6C9VZfm83IxiVI0zp+S7pLptbEqQv8WQiqGRv8WAG6lg4lHJOvKdMlgwFAoRDofHLZ8Kex5FbXzPmNYIBAJs3LgRk0nXMxUGhOSJbTYbhYWF+Hw+Ojo6lJcqsoxy/KT4I733QrIPBAIqHSPXh3S/yXmX60SOrbHI5Ha7CYfDykttaWlRTAOfz6e0GESyUbr05IEntDmHw0E4HKahoYHs7GyVr+3u7iYYDCrhF2Ohavgx3RdmxX+KMTKqj8DczwGlyTnFGpNemFoIb2kLRoTX12k/4mdP3wTP6WMWyAfmxqheXEnJSzV6WyjQ0+EDfgynVumtqS4oYNeoe7KNqUmvz/3x3+BXcG7zQ7sXlsP27+ZzpOktSrSdfPvRu5M+N4ldpNNHG7mEcCctowiYBt2aT3VbKawBePmjD9UEQWtrKx0dHRQUFCgDCLtvXsmlSqVZbiSp8BrDcaOHKNsQ70W6ZySUG57jlOKShJBGr8loeMVDNebrjF6OeE+SqpAUgdyoIoYs/FqbzaaEVGQu0njC2BW0p/fF025paVF56unTpyudBclN19fXY7FYyMvLIy8vL2mul7EF2fgQlTy4VPTj8bgyqHIsxfCKpoB0ORmn2RoLkmlpaTidTkXolxy+0+mktbWVYFCP6CQVMDg4yK5duxRlyuv1Kv6qGGHxlNva2ti5c6cqrg3HgUwFjJFRbYW55ZS9N4Cd3f3wFYesg0Og+vuV3Ga6mbO1J5I+dR6PcfbpT4A2NCL6lDnUaaWca/0b9b+YsXvcStGALpIyHz7/raf5x8un8wRncy13Jm0vgI9zTY/BKsOgvmmgXW2Cq3YvMvk0OFmfkbWai1jKo9Sa8sGXB4Faztde4Vru5OQfrBnqkNrBydp73MqNvH3hHI58dyMtFWVkVg+TCAzDRA/9Ba+//jozZ87k85//PNnZ2crDE+/D2P4HJLWr9vf3K0/GKONnLFiIbKD0aOfk5Kh2RAnz5AZJT09Xob2xx11ytZJqEI/L2GYrRkEaECTEFJ6m9K+LFyzrSF+61+vl+eefTxpYOFFgNArG8yC99M3NzYTDYbxerzqGMn66ubk5SbhEuqrkWMiDB1BFSjkXUn3PyclR14UI2kiKQCr50gorqaPu7m7VoCCFLrl2RBtX6GxC9hd1LJPJpCYxSC5c9qWjo4Ps7OykKESoY3s7dmONtL2v8gmx/n22XzGL6pxKOshOeqvitnXgGv1HmkmosdBmEkxlG/5oE1wTpHpSJdU5lcBrOhe0qpV/XHE6WODRz35VFcQECcxwbTraG6bd/14ywU6SGxPigAuqL6tk3mWbqM08DKryqOheB2eX7952HNJaeuHSKTx7+JeI4MRMgnvuHj6XGnRj+tdPePDGB/X19dTX1xMMBpO8QykWDQ/zhqv/SDVWQkvxIo0hodELNaoRGVtFpZA0fBa8rG/sshIPTVgKxtHHo7ERJPw3dleJxzswMDBiIulEhlGDQQp/klMFndWQlZWluqVkIGBTU5PyAAF1DiRd0NraqgpVkn82m81KAUtEccRwRiIRNbBRqHDGvLnQvEwmfUrBzp07qa2tpbGxkY6ODkKhkDoPXV1dNDQ00NDQoGhXIqYtaZrGxka2bdumRvQYC3TikY72ADpQGMMS9Z9hxbNAH+3/rCL7hA7imKldO1SUiuo80bXMT/rUVLaygLeTlv3JfA4NWjH/jy/wuOnLHKml87Zplf7migt5474jOLpjPXHMSWb13yyCOx/jau12frl8z11NWtwE5w69mAOmlb1QlE71A5XwxL2AX29LBQZfzIAPgPXBIdHtkdjRUwr0AOtGfX+iYs2aNTQ0NHDBBRdw2GGHJcnqGTtkjJ1UsJuTKB6n3OziGcLu9lPxQKVoYTQARvk+owGV7xzedmjM0UrqIRgMKo9XKs5GdoExDyj7KkWO1tZWduzYwY4dOw70of9YMBoJecDIoL6NGzdiNpspKytTjAi73U5vb69qthBxFbPZTFZWFm63WxkkSYuIXKNM1hWi/uDgIC6XS1X1fT4fsHvESWNjoxqbIzKMsp+9vb2A3rTR2dmJpmn09vYqhX95mIv3LEpiEpHIdSANJDL4UeQgxQiPdpwOJMaY9zNUpPncY1Q/dR45p++E+bfD7OvhXbjgw6d0WUCxqy3AVvhJ7Nss4Xm1FR8BfASYw0au126nkyxOCzwNQLTDwp1cCz8FO8kdML/s/yasymcKV3Lriu9y4/K71HvrVlSQRyvvMp8ITs7/4GnoBMxAY5o+a+rSe4EvISF85R2vsu6hhbAcfvLGTUq05ZrXfgtA9S8q4VXgiSAHw1yq4YjFYtTU1PCHP/wBq9XKrFmzlDCGFKHEGJpMJtWdZFTwl44e48VtpPaIZylGWTiJxvdcLpdSfzd6HcZcmXi/Ygii0Si7du1S4a94SkLZEgaB5AWlKBKPx2lpaWHXrl1KDNu47xMRw/ODEpKHw2E2bdqkQu3c3FwlkiLK/pKHNPKDZUSKpAuESSBiNi6XS7WnipaptJdqmqYiEvFahSHi8/lUikHYCKIi5na7VU4+HA6rnLsYe3mYCn1OcuhyDqWgKJNv5YE+WpHqQOMAkSmDuj7p6cDS66EKnj1kMSd/uAZWQsV5ukcXIZ36o2fwIMuYz7tk0Tnq1rLo5DXvQv2F3irM/5zyk6R1QrjpWZHP57/1NP9mEXm0KalB0FMDl3E/l/NbElg4Y/YfgKGGgA0OuBbgUpifDu/qn7mfr8Mlu7exi0n6HwuBuhiUWiEbyPZAx8SX/NsTampqeOSRR/jGN76h9Dol5yZ5UvEOjVVVo7dqhIR2xhZY8UQFUmjKyMhQo4+N/EejUZdcrPHzfX19NDQ0KOFqCYtFi8DYgAC79Vt7enrYtGkT3d3dlJeXj3uByojhxmFPLZdSFBwYGKC7u5v169cTj8eZP38+oVBIiVdnZmaqY2vk9nZ3dzN58mTS09PV1FoxbBK+i8iMiK04HA6sVquSBZSuJnnfOICvp6cHr9eL3+/HarUSDocV5c5ut6tRKmLM5QEoRSx5EEjk4/P5VFpJ0hri5coDcU/V/gOBA2RUm+D7a2n/fhdcOhlmw8nx1bqYyuLda6UTgaug1noYny99hbW1n9wwLd72JlwT5B8WPefKH2H9S3Mxk+ArPMjX1z4MK+DZ8JdgMeRfvn139f5FIFAFFMK7lTBjHhYSPMzFekoB3WjXmkLgWAjTZFT10OC/NZ3AL0fZq4MH9fX1PP/88xx66KEcffTRShXK6D2KYRIDKKG+3ExioMTgyuvhzQLi4UpYHg6HaW9vVxJzErJL1V7mFsl+SLFGFPuNNC1pNJC8o1ScxSA3NzcTCATIysqivLx8QpP+R4PR0NrtdiWAsnHjRjIzM8nPz1ccUKvVSlZWFoWFhTQ3N9PQ0EAoFFJpEyHli5BJWlqaquTLsc7IyFDTHoy5Z5FblGJTPB5nx44dOJ1OSktLCQaDeL1e8vLysFgsihsr+fJIJKLOlfCaYXcTiqR/5BzKOQ0Gg7S0tCQZceP+GnGQV/9Hw9/0/1ZWwNlFECiCFVWwuCpprYoL19F/oZ3tJhvf42fcwXX7tPV5azfBH/W/H7/jixA1AW646sfoc7KqeNsUASK8sfRh3btcuQryl1Hx6O7cZzc+fW4WwI2XQQ2c/6f/4zHO4x7T12Fp1m5t11VQcckoedPSLKjLA1r3ad8nIkKhEE899RTvvfcefX19zJs3j0mTJqmOHGMTgPHmMhYKjF6fUaZNPEYxpMZ1IpEInZ2d1NbWEolE1Lhsj8fDpk2bSEtLY9asWaqVVvJy27dvJy0tDZ/Pp6rLUp0WIyvekbS09vT0sGPHDvx+P+Xl5UndPAcTjMdciPKhUIj169dTUlJCSUmJ0jOQHvqcnByi0ajy6CUnKlQmUe0HVNgtwwL7+voUpSkSiZCTk6PGXMs03EAggNvtprOzUylNSaFSQn2ZEyZpJJltJsLhoiMhaQU5l3IeZbnkk8erg2o4xqGX8iF4Yjm8mkXa6u9RnFczYg0zcbh0Fv96q5yBBTfyPEvUe9PZzCFsSVp/G1N1j/eDGMy18sgdF3D7rKu5vuiXMPcGeGaHznmddrJe6f9jK7yZB5Zl0ALVmyt3b6wF4C3gi7i+3054WQ6vsIjGpmJY6qD80Q1qLhZAQ28x4cacoVcxwKp/V93Ha5udqKivr+fXv/41p59+Oueccw6TJk1SRSjpjR/uwZrNZhWyAUnULEDRq4w3sIT2Rrm5zZs3093dTVFREUVFRbz33nsq/+b1ehW3sbOzk+bmZiUtJ16s8QFgFH+R121tbQQCAaZOnUpGRgY7d+5k5cqVox+IcYbs+54MhzEdYJTz6+7upru7m9mzZ2OxWAgEAmqsiuRe5WHS1dWVFDmIZqroA8hQv+7ubhobG5WwjdPppKSkhEmTJqmZY319fWrczeDgoMqhilC2oLu7m/b2dhKJhEoxiNfq8XjU/gmzwMgikPMv41WMD5fx5KqOg1GNAb+EhdMYfOoi0k+PjFgjgQVW7uD0+9/k6Pp3oPR99MLPi/DMU6w9ZXdaYDPTueDwp8AB5SWbqK06jKcnnc/T154Pr8ag9Of6Z1s80PJtdKu6Us+BciHwCMwYalRQWABsIvz9HFgKjUeU64t/SpJBrW6aCUW9wCb0cdrAmkJ9P/exu+tgQCQS4Z133mHq1KnMnTuXoqKipGKOsZNGbkhAFbCMnEq5+I1TU6WAAbpBdDqdVFZWUlJSovipsViMgoICgsEg7e3txGIx6urqVHFKquAiJWe8ecRLBd1wSJdRe3u78o4ikQivvfYaoVDyxIjxwicpthiNhuQm4/E4HR0dyvP0eDxJotWAUhGTltL09HQmTZqkqvUiXhIKhaipqVGesMzAEn6o2+0mFAqpol8ikcDn8+FyuZLOr7A2BgcHycnJob29nZaWFqU9IPnvwcFBlbstLy+nrq5O8V7dbjfbt29ny5YtKu1gDPnH02MdR9WPrXBGjOqiSvIbtid1I20/cRbwLE8fcT68uxbenQcL4bA+CxdwddJW1jIftoI/0EQf6RR9q5bGU6fBtK2c/91XqNOO4I2jj4c3q4CfoRs/PxCEa8v15a8+iW5sLTBjoR7eN86EXz0GjvMoeqd2xHiWbnxQ1AHEYOFMvZgVfYGkmSqfImzdupU//OEP9Pb2cvjhh1NUVKQoM0JbMio/iTcYi8VUnk0MhXiy0oUlnoeEfSII4vf7k3RZc3JylOZnRkYGs2bNwufz0dTUpLxbs9lMZmZmUrOA5GB37dpFXV2d8oL6+/vJycmhs7OT3/3ud2zfvv2jDsEBw94M6t66rIyvReHpnXfeobW1VT10RJPBKEQTj+sTbP1+P36/X6UEJLfa1dVFJBLB4/GoLivQz2cgEFD5VykwyWReMXqxWEx5ljKeRaattrS0UF9fn3TeJBISZoMMbKytrVX7JhNf98UL/RTmVEfDj6HRSsuUG8jcYchNWoD5J1PyTg2QQf3NQBRu5QYKaB65mflgM/fTaNK3kdZSwOBF5TxqehY4fmil78C1Hv55x2cAOOHXr8NCKL9jA7XWsyC+A26cok8VqKmFU2eC5Ty481Ua7wxRpk3Gzu4umxZTGdAKJxXBc6vRJxl+urF9+3buvfdejj76aL7yla9w2GGHqdlWUngCVNFAWheNbY9GHqoY0fT0dOX5ipcpXpZodRpbYDMyMpTAisfjweVy0dzczJYtW6iurqawsJDs7GwmTZqEx+MhEonQ1NTE+++/j9/vJz8/n2AwSF1dHS+//DI7duyY8DSqfcGe2AH9/f00NTXR3t7Orl27CAaDTJ48WbE6RJQkEokkjcARYylKVS0tLXR3d+P3+5k/fz4ffPABAwMDuFwugsGg6sASypXb7cbpdNLQ0KD4w9FoVKVdbDYbTU1NuN1uSktL2bZtG5s3b1ZTemUkj8ViYefOncqIi8i5XD9C7TJiPD3Vseuo2mfEoC5G9d935zUrnl1HxTvrdCEVIhCHcm3D6AZ1CDoRvwIY2o4DIE6JVkOFtg4abXBnjBN+8breseUAlg6F80OPlopb1uGNdqLarUqBUxcCTrbPmUX14ZW0JvKofroSeAE+lzfU39+2H4/HxEYikeDNN99k69atNDc3K01MoUgJbQpISgkImVxaDSW8E44hJM9nl9yeMbVg7OqSCrMUpRKJBD09PTQ0NFBfX8+uXbvo7OxUHTpbt24lGAySn59PZmYmAwMDPPDAA2zduvVTYVBHgxwvo7ff0dHBe++9R3Nzs1L7r6+vV7OjCgoK8Pv9Krow0tbkXApToKioiN7eXjo7O1VbsMvlUur+oVCIYDBIf3+/SqtIiC9epqQMBgcHKS4uJhAIsH37diVCDbp8oNfrpaGhgXXr1inGgvG8GbvsxhsTRPRTF0epXlgJUUh7ppepeVuxkKB6QyXc+hZ5t4zsod/MdN5jLgDt24rRJa8KGcy36RqnQP2kGVQ0r6OscBvbt86EubD4mbe44oWfc9+lZ1I9pxJqYkAR1V+cAs+8D1j0GVjrnwRCQBN8sAaALsuXgELgNXixCX1qwMHR37+/EI/Heeyxx2hsbCQ/P5/Kyko1AE4MplTYpc1RClPSrSOeZyAQIB6Pq0FuQp+KRCLqJhavwziJQDysQCCgPLC6ujra29sJBALKuLpcLjo7O+no6CAzM5P29nZ6enp4+OGHx/kojg2MDyaBUVoxEomwfft2+vr6aG1tZerUqZhMJjVTTOQVJT2Qlpam2lvlnNTW1rJ582bFJrBYLOpBJWNVpJ9fBGxEF8Dj8ZCbm8u2bduwWCz4fD5aW1tpaGhQba/SfSdjUpqampR4tqQqjHzUiZJLFZi0fcyIm0xVY7wrRjjJ184hkwDVphLytR7+zqkj1pp32SZ4BqgClgcBD5wKPLODCq2batMcwEKF9p76TBwztUccpoud1LwARSfqE1rnA4ufhPlnwXogXjXGv/GjoWn/+fcfiAvMZrNx7LHHsmDBApYsWUJWVpa6+CWcFDV6Y3++tBp2dnZis9nU3HcxujKkz+v1KhV/yadKW2VbWxu7du2iu7ubzZs388Ybb9DS0qKG/nm9XoqLiwmHw9TV1Y35sdhfnTw5OTkq7WHExz2fw9c36p+K0PS0adMoKyujrKxMtYaKNykqYV1dXezcuZMtW7ZgtVpVs4B0QLlcLsrLywkGg6qTa9euXTQ365GlMDT6+/txOp2qJbWzs1OR/+vq6pIiFtEjsFqtynhLdCIP2j0Z0o9znKRtd39igniqw7GMls/mkfnSOqCPlkVlzLNs4vGXvkgxDUmjp11bh6asLp8GvArPWNF/lhzYR6j+7UVUXK7nWy0kqHhH9F0rdY80zlATwol6WiD+5IH5mZ8CDAwMUFNTw9SpU1VhYTSFKiBJvFrI5UYFfqNgi91uV4RyaVk0jm7RNE3xJVtaWujq6qKzs1MZVICenp79fsMcrDAWCQHl6dfU1KiHWWFhIf39/ezatUvpPjgcjqQ0jM/nUypm4XBYtY0K/UkEXUQTVdpV5SEonXBer5fBwUFeffVVlQYyGkNppTV+t/FaGo3cP1EwQY3qSlhzCdVrK3Ujlw2E0WX8vp/ORbfdr2sDGOddzfaAb6hy/xxs7Qyik+9Pg+W3U33Sd/Supw26IU2b34s/HqBrNUMygD/Wt/OqhYOxb3880dTUxIYNG5gxYwaapqmhcGIYAdWDL9J9IpYhVWTxooReJTxJmZyak5ODxWIhFArR3t5Od3c3bW1tbN26lfr6epqbmw+6bqixxkelAiRH3d7ezrvvvktTUxM+n0+F/w0NDaroZNR56OzspLCwULX+Dg7q01kbGxux2+10d3crGb9QKKRyqRK9hEIhtm3bpiQY5cEpHvRww2r0XvdVeWq8mwAmqFGNAX+D+RdCo42Kwk2Arv4UXZ7OatPJvKItgq3gywgAULExubOp+rJK+L6Hhbe9wKum6/EXNelvzAXYxODSmURW9MOyJ9ndKxsb+pfCx4Gmabz11lvE43HmzZvHkiVLmDZtmpLkkxyYzMKSPm4hcgtBX24qyatK9b+3t1cVIjZv3sy2bdvo7++nurqahoYGmpqaxvkITByMZlBG0xAw/h8MBonH43R1deF2uykuLsZqtaqKvYw0kRRMMBhUHVROp1N5oWazWSn1C/e3o6NDFbxEKUtk/CTFIbnb0ar4wyliBwMmqFEF3ctcBSd9k+rsSrzPtVDsbcDyaB3Vf6yk3hSDeyDQ66MjnkWBt1lRnqqbZsLKx8jRjuZV0wJYBpGwkx2K4D8T/vgY0T+WAvXAQ6SM6X8GTdN4911deSYnJ0eNDxZ9UqFYCYlcjKex798480o80ubmZnp6epTGZ0NDg9IFWLdunZL1S+HjQ86BPOyEPywRhcg9tre3K7Hvvr4+uru7cTgcxGIxNWtKcqaiCeDz+RQjo7OzE5fLxcDAgJqAK80HktbZk8Ec7rkOXz7eilSjYYIWqoZjARCDZ06DALrileDWxwALLD4LroKKs9bpHu0Mv/7IyAfejaHC+4MEB0uhajTY7XaWLFnCYYcdRmlpqZIPFN3ShoYGMjIyKC4uVqpJ8g+gvb2dt956ix07digvStM0ZVjXrZuYOrVjXagS7M0T3dN6e1oGKPK/nAfh+Ao1KhKJKLpVd3c3LpdLdWL5fD7a29tVvtQ4fnzbtm2KoC8MBGNYv7f9Gu137u33j3eh6iAxqoLPobd/Gon2HiB3aNklcOeU5I88A6ypOiB7tz9xMBtVQU5ODh6Ph0mTJpGXl5c0NcDhcJCdna36x4093vX19bz22msqrBdJwfb29r184/jiQBlV2LMH91HrfdQyQNGUpHDlcrmUQHQikVDUOKnCZ2RkKA82FAolCY6LJyr51dFI+h/3+tyTUf1PkDKqe4UVGC5kEuNgLDx9GoyqwFi5N9Jg9kSLEa9pImmb7gsOdqNqfN84TlyaOsTTNEo/GkeOy75I/twoomPc148ShvkojEUB6r+IUvVJkSo0TUSMdnOlsP/wST2+PX1eKvFyzoy6uKOJYxvzm0YDa5xjNnz7n8Q4joWTMBY52U+ZUU0hhU8XxiLkHe079kZRMv4v2NuDcjSDNVaGcaJEZZAyqimkkMIo+Kiq+56MbAo6UkY1hRRS+Ehv7z9pAz0Q+E/2Zyx+y8SRdkkhhRTGFSnPc/8gZVRTSGECY7Qe97HOr6bwnyEV/qeQwkGEAxF6f5oN64HoxEp5qimkkMJ/Hcby4ZQyqimkMMEw0QpBKXw8pIxqCilMQExkvdBPC8bqGKdyqimkMMEgbb2wZ+J9Cp8Mw5spUkY1hRT+CyAC0HvTF03hP8NYear7LKiSQgoppJDC3pHKqaaQQgop7EekjGoKKaSQwn5EyqimkEIKKexHpIxqCimkkMJ+RMqoppBCCinsR6SMagoppJDCfkTKqKaQQgop7EekjGoKKaSQwn5EyqimkEIKKexH/H9aDmGmD0G8WAAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████| 2/2 [00:00<00:00,  3.34it/s, kld=113, perceptual=0.339, generator=2.48, feature=0.174, discriminator=2.51]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 5/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.15it/s, kld=181, perceptual=0.321, generator=2.52, feature=0.203, discriminator=2.23]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=170, perceptual=0.313, generator=2.53, feature=0.202, discriminator=2.21]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████| 2/2 [00:00<00:00,  2.59it/s, kld=151, perceptual=0.348, generator=2.49, feature=0.198, discriminator=2.25]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.17it/s, kld=179, perceptual=0.365, generator=1.58, feature=0.125, discriminator=3.83]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=209, perceptual=0.396, generator=1.49, feature=0.137, discriminator=3.75]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████| 2/2 [00:00<00:00,  3.08it/s, kld=108, perceptual=0.384, generator=1.93, feature=0.183, discriminator=3.43]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 7/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.15it/s, kld=407, perceptual=0.38, generator=1.84, feature=0.127, discriminator=3.41]\n",
+      "  0%|                | 0/2 [00:00<?, ?it/s, kld=427, perceptual=0.37, generator=1.94, feature=0.124, discriminator=2.84]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████| 2/2 [00:00<00:00,  3.35it/s, kld=302, perceptual=0.393, generator=2.02, feature=0.133, discriminator=2.79]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.15it/s, kld=356, perceptual=0.365, generator=2.34, feature=0.166, discriminator=2.39]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=345, perceptual=0.357, generator=2.35, feature=0.159, discriminator=2.52]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████| 2/2 [00:00<00:00,  3.20it/s, kld=237, perceptual=0.37, generator=2.35, feature=0.176, discriminator=2.37]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      " 60%|████▏  | 9/15 [00:04<00:03,  1.87it/s, kld=194, perceptual=0.35, generator=2.63, feature=0.156, discriminator=2.57]\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
+      "\u001B[0;31mKeyboardInterrupt\u001B[0m                         Traceback (most recent call last)",
+      "Cell \u001B[0;32mIn[22], line 36\u001B[0m\n\u001B[1;32m     34\u001B[0m optimizer_D\u001B[38;5;241m.\u001B[39mzero_grad()\n\u001B[1;32m     35\u001B[0m loss_d \u001B[38;5;241m=\u001B[39m loss_d_r \u001B[38;5;241m+\u001B[39m loss_g_f\n\u001B[0;32m---> 36\u001B[0m \u001B[43mloss_d\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mbackward\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m     37\u001B[0m optimizer_D\u001B[38;5;241m.\u001B[39mstep()\n\u001B[1;32m     39\u001B[0m \u001B[38;5;66;03m# Store\u001B[39;00m\n",
+      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/torch/_tensor.py:479\u001B[0m, in \u001B[0;36mTensor.backward\u001B[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001B[0m\n\u001B[1;32m    432\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124mr\u001B[39m\u001B[38;5;124;03m\"\"\"Computes the gradient of current tensor w.r.t. graph leaves.\u001B[39;00m\n\u001B[1;32m    433\u001B[0m \n\u001B[1;32m    434\u001B[0m \u001B[38;5;124;03mThe graph is differentiated using the chain rule. If the tensor is\u001B[39;00m\n\u001B[0;32m   (...)\u001B[0m\n\u001B[1;32m    476\u001B[0m \u001B[38;5;124;03m        used to compute the attr::tensors.\u001B[39;00m\n\u001B[1;32m    477\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m    478\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m has_torch_function_unary(\u001B[38;5;28mself\u001B[39m):\n\u001B[0;32m--> 479\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mhandle_torch_function\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m    480\u001B[0m \u001B[43m        \u001B[49m\u001B[43mTensor\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mbackward\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    481\u001B[0m \u001B[43m        \u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    482\u001B[0m \u001B[43m        \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m    483\u001B[0m \u001B[43m        \u001B[49m\u001B[43mgradient\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mgradient\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    484\u001B[0m \u001B[43m        \u001B[49m\u001B[43mretain_graph\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mretain_graph\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    485\u001B[0m \u001B[43m        \u001B[49m\u001B[43mcreate_graph\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcreate_graph\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    486\u001B[0m \u001B[43m        \u001B[49m\u001B[43minputs\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43minputs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    487\u001B[0m \u001B[43m    \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m    488\u001B[0m torch\u001B[38;5;241m.\u001B[39mautograd\u001B[38;5;241m.\u001B[39mbackward(\n\u001B[1;32m    489\u001B[0m     \u001B[38;5;28mself\u001B[39m, gradient, retain_graph, create_graph, inputs\u001B[38;5;241m=\u001B[39minputs\n\u001B[1;32m    490\u001B[0m )\n",
+      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/torch/overrides.py:1534\u001B[0m, in \u001B[0;36mhandle_torch_function\u001B[0;34m(public_api, relevant_args, *args, **kwargs)\u001B[0m\n\u001B[1;32m   1528\u001B[0m     warnings\u001B[38;5;241m.\u001B[39mwarn(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mDefining your `__torch_function__ as a plain method is deprecated and \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m   1529\u001B[0m                   \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mwill be an error in future, please define it as a classmethod.\u001B[39m\u001B[38;5;124m\"\u001B[39m,\n\u001B[1;32m   1530\u001B[0m                   \u001B[38;5;167;01mDeprecationWarning\u001B[39;00m)\n\u001B[1;32m   1532\u001B[0m \u001B[38;5;66;03m# Use `public_api` instead of `implementation` so __torch_function__\u001B[39;00m\n\u001B[1;32m   1533\u001B[0m \u001B[38;5;66;03m# implementations can do equality/identity comparisons.\u001B[39;00m\n\u001B[0;32m-> 1534\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[43mtorch_func_method\u001B[49m\u001B[43m(\u001B[49m\u001B[43mpublic_api\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtypes\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m   1536\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m result \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28mNotImplemented\u001B[39m:\n\u001B[1;32m   1537\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m result\n",
+      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/monai/data/meta_tensor.py:276\u001B[0m, in \u001B[0;36mMetaTensor.__torch_function__\u001B[0;34m(cls, func, types, args, kwargs)\u001B[0m\n\u001B[1;32m    274\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m kwargs \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m    275\u001B[0m     kwargs \u001B[38;5;241m=\u001B[39m {}\n\u001B[0;32m--> 276\u001B[0m ret \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43msuper\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m__torch_function__\u001B[49m\u001B[43m(\u001B[49m\u001B[43mfunc\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtypes\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m    277\u001B[0m \u001B[38;5;66;03m# if `out` has been used as argument, metadata is not copied, nothing to do.\u001B[39;00m\n\u001B[1;32m    278\u001B[0m \u001B[38;5;66;03m# if \"out\" in kwargs:\u001B[39;00m\n\u001B[1;32m    279\u001B[0m \u001B[38;5;66;03m#     return ret\u001B[39;00m\n\u001B[1;32m    280\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m _not_requiring_metadata(ret):\n",
+      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/torch/_tensor.py:1279\u001B[0m, in \u001B[0;36mTensor.__torch_function__\u001B[0;34m(cls, func, types, args, kwargs)\u001B[0m\n\u001B[1;32m   1276\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mNotImplemented\u001B[39m\n\u001B[1;32m   1278\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m _C\u001B[38;5;241m.\u001B[39mDisableTorchFunction():\n\u001B[0;32m-> 1279\u001B[0m     ret \u001B[38;5;241m=\u001B[39m \u001B[43mfunc\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m   1280\u001B[0m     \u001B[38;5;28;01mif\u001B[39;00m func \u001B[38;5;129;01min\u001B[39;00m get_default_nowrap_functions():\n\u001B[1;32m   1281\u001B[0m         \u001B[38;5;28;01mreturn\u001B[39;00m ret\n",
+      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/torch/_tensor.py:488\u001B[0m, in \u001B[0;36mTensor.backward\u001B[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001B[0m\n\u001B[1;32m    478\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m has_torch_function_unary(\u001B[38;5;28mself\u001B[39m):\n\u001B[1;32m    479\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m handle_torch_function(\n\u001B[1;32m    480\u001B[0m         Tensor\u001B[38;5;241m.\u001B[39mbackward,\n\u001B[1;32m    481\u001B[0m         (\u001B[38;5;28mself\u001B[39m,),\n\u001B[0;32m   (...)\u001B[0m\n\u001B[1;32m    486\u001B[0m         inputs\u001B[38;5;241m=\u001B[39minputs,\n\u001B[1;32m    487\u001B[0m     )\n\u001B[0;32m--> 488\u001B[0m \u001B[43mtorch\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mautograd\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mbackward\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m    489\u001B[0m \u001B[43m    \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgradient\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mretain_graph\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcreate_graph\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43minputs\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43minputs\u001B[49m\n\u001B[1;32m    490\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n",
+      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/torch/autograd/__init__.py:197\u001B[0m, in \u001B[0;36mbackward\u001B[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001B[0m\n\u001B[1;32m    192\u001B[0m     retain_graph \u001B[38;5;241m=\u001B[39m create_graph\n\u001B[1;32m    194\u001B[0m \u001B[38;5;66;03m# The reason we repeat same the comment below is that\u001B[39;00m\n\u001B[1;32m    195\u001B[0m \u001B[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001B[39;00m\n\u001B[1;32m    196\u001B[0m \u001B[38;5;66;03m# calls in the traceback and some print out the last line\u001B[39;00m\n\u001B[0;32m--> 197\u001B[0m \u001B[43mVariable\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_execution_engine\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mrun_backward\u001B[49m\u001B[43m(\u001B[49m\u001B[43m  \u001B[49m\u001B[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001B[39;49;00m\n\u001B[1;32m    198\u001B[0m \u001B[43m    \u001B[49m\u001B[43mtensors\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgrad_tensors_\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mretain_graph\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcreate_graph\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43minputs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    199\u001B[0m \u001B[43m    \u001B[49m\u001B[43mallow_unreachable\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43maccumulate_grad\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m)\u001B[49m\n",
+      "\u001B[0;31mKeyboardInterrupt\u001B[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "net = net.to(device)\n",
+    "discriminator = discriminator.to(device)\n",
+    "torch.autograd.set_detect_anomaly(True)\n",
+    "for epoch in range(num_epochs):\n",
+    "    print(\"Epoch %d/%d\" %(epoch, num_epochs))\n",
+    "    train_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=120)\n",
+    "    losses_epoch = {'kld': 0, 'perceptual': 0, 'feature': 0, 'generator': 0, 'discriminator': 0}\n",
+    "    for step, d in train_bar:\n",
+    "        image = d['image'].to(device)\n",
+    "        with torch.no_grad():\n",
+    "            label = one_hot(d['label'], 6).to(device)\n",
+    "        optimizer_G.zero_grad()\n",
+    "\n",
+    "        # Losses gen\n",
+    "        out, kld_loss = net(label, image)\n",
+    "        disc_fakes, features_fakes = discriminator(torch.cat([out, label], 1))\n",
+    "        loss_g = adversarial_loss(disc_fakes, target_is_real = True, for_discriminator = False)\n",
+    "        disc_reals, features_reals = discriminator(torch.cat([image, label], 1))\n",
+    "        loss_feat = feature_loss(features_fakes, features_reals, lambda_feat, device)\n",
+    "        loss_perc = perceptual_loss(out, target = image)\n",
+    "        total_loss = loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat  * lambda_feat\n",
+    "        total_loss.backward(retain_graph = True)\n",
+    "        optimizer_G.step()\n",
+    "\n",
+    "        # Store\n",
+    "        losses_epoch['kld'] += kld_loss.item()\n",
+    "        losses_epoch['perceptual'] += loss_perc.item()\n",
+    "        losses_epoch['generator'] += loss_g.item()\n",
+    "        #Train disc\n",
+    "        out, _ = net(label, image)\n",
+    "        disc_fakes, _ = discriminator(torch.cat([out, label], 1))\n",
+    "        loss_d_r = adversarial_loss(disc_reals, target_is_real = True, for_discriminator = True)\n",
+    "        loss_g_f = adversarial_loss(disc_fakes, target_is_real = False, for_discriminator = True)\n",
+    "        optimizer_D.zero_grad()\n",
+    "        loss_d = loss_d_r + loss_g_f\n",
+    "        loss_d.backward()\n",
+    "        optimizer_D.step()\n",
+    "\n",
+    "        # Store\n",
+    "        losses_epoch['feature'] = loss_feat.item()\n",
+    "        losses_epoch['discriminator'] = loss_d_r.item() + loss_g_f.item()\n",
+    "\n",
+    "        train_bar.set_postfix(\n",
+    "                        {\"kld\": kld_loss.item(),\n",
+    "                         \"perceptual\": loss_perc.item(),\n",
+    "                         \"generator\": loss_g.item(),\n",
+    "                         \"feature\": loss_feat.item(),\n",
+    "                         \"discriminator\": loss_d_r.item() + loss_g_f.item(),\n",
+    "                        })\n",
+    "\n",
+    "    val_bar = tqdm(enumerate(val_loader), total=len(val_loader), ncols=120)\n",
+    "    losses_epoch_val = {'kld': 0, 'perceptual': 0, 'feature': 0, 'generator': 0, 'discriminator': 0}\n",
+    "    for step, d in val_bar:\n",
+    "        image = d['image'].to(device)\n",
+    "        with torch.no_grad():\n",
+    "            label = one_hot(d['label'], 6).to(device)\n",
+    "            # Losses gen\n",
+    "            out, kld_loss = net(label, image)\n",
+    "            disc_fakes, features_fakes = discriminator(torch.cat([out, label], 1))\n",
+    "            loss_g = adversarial_loss(disc_fakes, target_is_real = True, for_discriminator = False)\n",
+    "            disc_reals, features_reals = discriminator(torch.cat([image, label], 1))\n",
+    "            loss_feat = feature_loss(features_fakes, features_reals, lambda_feat, device)\n",
+    "            loss_perc = perceptual_loss(out, target = image)\n",
+    "            total_loss = loss_adv * loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat  * lambda_feat\n",
+    "            # Store\n",
+    "            losses_epoch_val['kld'] += kld_loss.item()\n",
+    "            losses_epoch_val['perceptual'] += loss_perc.item()\n",
+    "            losses_epoch_val['generator'] += loss_g.item()\n",
+    "            #Train disc\n",
+    "            out, _ = net(label, image)\n",
+    "            disc_fakes, _ = discriminator(torch.cat([out, label], 1))\n",
+    "            loss_d_r = adversarial_loss(disc_reals, target_is_real = True, for_discriminator = True)\n",
+    "            loss_g_f = adversarial_loss(disc_fakes, target_is_real = False, for_discriminator = True)\n",
+    "            loss_d = loss_adv * (loss_d_r + loss_g_f)\n",
+    "\n",
+    "            # Store\n",
+    "            losses_epoch_val['feature'] = loss_feat.item()\n",
+    "            losses_epoch_val['discriminator'] = loss_d_r.item() + loss_g_f.item()\n",
+    "\n",
+    "            val_bar.set_postfix(\n",
+    "                            {\"kld\": kld_loss.item(),\n",
+    "                             \"perceptual\": loss_perc.item(),\n",
+    "                             \"generator\": loss_g.item(),\n",
+    "                             \"feature\": loss_feat.item(),\n",
+    "                             \"discriminator\": loss_d_r.item() + loss_g_f.item(),\n",
+    "                            })\n",
+    "            if step == 0 and epoch%10==0:\n",
+    "                picture_results(label, image, out)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f579376b",
+   "metadata": {
+    "pycharm": {
+     "name": "#%%"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "\n"
+   ]
+  }
+ ],
+ "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
+}
\ No newline at end of file
diff --git a/tutorials/generative/2d_spade_gan/2d_spade_vae.py b/tutorials/generative/2d_spade_gan/2d_spade_vae.py
new file mode 100644
index 00000000..1f2a93ac
--- /dev/null
+++ b/tutorials/generative/2d_spade_gan/2d_spade_vae.py
@@ -0,0 +1,330 @@
+# ---
+# 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 VAE-GAN
+
+# This notebook creates a mock SPADE VAE-GAN based on the paper "Semantic Image Synthesis with Spatially-Adaptive Normalization" (2019) by Park T, Liu MY, Wang TC, Zhu JY. More information available at: https://github.com/NVlabs/SPADE
+
+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
+from generative.networks.nets import MultiScalePatchDiscriminator
+import numpy as np
+import monai
+from generative.networks.nets.spade_network import SPADE_Net
+
+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)
+
+# INPUT PARAMETERS
+input_shape = [128, 128]
+batch_size = 6
+num_workers = 4
+num_epochs = 100
+lambda_perc = 1.0
+lambda_feat = 0.1
+lambda_kld = 0.00001
+loss_adv = 1.0
+
+# ### 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.
+#
+
+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)] + \
+             [os.path.join(images_FLAIR, i) for i in os.listdir(images_FLAIR)]
+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()
+
+# ### Network 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()
+
+
+
+def feature_loss(input_features_disc_fake, input_features_disc_real, lambda_feat, device):
+    criterion = torch.nn.L1Loss()
+    num_D = len(input_features_disc_fake)
+    GAN_Feat_loss = torch.zeros(1).to(device)
+    for i in range(num_D):  # for each discriminator
+        num_intermediate_outputs = len(input_features_disc_fake[i])
+        for j in range(num_intermediate_outputs):  # for each layer output
+            unweighted_loss = criterion(input_features_disc_fake[i][j],
+                                        input_features_disc_real[i][j].detach())
+            GAN_Feat_loss += unweighted_loss * lambda_feat / num_D
+    return GAN_Feat_loss
+
+
+net = SPADE_Net(spatial_dims = 2,
+                in_channels = 1,
+                out_channels = 1,
+                label_nc = 6,
+                input_shape = input_shape,
+                num_channels = [16, 32, 64, 128],
+                z_dim = 16,
+                is_vae = True)
+
+# +
+discriminator = MultiScalePatchDiscriminator(num_d = 2,
+                                             num_layers_d = 3,
+                                             spatial_dims = 2,
+                                             num_channels = 8,
+                                             in_channels = 7,
+                                             out_channels = 7,
+                                             minimum_size_im = 128,
+                                             norm = "INSTANCE",
+                                             kernel_size = 3
+                                             )
+
+adversarial_loss = PatchAdversarialLoss(reduction = "sum", criterion = "hinge")
+# -
+
+perceptual_loss = PerceptualLoss(spatial_dims = 2,
+                                 network_type = "vgg",
+                                 is_fake_3d = False,
+                                 pretrained = True)
+perceptual_loss=perceptual_loss.to(device)
+
+optimizer_G = torch.optim.Adam(net.parameters(), lr = 0.0002)
+optimizer_D = torch.optim.Adam(discriminator.parameters(), lr = 0.0004)
+
+# ### Training loop
+#
+
+net = net.to(device)
+discriminator = discriminator.to(device)
+torch.autograd.set_detect_anomaly(True)
+for epoch in range(num_epochs):
+    print("Epoch %d/%d" %(epoch, num_epochs))
+    train_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=120)
+    losses_epoch = {'kld': 0, 'perceptual': 0, 'feature': 0, 'generator': 0, 'discriminator': 0}
+    for step, d in train_bar:
+        image = d['image'].to(device)
+        with torch.no_grad():
+            label = one_hot(d['label'], 6).to(device)
+        optimizer_G.zero_grad()
+
+        # Losses gen
+        out, kld_loss = net(label, image)
+        disc_fakes, features_fakes = discriminator(torch.cat([out, label], 1))
+        loss_g = adversarial_loss(disc_fakes, target_is_real = True, for_discriminator = False)
+        disc_reals, features_reals = discriminator(torch.cat([image, label], 1))
+        loss_feat = feature_loss(features_fakes, features_reals, lambda_feat, device)
+        loss_perc = perceptual_loss(out, target = image)
+        total_loss = loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat  * lambda_feat
+        total_loss.backward(retain_graph = True)
+        optimizer_G.step()
+
+        # Store
+        losses_epoch['kld'] += kld_loss.item()
+        losses_epoch['perceptual'] += loss_perc.item()
+        losses_epoch['generator'] += loss_g.item()
+        #Train disc
+        out, _ = net(label, image)
+        disc_fakes, _ = discriminator(torch.cat([out, label], 1))
+        loss_d_r = adversarial_loss(disc_reals, target_is_real = True, for_discriminator = True)
+        loss_g_f = adversarial_loss(disc_fakes, target_is_real = False, for_discriminator = True)
+        optimizer_D.zero_grad()
+        loss_d = loss_d_r + loss_g_f
+        loss_d.backward()
+        optimizer_D.step()
+
+        # Store
+        losses_epoch['feature'] = loss_feat.item()
+        losses_epoch['discriminator'] = loss_d_r.item() + loss_g_f.item()
+
+        train_bar.set_postfix(
+                        {"kld": kld_loss.item(),
+                         "perceptual": loss_perc.item(),
+                         "generator": loss_g.item(),
+                         "feature": loss_feat.item(),
+                         "discriminator": loss_d_r.item() + loss_g_f.item(),
+                        })
+
+    val_bar = tqdm(enumerate(val_loader), total=len(val_loader), ncols=120)
+    losses_epoch_val = {'kld': 0, 'perceptual': 0, 'feature': 0, 'generator': 0, 'discriminator': 0}
+    for step, d in val_bar:
+        image = d['image'].to(device)
+        with torch.no_grad():
+            label = one_hot(d['label'], 6).to(device)
+            # Losses gen
+            out, kld_loss = net(label, image)
+            disc_fakes, features_fakes = discriminator(torch.cat([out, label], 1))
+            loss_g = adversarial_loss(disc_fakes, target_is_real = True, for_discriminator = False)
+            disc_reals, features_reals = discriminator(torch.cat([image, label], 1))
+            loss_feat = feature_loss(features_fakes, features_reals, lambda_feat, device)
+            loss_perc = perceptual_loss(out, target = image)
+            total_loss = loss_adv * loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat  * lambda_feat
+            # Store
+            losses_epoch_val['kld'] += kld_loss.item()
+            losses_epoch_val['perceptual'] += loss_perc.item()
+            losses_epoch_val['generator'] += loss_g.item()
+            #Train disc
+            out, _ = net(label, image)
+            disc_fakes, _ = discriminator(torch.cat([out, label], 1))
+            loss_d_r = adversarial_loss(disc_reals, target_is_real = True, for_discriminator = True)
+            loss_g_f = adversarial_loss(disc_fakes, target_is_real = False, for_discriminator = True)
+            loss_d = loss_adv * (loss_d_r + loss_g_f)
+
+            # Store
+            losses_epoch_val['feature'] = loss_feat.item()
+            losses_epoch_val['discriminator'] = loss_d_r.item() + loss_g_f.item()
+
+            val_bar.set_postfix(
+                            {"kld": kld_loss.item(),
+                             "perceptual": loss_perc.item(),
+                             "generator": loss_g.item(),
+                             "feature": loss_feat.item(),
+                             "discriminator": loss_d_r.item() + loss_g_f.item(),
+                            })
+            if step == 0 and epoch%10==0:
+                picture_results(label, image, out)
+
+# + pycharm={"name": "#%%"}
+
+

From e77599e4d1728ccb4659133d480a5dd5e68f87d7 Mon Sep 17 00:00:00 2001
From: Walter Hugo Lopez Pinaya <ianonimato@hotmail.com>
Date: Thu, 22 Jun 2023 09:22:17 +0100
Subject: [PATCH 4/7] Add tutorial outputs

Signed-off-by: Walter Hugo Lopez Pinaya <ianonimato@hotmail.com>
---
 .../2d_spade_gan/2d_spade_vae.ipynb           | 1723 +++++++++++++++--
 1 file changed, 1593 insertions(+), 130 deletions(-)

diff --git a/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb b/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
index c7c29aaf..bf7271c3 100644
--- a/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
+++ b/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 1,
    "id": "1f7ba8ce",
    "metadata": {},
    "outputs": [],
@@ -37,12 +37,23 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 2,
    "id": "e059c423",
    "metadata": {
     "scrolled": true
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/media/walter/Storage/Projects/GenerativeModels/venv/lib/python3.10/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "A matching Triton is not available, some optimizations will not be enabled.\n",
+      "Error caught was: No module named 'triton'\n"
+     ]
+    }
+   ],
    "source": [
     "import os\n",
     "import tempfile\n",
@@ -63,7 +74,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 3,
    "id": "e76296e7",
    "metadata": {
     "scrolled": false
@@ -73,7 +84,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Temporary directory used: /tmp/tmpy_otj3u5 \n"
+      "Temporary directory used: /tmp/tmpo8gppqh6 \n"
      ]
     }
    ],
@@ -86,7 +97,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 4,
    "id": "2483148a",
    "metadata": {},
    "outputs": [],
@@ -134,7 +145,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 5,
    "id": "dc560f7e",
    "metadata": {
     "scrolled": true
@@ -146,17 +157,17 @@
      "text": [
       "Downloading...\n",
       "From: https://drive.google.com/uc?export=download&id=1SX_MCzQe-vyq09QYxECk32wZ2vxp9rx5\n",
-      "To: /tmp/tmpy_otj3u5/data.zip\n",
-      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 384M/384M [00:06<00:00, 62.8MB/s]\n"
+      "To: /tmp/tmpo8gppqh6/data.zip\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 384M/384M [00:05<00:00, 69.6MB/s]\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "'/tmp/tmpy_otj3u5/data.zip'"
+       "'/tmp/tmpo8gppqh6/data.zip'"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -168,7 +179,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 6,
    "id": "cd7dd6ec",
    "metadata": {},
    "outputs": [],
@@ -182,7 +193,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 7,
    "id": "d48987b9",
    "metadata": {},
    "outputs": [],
@@ -208,12 +219,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 8,
    "id": "8ab79cdc",
    "metadata": {
     "lines_to_end_of_cell_marker": 2
    },
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "monai.transforms.io.dictionary LoadImaged.__init__:image_only: Current default value of argument `image_only=False` has been deprecated since version 1.1. It will be changed to `image_only=True` in version 1.3.\n",
+      "monai.transforms.croppad.dictionary RandSpatialCropd.__init__:random_size: Current default value of argument `random_size=True` has been deprecated since version 1.1. It will be changed to `random_size=False` in version 1.3.\n"
+     ]
+    }
+   ],
    "source": [
     "preliminar_shape = input_shape + [50] # We take random slices fron the center of the brain\n",
     "crop_shape = input_shape + [1]\n",
@@ -257,7 +277,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 9,
    "id": "98d14e75",
    "metadata": {},
    "outputs": [
@@ -270,7 +290,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -300,7 +320,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 10,
    "id": "fa17d864",
    "metadata": {},
    "outputs": [],
@@ -310,7 +330,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 11,
    "id": "8f126b17",
    "metadata": {},
    "outputs": [],
@@ -335,7 +355,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 12,
    "id": "255c90c7",
    "metadata": {},
    "outputs": [],
@@ -367,7 +387,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 13,
    "id": "c18dbad8",
    "metadata": {},
    "outputs": [],
@@ -387,7 +407,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 14,
    "id": "89989c34",
    "metadata": {},
    "outputs": [],
@@ -404,7 +424,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 15,
    "id": "5b8b676f",
    "metadata": {},
    "outputs": [],
@@ -425,7 +445,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 16,
    "id": "36ea4308",
    "metadata": {
     "scrolled": false
@@ -436,7 +456,9 @@
      "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=VGG16_Weights.IMAGENET1K_V1`. You can also use `weights=VGG16_Weights.DEFAULT` to get the most up-to-date weights.\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=VGG16_Weights.IMAGENET1K_V1`. You can also use `weights=VGG16_Weights.DEFAULT` to get the most up-to-date weights.\n",
+      "Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /home/walter/.cache/torch/hub/checkpoints/vgg16-397923af.pth\n",
+      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 528M/528M [00:07<00:00, 77.9MB/s]\n"
      ]
     }
    ],
@@ -450,7 +472,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": 17,
    "id": "3b57abd3",
    "metadata": {},
    "outputs": [],
@@ -469,7 +491,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 18,
    "id": "918eac0a",
    "metadata": {
     "scrolled": false
@@ -486,13 +508,13 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|█████| 15/15 [00:08<00:00,  1.74it/s, kld=378, perceptual=0.395, generator=2.04, feature=0.206, discriminator=3.69]\n",
-      "  0%|                | 0/2 [00:00<?, ?it/s, kld=356, perceptual=0.371, generator=2.1, feature=0.203, discriminator=3.62]"
+      "100%|█████| 15/15 [00:16<00:00,  1.12s/it, kld=293, perceptual=0.339, generator=1.94, feature=0.125, discriminator=3.96]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=305, perceptual=0.351, generator=1.94, feature=0.124, discriminator=3.94]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -504,7 +526,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|████████| 2/2 [00:00<00:00,  3.18it/s, kld=252, perceptual=0.362, generator=2.1, feature=0.204, discriminator=3.61]"
+      "100%|███████| 2/2 [00:00<00:00,  3.21it/s, kld=197, perceptual=0.339, generator=1.93, feature=0.121, discriminator=3.94]"
      ]
     },
     {
@@ -519,32 +541,31 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.18it/s, kld=279, perceptual=0.395, generator=2.15, feature=0.202, discriminator=3.7]\n",
-      "  0%|                 | 0/2 [00:00<?, ?it/s, kld=284, perceptual=0.405, generator=2.18, feature=0.18, discriminator=3.6]"
+      "100%|█████| 15/15 [00:06<00:00,  2.17it/s, kld=162, perceptual=0.361, generator=1.99, feature=0.127, discriminator=3.79]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.02it/s, kld=116, perceptual=0.324, generator=2.09, feature=0.131, discriminator=3.63]"
      ]
     },
     {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 400x150 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 2/100\n"
+     ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|████████| 2/2 [00:00<00:00,  3.25it/s, kld=184, perceptual=0.421, generator=2.2, feature=0.196, discriminator=3.36]"
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.15it/s, kld=155, perceptual=0.238, generator=2.41, feature=0.147, discriminator=3.03]\n",
+      "100%|████████| 2/2 [00:00<00:00,  3.92it/s, kld=179, perceptual=0.34, generator=2.41, feature=0.183, discriminator=2.95]"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 2/100\n"
+      "Epoch 3/100\n"
      ]
     },
     {
@@ -552,32 +573,31 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.14it/s, kld=207, perceptual=0.421, generator=2.32, feature=0.214, discriminator=2.83]\n",
-      "  0%|                | 0/2 [00:00<?, ?it/s, kld=198, perceptual=0.426, generator=2.3, feature=0.221, discriminator=2.82]"
+      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=199, perceptual=0.286, generator=2.31, feature=0.164, discriminator=3.36]\n",
+      "100%|█████████| 2/2 [00:00<00:00,  4.28it/s, kld=144, perceptual=0.3, generator=2.53, feature=0.179, discriminator=2.68]"
      ]
     },
     {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 400x150 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/100\n"
+     ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████| 2/2 [00:00<00:00,  3.47it/s, kld=125, perceptual=0.414, generator=2.33, feature=0.222, discriminator=2.82]"
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.19it/s, kld=483, perceptual=0.47, generator=2.29, feature=0.238, discriminator=2.82]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.43it/s, kld=296, perceptual=0.449, generator=2.33, feature=0.237, discriminator=2.78]"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 3/100\n"
+      "Epoch 5/100\n"
      ]
     },
     {
@@ -585,32 +605,31 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.17it/s, kld=131, perceptual=0.384, generator=2.31, feature=0.219, discriminator=2.68]\n",
-      "  0%|                | 0/2 [00:00<?, ?it/s, kld=117, perceptual=0.382, generator=2.38, feature=0.23, discriminator=2.57]"
+      "100%|█████| 15/15 [00:06<00:00,  2.25it/s, kld=258, perceptual=0.456, generator=2.84, feature=0.273, discriminator=2.15]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.31it/s, kld=150, perceptual=0.466, generator=2.83, feature=0.275, discriminator=2.15]"
      ]
     },
     {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 400x150 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 6/100\n"
+     ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████| 2/2 [00:00<00:00,  3.38it/s, kld=87.2, perceptual=0.403, generator=2.35, feature=0.221, discriminator=2.59]"
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.17it/s, kld=80.9, perceptual=0.406, generator=2.88, feature=0.245, discriminator=2.05]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.98it/s, kld=51.4, perceptual=0.422, generator=2.89, feature=0.249, discriminator=1.97]"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 4/100\n"
+      "Epoch 7/100\n"
      ]
     },
     {
@@ -618,32 +637,47 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:07<00:00,  2.12it/s, kld=170, perceptual=0.353, generator=2.46, feature=0.17, discriminator=2.51]\n",
-      "  0%|                | 0/2 [00:00<?, ?it/s, kld=203, perceptual=0.38, generator=2.46, feature=0.179, discriminator=2.38]"
+      "100%|██████| 15/15 [00:06<00:00,  2.19it/s, kld=101, perceptual=0.375, generator=2.75, feature=0.194, discriminator=2.1]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.16it/s, kld=73.3, perceptual=0.341, generator=2.81, feature=0.162, discriminator=2.65]"
      ]
     },
     {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 400x150 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 8/100\n"
+     ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████| 2/2 [00:00<00:00,  3.34it/s, kld=113, perceptual=0.339, generator=2.48, feature=0.174, discriminator=2.51]"
+      "\n",
+      "100%|███████| 15/15 [00:07<00:00,  2.14it/s, kld=130, perceptual=0.4, generator=2.91, feature=0.203, discriminator=1.89]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.42it/s, kld=101, perceptual=0.385, generator=2.94, feature=0.185, discriminator=2.08]"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 5/100\n"
+      "Epoch 9/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=156, perceptual=0.352, generator=2.68, feature=0.184, discriminator=2.03]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.28it/s, kld=97.8, perceptual=0.343, generator=2.63, feature=0.183, discriminator=2.08]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10/100\n"
      ]
     },
     {
@@ -651,13 +685,13 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.15it/s, kld=181, perceptual=0.321, generator=2.52, feature=0.203, discriminator=2.23]\n",
-      "  0%|               | 0/2 [00:00<?, ?it/s, kld=170, perceptual=0.313, generator=2.53, feature=0.202, discriminator=2.21]"
+      "100%|█████| 15/15 [00:06<00:00,  2.25it/s, kld=159, perceptual=0.347, generator=2.92, feature=0.185, discriminator=1.76]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=166, perceptual=0.348, generator=2.94, feature=0.176, discriminator=1.93]"
      ]
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVUAAACFCAYAAADrRWu1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABxDUlEQVR4nO2deXhU9dn+P5NkMpPJzGQykz0BQghL2JuguIDgVrRF616s+kqrttq6tbW1rfoaW6u2LvXVttqqr1jpa23RarUuPzesqGAFBYEAYQmQfZlMMnsyk/P74+T5ciYJiwok2Lmvi4vMzJmzznnOs9zP/Zg0TdNIIokkkkjioCBluHcgiSSSSOKLhKRRTSKJJJI4iEga1SSSSCKJg4ikUU0iiSSSOIhIGtUkkkgiiYOIpFFNIokkkjiISBrVJJJIIomDiKRRTSKJJJI4iEga1SSSSCKJg4gvpFGtq6vDZDJxzz33HLR1Ll++HJPJxPLlyw/aOpMYjOR5/uJh8eLFlJaWDvduHDaMKKO6ZMkSTCYTH3744XDvyhGLkXYOQ6EQ1dXVSSPZjw0bNnDxxRdTXFyMxWKhqKiIiy66iA0bNnyu9d5xxx0899xzB2cn94P33nuP6upqfD7fYdnekYYRZVST+OIhFApx2223HbBRPeGEEwiHw5xwwgmHdseGAc8++yyVlZW88cYbfPOb3+T3v/89l112GW+99RaVlZX8/e9//8zrPtxG9bbbbjtgo/rII4+wefPmQ7tTIwhpw70DSSRhREpKClardbh346Bj27ZtXHLJJZSVlfGvf/2L3Nxc9dl1113H3LlzueSSS1i3bh1lZWXDuKcHH2azebh34bDiiPJUe3p6+O///m+qqqrIysoiMzOTuXPn8tZbb+31O7/5zW8YM2YMGRkZzJs3j/Xr1w9aZtOmTZx33nm43W6sViuzZs3iH//4x6E8lMOKxYsXY7fbaWho4KyzzsJut5Obm8sNN9xAPB5Xyxlz0fs7b/Pnz2f+/PlDbkvyZ3V1dcp43HbbbZhMJkwmE9XV1Xvd16FyqvPnz2fq1KmsW7eOefPmYbPZKC8vZ9myZQC8/fbbzJ49m4yMDCZOnMjrr7+esM6dO3fy3e9+l4kTJ5KRkYHH4+H888+nrq5u0PZlGxkZGZSUlHD77bfz+OOPYzKZBi3/8ssvM3fuXDIzM3E4HHz1q1/daxh/9913EwqF+OMf/5hgUAFycnL4wx/+QDAY5Ne//vWQ59KI6upqTCaTem0ymQgGgzzxxBPqHC9evDhh2U2bNnHBBRfgdDrxeDxcd911RCIRtQ659kuWLBm0PeM1q66u5kc/+hEAY8eOVdsb6lzu7TiMv7Pf/e53lJWVYbPZ+PKXv8zu3bvRNI1f/OIXlJSUkJGRwde+9jW8Xm/COp9//nm++tWvUlRUhMViYdy4cfziF79I+D0LZBsZGRkcffTRvPPOO0P+fqPRKLfeeivl5eVYLBZGjRrFj3/8Y6LR6F6PbSgcUZ5qd3c3jz76KBdeeCFXXHEFfr+fxx57jAULFvDBBx8wc+bMhOX/9Kc/4ff7+d73vkckEuF//ud/OOmkk/jkk0/Iz88H9BzX8ccfT3FxMT/5yU/IzMzkr3/9K2eddRbPPPMMZ5999jAc6cFHPB5nwYIFzJ49m3vuuYfXX3+de++9l3HjxnHVVVclLHsg5+1AkJuby0MPPcRVV13F2WefzTnnnAPA9OnTP/X+d3Z2snDhQhYtWsT555/PQw89xKJFi/jzn//M9ddfz5VXXsk3vvEN7r77bs477zx2796Nw+EA4N///jfvvfceixYtoqSkhLq6Oh566CHmz5/Pxo0bsdlsADQ0NHDiiSdiMpn46U9/SmZmJo8++igWi2XQ/jz55JNceumlLFiwgF/96leEQiEeeugh5syZw0cffTTIGL7wwguUlpYyd+7cIY/vhBNOoLS0lH/+85+f+tw8+eSTXH755Rx99NF8+9vfBmDcuHEJy1xwwQWUlpZy5513snLlSh544AE6Ozv505/+9Km2dc4557BlyxaeeuopfvOb35CTkwMw6EFxIPjzn/9MT08P11xzDV6vl1//+tdccMEFnHTSSSxfvpwbb7yRrVu38uCDD3LDDTfwv//7v+q7S5YswW6384Mf/AC73c6bb77Jf//3f9Pd3c3dd9+tlnvooYe4+uqrmTt3Lt///vepq6vjrLPOIjs7m5KSErVcX18fZ555JitWrODb3/42FRUVfPLJJ/zmN79hy5Ytny61oo0gPP744xqg/fvf/x7y81gspkWj0YT3Ojs7tfz8fO1b3/qWem/Hjh0aoGVkZGj19fXq/VWrVmmA9v3vf1+9d/LJJ2vTpk3TIpGIeq+vr0877rjjtPHjx6v33nrrLQ3Q3nrrrc97mIcUQ53DSy+9VAO0n//85wnLfulLX9KqqqrU609z3ubNm6fNmzdv0PYvvfRSbcyYMep1W1ubBmi33nrrAe3/UOd53rx5GqD93//9n3pv06ZNGqClpKRoK1euVO+/+uqrGqA9/vjj6r1QKDRoO++//74GaH/605/Ue9dcc41mMpm0jz76SL3X0dGhud1uDdB27NihaZqm+f1+zeVyaVdccUXCOpubm7WsrKxB7/t8Pg3Qvva1r+3z2M8880wN0Lq7uzVNG3wuBbfeeqs28NbNzMzULr300r0ue+aZZya8/93vflcDtLVr12qatufaG8+bYOD1u/vuuxPOx/4w8DhkW7m5uZrP51Pv//SnP9UAbcaMGVpvb696/8ILL9TS09MT7tGhrul3vvMdzWazqeWi0ajm8Xi0o446KmF9S5Ys0YCE3++TTz6ppaSkaO+8807COh9++GEN0N59990DOlZN07QjKvxPTU0lPT0d0J8sXq+XWCzGrFmzWLNmzaDlzzrrLIqLi9Xro48+mtmzZ/PSSy8B4PV6efPNN7ngggvw+/20t7fT3t5OR0cHCxYsoLa2loaGhsNzcIcBV155ZcLruXPnsn379kHL7e+8DQfsdjuLFi1SrydOnIjL5aKiooLZs2er9+Vv43FlZGSov3t7e+no6KC8vByXy5Xwu3nllVc49thjEyIet9vNRRddlLAvr732Gj6fjwsvvFD9Ztrb20lNTWX27NmD0lF+vx9Aec57g3ze3d29z+U+C773ve8lvL7mmmsAhvWann/++WRlZanXcu0uvvhi0tLSEt7v6elJuBeN11Tu3blz5xIKhdi0aRMAH374IR0dHVxxxRUJ67vooovIzs5O2Je//e1vVFRUMGnSpIRretJJJwHsM8U4EEdU+A/wxBNPcO+997Jp0yZ6e3vV+2PHjh207Pjx4we9N2HCBP76178CsHXrVjRN45ZbbuGWW24Zcnutra0JBuZIhdVqHRSiZWdn09nZOWjZ/Z234UBJSUlCHhEgKyuLUaNGDXoPSDiucDjMnXfeyeOPP05DQwOaYdhFV1eX+nvnzp0ce+yxg7ZdXl6e8Lq2thZA3XAD4XQ6E16LsRTjujccqPH9LBh4TceNG0dKSso+c6GHGqNHj054LdfuQK7phg0buPnmm3nzzTcHPYTkmu7cuRMYfP3S0tIGpWdqa2upqanZaxqjtbX1QA5JX/8BLzkCsHTpUhYvXsxZZ53Fj370I/Ly8khNTeXOO+9k27Ztn3p9fX19ANxwww0sWLBgyGUGXpAjFampqQd1fSaTKcE4CYYqFBwM7G3/9/a+cd+uueYaHn/8ca6//nqOPfZYsrKyMJlMLFq0SP0GPg3kO08++SQFBQWDPjd6RaAbhcLCQtatW7fP9a5bt47i4mJllAc+RAQH4xwPXPeh3Nbe8Fmvqc/nY968eTidTn7+858zbtw4rFYra9as4cYbb/zM13TatGncd999Q34+0NDvC0eUUV22bBllZWU8++yzCT+CW2+9dcjlxaMwYsuWLeopJdQVs9nMKaeccvB3+AjF/s4b6F7uUKkD8Q4Ee7tZDyeWLVvGpZdeyr333qvei0Qig3iWY8aMYevWrYO+P/A9KQLl5eUd8O9m4cKFPPLII6xYsYI5c+YM+vydd96hrq6O73znO+q97OzsIbmgA88x7P8819bWJkRzW7dupa+vT11TCYcHbu+zbOtQY/ny5XR0dPDss88m8Jl37NiRsNyYMWMA/VhPPPFE9X4sFqOuri6hYDpu3DjWrl3LySef/LmP74jLqUKiF7Jq1Sref//9IZd/7rnnEvIwH3zwAatWreL0008H9Jti/vz5/OEPf6CpqWnQ99va2g7m7h8x2N95A/1HuGnTpoRztHbtWt59992EdUllfTi7b1JTUwd51Q8++OAgL2zBggW8//77fPzxx+o9r9fLn//850HLOZ1O7rjjjoQUlGCo382PfvQjMjIy+M53vkNHR0fCZ16vlyuvvBKbzaboSqCf466urgQPt6mpacgmgczMzH2e49/97ncJrx988EEAdU2dTic5OTn861//Slju97///ZDbguG7pkPZgZ6enkH7OmvWLDweD4888gixWEy9/+c//3lQ2uuCCy6goaGBRx55ZND2wuEwwWDwgPdvRHqq//u//8srr7wy6P358+fz7LPPcvbZZ/PVr36VHTt28PDDDzN58mQCgcCg5cvLy5kzZw5XXXUV0WiU+++/H4/Hw49//GO1zO9+9zvmzJnDtGnTuOKKKygrK6OlpYX333+f+vp61q5de0iPdSTiQM7bt771Le677z4WLFjAZZddRmtrKw8//DBTpkxJyHFlZGQwefJknn76aSZMmIDb7Wbq1KlMnTr1sB3PwoULefLJJ8nKymLy5Mm8//77vP7663g8noTlfvzjH7N06VJOPfVUrrnmGkWpGj16NF6vV3kwTqeThx56iEsuuYTKykoWLVpEbm4uu3bt4p///CfHH388v/3tbxPWPX78eJ544gkuuugipk2bxmWXXcbYsWOpq6vjscceo729naeeeiqBCrVo0SJuvPFGzj77bK699lpF25owYcKgwmxVVRWvv/469913H0VFRYwdOzahgLdjxw7OPPNMTjvtNN5//32WLl3KN77xDWbMmKGWufzyy7nrrru4/PLLmTVrFv/617/YsmXLoPNZVVUFwE033cSiRYswm82cccYZytgeahx33HFkZ2dz6aWXcu2112IymXjyyScHPTjT09Oprq7mmmuu4aSTTuKCCy6grq6OJUuWMG7cuASP9JJLLuGvf/0rV155JW+99RbHH3888XicTZs28de//pVXX32VWbNmHdgOHjBP4DBA6EB7+7dr1y7tjjvu0MaMGaNZLBbtS1/6kvbiiy/ulbJx9913a/fee682atQozWKxaHPnzlUUEiO2bdum/dd//ZdWUFCgmc1mrbi4WFu4cKG2bNkytcyRTqnKzMwctOxAas6nPW9Lly7VysrKtPT0dG3mzJnaq6++OiQN6L333tOqqqq09PT0/dKr9kapmjJlyqBlx4wZo331q18d9D6gfe9731OvOzs7tW9+85taTk6OZrfbtQULFmibNm3SxowZM4iG9NFHH2lz587VLBaLVlJSot15553aAw88oAFac3PzoH1dsGCBlpWVpVmtVm3cuHHa4sWLtQ8//HCvx7du3Trtwgsv1AoLCzWz2awVFBRoF154ofbJJ58Mufz/+3//T5s6daqWnp6uTZw4UVu6dOmQlKpNmzZpJ5xwgpaRkaEB6rhk2Y0bN2rnnXee5nA4tOzsbO3qq6/WwuFwwjpCoZB22WWXaVlZWZrD4dAuuOACrbW1dchr9otf/EIrLi7WUlJS9kuv2tf9OfB8Atrf/va3hPeH+k2/++672jHHHKNlZGRoRUVF2o9//GNFpxt4jz7wwAPKZhx99NHau+++q1VVVWmnnXZawnI9PT3ar371K23KlCmaxWLRsrOztaqqKu22227Turq69np8AzGijGoSw4u9/dj/03HddddpVqtVi8Viw70rnxpiVNva2oZ7V0YM4vG45na7tcsvv/yQrP+IyqkmkcShRjgcTnjd0dHBk08+yZw5cw46gyKJQ49IJDIoLfCnP/0Jr9c7ZJv1wcCIzKkmkcRw4dhjj2X+/PlUVFTQ0tLCY489Rnd39155zEmMbKxcuZLvf//7nH/++Xg8HtasWcNjjz3G1KlTOf/88w/JNpNGNYkkDPjKV77CsmXL+OMf/4jJZKKyspLHHnvsCylF+J+A0tJSRo0axQMPPIDX68XtdvNf//Vf3HXXXao782DDpA30jZNIIokkkvjMSOZUk0giiSQOIpJGNYkkkkjiICJpVJNIIokkDiIOuFBlMlUfwt1IYiA0rfpzr2O4e7T/03CwyhNut5tgMIimafu8hvLZp9nuf8pvYn/nRD43m82fqgX1QJCs/ieRxAjF3gzggSpM/Sdjf+fEZDLR19d30B6ERiSNahJJJPEfgcP1MEoa1SSSGIHYX+g/UjGU5zdSjmPgOU0a1SSS+A/BgeQDD6Wh+qzrPpIeBJque5IM/5NI4j8Bw2GYDsY29zYN4j8NSUpVEkkkcdBgMpmOGG/1UCHpqSaRxH8gPovhO5DviKc6cNn/JA82aVSTSCIJhaEM51C50gNdbuD7/wnGNWlUk0jiCMPnDa8HVsAPtCou7+/rczGaAz3WvXmwgi+SsU0a1SSSOELwaYzpgSwr+U+jsUxJSUkwhEaSfEpKihq/rWnaoMGJYlT7+vrUOlJSUtTy8tm+9veLYFyPUKOaARgV2s397wm6h/jM+F4ShxOpqamkpaWpGyslJYXU1FR1E8rNNjBM1DRtyGmlSewdnzVXavxeSkoK6enp6rqJIRSDZ7VaycjIoLe3l3A4rL4rxjQajSYo7g/8/r6oV18EBsERZFQrgWKgBk65GF6v7n/PCcyH+w2LXr8EqOt/cTbcPxmuf1r/bhKHBQ6Hg9GjR5ORkcH48eMZN24c3d3d+Hw+PB4PU6ZMweVyEQgECAaD1NXV4ff7yc7OJi0tjWg0SltbG2+88QY9PT3EYjHa29uH+7CGDQe7oi5eqXimaWlpZGRkKAObnZ1NQUEBHo+Hvr4+QqEQsViMYDBIdnY2Y8eOxWq14vV66ezsxGq1omkaPT09dHR0UF9fT0dHB2lpafT29iojeyBc1r3lZY8UHAFG9SagDi4eD9cDW6swn9JN7/xqWP8ykAbzgeVADox/ZC21WxfDb6thTjVcDRVfX0NN89fhrur+dVYDK4DXD+eB/EdgwoQJTJs2jdGjRzNr1iwKCwtxuVyYzWa8Xi9NTU04HA7GjRtHZmYmPT099Pb2Ul9fj9/vJz8/n7S0NOLxOG1tbeTm5tLW1kY8Hmfbtm20t7ezefPm4T7MQ47PQ8Af+P2Bf4tBTU1NVf/sdjtHHXUURUVFRCIRCgoKKC8vx2KxkJKSwq5du9i9ezegjx2fMmUKHo8Hk8lETU0NXq+XCRMmEIvF2L17Nz6fj08++QSTyUR6ejoff/wxXq+XeDyuDLnRcx0qLXAojeuh9IgPWPn/8KtUXQSu8bAccmfswkYIGyH1aQgbHUF9brs900+zKQfda60lpbkImz1ERmaYNtMGuOF0xt+9lqZgEYGZufoKjgGWAjwEtBzWIzsQHGkqVSkpKdx4443Mnj2bkpIS7HY7VqtVDcuTXFwoFCIej5Oenk4sFqO3t1cZ0Xg8Tl9fH5FIRKUL5EY0mUzs3LmTN998kw0bNrBz5066uroO2/EdCA62SpURnzefasxxilFNS0vDbDaTnZ3NMcccQ2FhIdOnT6etrY1QKERpaSk2m015odu3byccDtPT00Nubi5ZWVkUFxcTCASoq6ujp6eHiRMnEg6HiUajdHd309LSov698cYbRCKRhHSAMXVgxECP1nhuD9Z57uvrIyUlZdCwx8+LkeupzhxPxUdrEt7a0VVK5HI3uHSPdFSm/uSseaMS2ME72onM/dFqIMiozN3U/LISeBJ8p5NGXF++drdaX83SPOAqdM81ic+DyZMnc+yxxzJt2jRsNhsA8XhceaLp6emkp6djtVqVMQ2Hw+pmEuMroWJGRgZpaWkUFhaSmpqq1lFXV0dDQwPRaBS73Y7f76e7O5kv3xeMOVPxUNPS0sjMzKSgoIDCwkJGjx5NTk4OsVgMi8VCKBSiqamJzMxMLBYLWVlZ2O120tLSiEQiBINBfD4fHR0duN1ulSPv6OjA4/HgcDhwu91kZ2djNpvJyMhgwoQJtLe3093dTW9vr3qQSsFrfwyEIyUFMAKNqhm4Ej7WXzVGi+iyevrf74Wbgduhtm4Gua/tIpUYPAx8PJa5o1ZDfS2pP8nXv3wzsPwmeBhipJJGnCgWtpsmw80mYB16njUf3VuVYtfBfXJ9keF0OjnttNOYO3cukyZNIj09nVAoRG9vr8qx9fb2Yjab1U2ZkpKi8mtieC0Wi/JSo9Eoqamp9PT0qDyfpmnY7XamT59OdnY2HR0dbNy4kaamJuLxOOFwmE2bNgGDvZ4vMvbmzclnxnDfZDKRmppKeno6DoeDiRMncswxx1BeXs6GDRuor6+nvb2djIwMNE0jEAgQCAQIhULk5OTgdDrp6elR16a9vZ01a9bgcDjIycmhqKiIcDhMZ2cnNpsNs9lMWlqa+m5GRgZ+v5/29nZCoRBer5eamhoCgQDRaFTleGXfjamMvr6+BKm+z2tgD6WBHmFG1Q1p10IaFIS3AxCNpMPlZt55pAoACz3s/sUozj31JdpOHQ2vd8B5MGfGa6xoP5UyrQcLW/XVpcGl8x7iifmnUXv7dCrGfdS/nQ9g5WwAyrQi4oxipykIp1VBAFixCugF3u7/P4m94bLLLuOkk06iuLhY3TTibUrYHo/HVaHCarViNpvRNI3U1FT6+vqIx+P09vbS29uL3+8nFoupwogsF4/HsVgsjB49mpKSEnw+H5FIhI6ODrxeLwAVFRVomsbGjRuH+awMD4xsiqGoUuJNmkwm8vLymDZtGna7Ha/Xy86dO6mvr8fhcFBUVKS8S03T2L17NzU1NVRUVDBq1CjFyLBYLNhsNjo6OkhPT8dsNhOLxQiHw4wePZrc3FxsNhs2m41IJMKYMWNwOBzs3r2bQCCA3+/HZrPx0Ucf0dnZSTQaJS0tjdTU1EF0LuOxjPRmghFmVM+BcqioSQz7SQObwXs89+2XsD/XxpuZJ3G06R+wrJsV006FGFiIAlDzTCXEVvFfPMkTd10F6Cd/+1VToARmvLaStSYPqYR0b7d/O7iAhbMhBryyBvAe4mM+8pCSksJxxx2Hx+Nh+vTplJaWYrFYVMFB/vX29qobBCAa1a/NQI9D0zRisRjRaFSFgpJfFa+zt7dX3UhSqQaUZxuPx0lLS8PpdDJp0iT6+vrIyMggIyND5c6sViv/+te/vtCerNH4DMyd2mw2nE4nZrMZj8ej0jCNjY20tLTQ2dkJoCKFUCikHoA+n4+GhgbS09PJzMwkHA7T29urDKZ4rykpKbS3t6scenZ2NqCnd4LBIHa7HZfLhaZp5ObmkpmZSTQaZf369YRCITRNSxgdnZGRQU9PD8FgUP0mRnoL7AgyqhVACe71DftfdD4ECHA0r3OstoFL+BPfzV4Cz0HN+ErEUaV+BhexFH6yCtJmU3ODfoH5GNaatsLFx1Br+gc8fCawag8Lywp8WA9MZ/Ap2go5i6H9GaCVkVjkOlRISUlh+vTpzJkzh8mTJ1NaWkpBQQGZmZn09vYSi8XIyMhQeTLxaFJSUpSR7evrIxaLqRRAJBJR3xXPNi0tTf3f09OjjKB4LmlpaSonaLVaAZ07WVFRwbRp00hLSyMWi6n1dHR0EAqFSElJ4ZhjjmH9+vW8//77dHR0DNu5PBB8lgq10ZjKP4vFgsfjYcKECYwfP14VnlpbW+no6GDbtm0Eg0HS0tJwu91kZmYqZkY8Hle8VPlOVlYW0WiUvr4+zGYzLpcLh8NBPB4nNTWV7Oxs+vr68Pv99PX1kZqaisViIRwOs23bNpXq8Xg8FBYWYrFY1G8iEomQl5eH1WolHA7jdDrxeDy89tpr7Nq1Sz2YBzYoyN8jAcNsVKcBfpi5GG6Hiq+u2d8XdJTA+N3d1P5qLO+b8vmtdjV83AvPmeFqeOa6r1BKHVXTNtKcVgYvlsHCFqZq7TzEecw1PQ4cD0vXAU495D9lNvjQ//5wHZCGPTBFFcMENWcvhnqg3QPl58LWeuCv/Cc0FzgcDk4++WRmz55NRUUFZrNZFZg0TSMcDmO320lPTycejxOLxVQez5jfi8X0yCASiRAIBFSYb7FYEkJVqSKnpKQowx0KhcjKyiIzM5O5c+dit9tZtWoVsViME044gVmzZqlQ1Gw2k5KSQldXFx0dHaxbt476+nqOOuooJk2axD333DOcp/OAsC/Duq8qv7EDKi0tjdGjR3PcccdRUFCA3+9n5cqVbNu2jVgsplgU4l2KIY7H4/h8Pnp6enC5XLjdbkWRcjgcWK1W+vr68Pl8RKNRZYzFe5XKekpKiiqCbd++nfLycjIzM0lPT8fn8+FwOJgxYwY5OTmKMRIMBrHZbHR1dRGNRpkzZw4vv/wynZ2dquFgIDVrpGAYjWo1/Zwmxny0KYEutV/EwI8DPkT3KoHVY2bAdfrfcVI5n7/B+uW4Y+PxXl0M9HIfP2DuE6v7t+tBz5eaIQYlr9WSTg8dUQ9d/esMrMyl5hQXvGiGhehnqwBKdtdSbzoetrbAKSXwupsvslE1mUxMmzaNk046ienTp1NYWIjNZkvomDEWE6TYIN6ppmmqM0eKU2KEe3p61Ofi0RrTCCkpKZjNZgB6enrUTW2xWBgzZowim3d1dZGXl4fL5VLrEoNis9lwuVxEIhF8Pp/Kx1566aW8++671NXVKUN/pGAogROjoRGmRU5ODmVlZUyaNInc3Fx8Ph/t7e1s2bKF5uZmxRu1Wq0q3202m7FYLFitVkV5i8ViZGdnY7FYlPGU1IDJZFI0LEkPGNMBJpOJpqYmSkpK6O7upqGhgbKyMvW58aEp+yDsD9lni8XCCSecwPr162lubsbv9ye0yo4kwzp8RrWuF5ZdDDcAbPp0370amo8tgwgsCX990MevcwrbTS8CMbxp84FfAr182fSN/r+lzfUKSrRa6h1Q/5MX4LwfkLW0ec+K2gHqYOFWOOZ03nj/OE42PUi96W10I1oOr18MnAPch57C+GJ1bZlMJqqqqrjwwguZP38+6enpKgcqEKOampqqwngxqICi6cRisYTPJTSUnJ+kBMS4irfb09NDV1cXNptNeTNibIuLiykvL6ezsxOPx0N6ejo9PT0AKnyVbZSVlZGZmUkoFOKTTz6htbWViy++mPT0dJYtW0ZfXx8ff/zxcJzmfeJAxE4A9SBJSUkhIyODqVOnMnbsWKZPn86UKVOIRqO88847rF69mubmZhVKm81mTCaTCvOluCR0qlAoRDAYxGq14nK5yM7Oxu12q+tpMpkIh8OK9SFpHIlQrFYrfr+fzs5Oxo4dy44dO1RDhzz43G43zc3NdHZ2YrFYsFgsZGRk4HK5sFqtZGZmUlVVxdixY6mrq2PNmjW0tLQQDoeHfCAOp5EdBqN6Dlw+HRYBi6FCO8CQ34DVN03WG632golshk2/gUndMAv48CY4DXjlH8CVYDVBpAU+Bgd++C2w4gdwsaxhXf//k4HxQAusrOVxvglUwOVV8OgK4HgqtDW0k0NbRjVEVgAXoHdqvfupj2skYt68eVx88cWMGzdOGVShSgmMxSip4ovBlOq9GErJlYqxk38S8kvqoKuri0gkQmtrKz6fD7PZTEVFBVarlXg8TigUUoY5KytLFWJk38Qb7unpwWw2k56eTl9fH8XFxaSkpOByuaipqaGxsRGHw8H3v/99CgoKuO+++3j55ZeH63R/JhgJ9JqmKfpaRUUF2dnZRKNRurq68Pv9ivObmpqqjGlmZmZCQUu8XI/HQ0lJCZqm0dLSQjAYVB6xRAsmkwmXy4XT6WT37t0JlCvxWlNSUojFYqqpo7y8nPb2drX9WCyG2WwmJyeHtrY2VXiMx+Pk5uaSk5NDU1MTZrOZSZMmUVFRgdvt5q233iIQCNDW1qa83kM1IfXT4DAb1WrM7d3Y7M10Wd+F+nPxf8ehG7Yh0BLPJ/Kx+1NvJY8W7p/4Ha4v+YOuCWAFXBqUl8LM/if9x92wKZ+anMmUXFqL41J9H2Kk0rX1In2Zdn2fuasaVsDTHfmQZqPikTVsvWs6vYEYNQ2TKSveBuFdtJlmw3wTxE6FFWFgNnrH1pGHlJQUnE4nX/va1zj22GOVNyIFIKNikeS1xAOV5YyGUsJ/+dEbaTOAqvoKRScYDOJ0Ounu7lbekHg14u1K6CrejBhkKWwZi2Wyfdn//HydyxwMBmltbVVczJNPPnlEG9WBbahG6pSEzS6Xi/z8fEaPHo3dbqezs5O6ujqCwSANDQ2EQiHS0tKwWCykp6eTlZWFyWTCbDbT09NDIBBQDymHw4HZbKawsFAZQovFonr6Q6EQ4XAYr9eLz+ejt7dX5V7b2tpoaWlB0zTFLe7u7mbMmDEJRUhJ70hOXjze7u5uNm3aRE5ODmlpabS2tpKamkpBQQGVlZUqknnvvfeora1NUM0azlzrYTKqTuBs4Bl6fefQldMLi8+FZVA/Te/pr7hsDZ24aL6mbM/XftsLZ0HB37d/qq3NXb0aZq0DXoPFp8LWalheDZOmQ6R/oUnjYdHTgJv6klPhBqi4bg1pxBWfdaurnN5J1bq2wE92cJ7nLZ6KXULNNZXwkwicZYaPf8n2rbdSMe4j2hgNyzXAhJ4KODINKsBRRx3F2WefzcSJEzGZTEQiEUXkl3BeIF6hUHSkuCTGVzwII+fQWOACVJ6us7OTHTt2UFBQwIQJE/B4PBQXF5Oenq66q3w+n8rbSldQd3e3MpxiSHt6ehT3EfQHhdx4UmzJy8tTBqG2than00lJSQn19fWH7Vx/XohhTU1NJSsri9LSUkaNGoXVasXhcNDT00NzczPhcFjxgLOyslQe1el0KiMpKlNdXV1kZGQoAykpBankm0wm1QDQ0dGhhHF8Pp/yglNSUvB6vXR3d9PZ2Ul2djbNzc2EQiHy8/NVukcYHRLlSAGsr6+Pzs5OAoEATqeTcDhMQ0MDDoeD4uJiuru7sVqtuN1u/vjHPyq2wXDjMBnVNGAssBPK64C/woc3wsMw9aJ/s94UpebqObrBmwVH//tt/WsPwi38nCKaPt3mZmmwfjpM1WBrB2DuN4xQcecaajZU6mkBMmDWqXpK9/qnqYl9nYof7klHlHu2Qg16eH/KWG7gq/g0Fy//6Bwo6YE0KxxTjXBgWQ5sNcGVQMl4qLscePSznbJhxOmnn86ZZ55JKBSiq6srwfsTGpSRFmUkahu1NwHlZcprSPQiJDfqcDhISUlR3khpaSlutxuXy0VpaakyzHV1ddTW1pKamkpZWRkejwen06m8VNkX4b1Go1HV2SOGQPbFbDZTWlpKMBhUXtW4ceMYN27cEWVUYU8+taioCKfTSU5ODhaLhUAgoCrtoVAIh8NBfn6+EkqRPKnFYsHn8wEomppwgI2Fx1gspnQbpOhUX19Peno6ZWVlWCwWuru7VaSTn5+P1WqlublZKZdt2rSJYDBIYWEhGRkZxGIxlffu6upSeXQxzuLJCiugu7ubmTNnYrVaWbduHVVVVcycOZPVq1cTDAb/E8L/q+Av+bBoHVjnQwQKtPNpXgWsgCe4lFYtjxi65+IgsNd0wIHD1M85bYWp+bDwJubc+Ro2QmQQYtyUbfjCLlaYKnV6lB2wfl03ij/c95pv52Z+dvcvCdztIJ0eTv7Ve7DMRM15X6Ji3hqYBzVLKvtTByWf8zgOP5xOJyeddBIVFRXU1taqwoMYLTGkRh1NQHXCiNdkrOIbPSnjd4ypBHnf7XarPnRZr3jFwWBQ9frHYjEKCgpUTlbyvVKBBhKaECKRiPK4JS0huceCggL6+vpobm6mpaWF0aNHqzTDSMTA0D81NRWr1YrNZlPKUoBKkYhkotvtVudJUi3GtInZbCYcDquW09TUVPWwk9+ApAWysrKIRCJkZWWxdetWIpEIbW1tTJw4Eb/fr/LgmZmZqvglcoATJ06ko6NDaT/INTHS6eShYEwX9fb20tLSQk1NDbFYjOLiYpxOJ9nZ2Zx22mk0NjYqJoc8XIfDwB4Go/oQLK4GSiHyGnAq2fhodu1ZIo/Wfa7hUS7nY2Yyl3cA+PXOn/HBmEpSiQ/9hVeA06oBN7zybSqKNzKOrZzAO3zr7afwzrNyDn8H8mEm8Eo1cAZQpVZRc28lPAdcCbkX7UpYvY2w6vBaeOPfePGJ82GhiVhNKrWnz4AV9TCpBCYBm44cRoDZbGbx4sXMnq238NpsNtU66nK5VMEBUJ6fQIyjtKQaSftGPqukA+SHL8tJGFpSUqJYBIBqUZWbQwxuIBBQuVoRVe7s7MTn86muITE6krLo6+tTBRT5HqAeHHIDX3/99fzjH/8YcSpYRhgFUuTB4/F4KCgoULlRv193Tnp6egiHw3g8noRcptCipLAkBUZ5CNlsNvx+v2JuiMJURkYGVquV7OxsPB4Pdrud7u5u1WXl8XiUwLgI6WRmZpKTk0N9fT3bt2+nqKgIQF2T9vb2BAMv3XHS+ioPaumu2rFjB/F4HJvNhtfrZdKkSeTn57N79+6E38twGNZDaFTdYL8WAmBt9hKZ44b1FVBwYN/+hGksfvVp3Kc04L25GJbC++edpH94fwtHv/gJFV9dQ82JlXAzvHNylTJ0yxfMZv7Dq+DKaijZQrrWwxNXXMUnj0zjW089hfupCMs5HT6C+TNf5u0nqmFxiJIXanHgZ2u8HO4BmnthxdO02S/e225yG7fy4l3nQw7ESYNXlkPOfN37LQA2lXOkGNULLriAM844A4vFQk9PD4WFharKLx4h7PEe5YduNFjGUFqqxU6nk9zcXEpKShg1ahRms5n29nbC4bAqNnR3d2MymdQNLHQfMcLCEJA8YVFRUUIKoqenh8bGRrq6upTXZgz5JaSUyrWsLxwO093dTSAQoLu7m0gkwoYNGwaNChmpkOPJysrC7XYr4ZlAIEBXV1dCNTwtLU0ZuUAgoK6f3+8nFAqp8wTQ2dmpHmhFRUVYrVYikYjKd+bm5mK328nJyVEtr6CnDMxmsypYSnQQi8VwOp2UlpayceNGenp6GDVqFDabTVHmmpubycvLIy8vTxl+uVbygHS73bjdbtra2ujs7MTlctHS0qIKdGazWf12vniFqpnXMv6jtdQWzuCbWUt4aM4PYH03ZU0b9vvVHtJZ/KWnIQdsC0J476qGtOo97acL8+FqqHmlkpS/BOmbk8nva7/HDegdMg78MAfdQ47BWlM18Aprrq5O3NAuePtLXwJqsfo87N4xge7RZrKW9cBi4C4zsFXvtNoX6nS9gigWKJ/f35X1D1h45gGcqJGDOXPmqFAYUHxQMVyS9zJSn+SGCAaDCaGhcBt9Ph9NTU20trYqQY5wOIzP51MGFfYUlWSdRnpQenq62gejZyoygqAbl9zcXFJTUwkEAipnKIZDvDCr1YrdbldUH+n2kZB5x44dvP/++yM69DdW/EUFqrS0VFXYOzo6FHEf9P57m82mBGxEyV+8UangW61WTCYTPp9PcVBlm3l5eSqfCijPNT09nezsbMX4aG1tpaWlBa/XSygUoqioSLER0tLS8Hq92O12NRVAmAGSdxWDnZKSQjQaVRQ6ed3e3q5aWc1ms+rmam1tVWpocOAGdV+838+KQ2dUY/2eG/DQL3/A6ocmU/XiRrY7+rfqI2EESrw/p6p/NVX/PAb1c8frby5CLzZdic45jeif9xU06mLWA5FGf14TdLL/EDdJHPSuqjCRe9yYcjQ6rsvQU6ER4EVgoXnIryYg0kvNjyoZf/daKmr1QleNqQJeXA18sJ8vjwyIl2is0BvzooD6caemphKJROju7iYUCqm++qysLEUOF09RbgbxeI0eo7yWwpL8kxvUuE/iJcv3pBPLKBqSk5OD2Wyms7NzkFE0GmVjHlcq5tLBEwgEaG5uHvZix75gZFCkpqZSXFxMSUkJ+fn5qvU3FNI7FKXAJ9GHyPmJsldOTo7irQpRPxgMEovFVMuoRBFmsxm3261SBvKQKikpUcInvb29StpPCp2AypOK5ylNGhLqOxwOPB6P0loVGFXMhGESCoWor69XqaKMjAx8Ph/p6enY7Xa6urpUAXU4cOiM6vr72G5yw0+m6KH0TfDC7pMJY1OLuPDxAmfw85b/pq86UzeW9fDO96qg7mVgEqwcCyuq4YbX4IZTIfZLaL4Jmn8FD58OrIPl47mWBxI2/8bE4+h4waNer2I29/4Kmh/OomB3l95Y9QZoj4zCcWErgRwgUo2nWk8hVHauYI1pDiy9CS7ugN962Bt+of2UWxz3UHuPCVZWUjF7DbmahbZrquC3nxysM3pI8ZWvfIXi4mK6urqUMRPuqXEEhslkwuv1Ul9fj9frJTU1lZKSEgoLC3E6ncr42Ww2MjIycDqdZGZmEo/HCQaDeL1eZWAtFovyIOWGN5lM+P1+wuGw8nyj0ajKg0oIa5QNlHZWi8Wicr+i0Sn5NWODgZGlIGyAzMxMnE4nkUiEnTt3UlVVxXvvvTecl2S/EOZEUVERhYWFuN1uwuEw6enp+P3+BDpZWloawWBQtfRGIhGam5vV8TscjoQBjampqbhcLoqKimhpaVFULAnZ5eFmtVoZNWoUOTk5Ste2r6+PQCCgCmKSVpFrLd1XRh6z2WymrKwsYQ6ZcX6W/GbEeMtUAafTSUFBAbm5uYpuZWyJHg4c2kLVwsVwHopVNBQ1qnr8r2DrEihdDA8vgZsX939yen+3VSfMhpq0U+EsoOQm5vz7NVaYzoAPJ8Np01k9Y/Kg9brw4TLE7en0cO9UKHzGB8tAyzLpHuiH4P8wD54B00MaV71wH5f373DVxxt1dsAKDx8cP22vh/kVXuIr/pf4Gs9Tb9JAgxzaaXONhrTFELuPka4NID3XRiV+qRSLYZJQTLiGGRkZFBYWUlpaqniJ4nWmpKSQnZ2tikQ9PT1YrVY11E/0UcUjNvJHpfIu/9LT01XRQjxn2V5fX59an0jQ9fb2EggE1A0uDwOjMLZx/UIBk8JVMBhUebmRCGOff3p6OqNGjaKsrIxwOExjY6MKgyUU9nq9Ku9tNpsZNWoUxcXF7Nq1S3U59fb2qiKeGM309HRMJn0IoNPpJB6PK73caDSqioXCIhARlIKCAkXWl8ihtbWVeDxOdna26vMHVL7dbrerBhPhy8o+iNGX/yWakGUl1ytcZ3mwDxcOkVE1A3mMf2EtALWRGXTgwYMutdZKni6IAnr+0boY99YGvGmnDypkxUilNZrPmOs2sXPmJAjAtTzACtcLjK9aS217AVUNa1hdXLnPPRrFblZ/dTIhMph73oeY5mgEXk8l87p+svCbkLWsOeE7q2dMhhkHftRPsYi53E6NqRzqSg/8i8MMKQAZZ7oDKsQU4yWeTH5+vgqXpeNGjJ8sGwqFsNvtqk0yGo3icDiUBJzcNLJN8SwsFovqqpHOmmg0qpYVHVUjyTslJUWFnoBKNxibDMS4apqmuJeSazWKuQgTwKhBMBIhnmJGRga5ubkqfG5vb1ftqKIla7FYlKcpXqzD4SA3N5eurq6EqQzBYFB57tnZ2aSnp9PR0UEsFlNRQEtLC3a7HUCpjImXKg9Ll8sF7AnfpYCpaRoulwubzaaiIHngZmRkqHy8sYIPqIeERCmxWIz6+npCoRB+vx+73a5+X8bC1heIUnUKlMwG1pLWT3v68onvMPWtf/Md/sA14x/Vi04uwPcaudpEruUBFmivAhBlj0jt7q5RRFwP0XX/TTr9KWHn41yqPcsTc6/i/Hf+xmxWqWLV3mAjzAfadM7nb9hNjdyr3UYqcf7EJXSZPJRrW3mP4/gN36eUHdzNjz/lsbvBPp4Ua5A+zP3vHQ+M3NbH4uJivvzlL6vQD1CiGALJUWqapugx8uM2tpLKzSDehsfjURQfKQhJqA57jKn8kxs8EomonJwYaQlVZT+lg0s8YdlHo3SdMT8nnqiEn/KeeEGAenA4nU5GjRrFzp07D/HZ/2wwtvfa7XZlTPLy8lQ0IA87u92OpmkJqRev10taWhpWq1WJl8hDUc6NcHllPLjNZlMGurm5WXVbycPP2MYs3Ve9vb2KQtfe3q6ujfwm4vE40WhUqU5JHtc4vcD4+xDIwz4YDKp9S09PV4b/UBSgDhQp+1/ks+Bl+AvKoLp9DTAf1ptG83u+CwEo0LZT0bkGlp1K27GjuWWzbgwHck9zsjrg9pvgvMjAjQBwNs/BebDd9DeemvuthILX3pBKnGc5hwItyA9NeVx/2x9opIjrtXuYyzvcww1sf3cKb45deEDrS8RsxvvXMjHfMEa5dPanXMfhRWpqqgr5JOw3hlC9vb14vV68Xi/t7e20tbWp0Ms4WkNCcbPZTG5urhJDltyqpBekR11uZPEsjO2skk8VAxqNRtWgOaFAdXV1qXydeEf5+fmqU6enp0eNdZH8nRh+I3fVyEIQwyJKSSMJRkMhBkZmQslxiTBJamoqbW1t7Nq1SynuOxwOvF6vqqqLV97b20swGKSzs1MxAqLRKC0tLTQ3N6trKwUsyZnKpADx9CU9Ix6oeNGlpaVKCGXmzJlUVVUxZcoUsrOzycjIUN/r7OxUhSrZN3nICV/a5/Ph9Xrp6upSnrHP56O+vp6mpiaVwx9Oo3oIPNUMYLbuhfYjP7WF/FtbqHm4khrTcmAVzaZzyNZ8VJy7hhpXJUwKcXTaJ6zuncxyTgSWUnPNxXA1cBq4Czrwbi2GldD+1T1Fo2ms44fX3c69t1dDOxxt+oQ/apdQxer97ul9/IBv8He+fOvzNFLE/aafcv/Cn0I7/PX9M7h1x20cbbqPy7TNfJffJ3w3TirLOC/B6IawgR1qTR74uEQNLzwSIJxOI6kcSMhhStVXbhoJ+8QQi+coN5S8JwbTWFSSG0m2ASjPVyr7QhoXVau+vj5VSJN0hXBSbTabSgMIzUvCfNl3aQiQ5gSj5yMPFPGIJE840qFpGsFgUPXqS7pC8pppaWl0dnZit9sVKb+9vZ1oNKpyx0aRFKnyFxYWKrk+4RsbqXVyzcPhsPJg5Xci5zAajSr91aysLOVBb9u2TXFpo9Go+t2AzurIzs5WGgTy0Ovu7iYYDBIIBBStSgpx0oZrtVrp7OxMoFUZRXuMOJSpgUNgVJ1QOh9ryeDZTmOaNrHz1K/D6xuBWuhnAlScvAY0qDGN4Uf8mjePXQhU65SoSauBF/DeU03KxUH65kf4bvsSAGqeqOTUS19n25VTuefcWwAwLdH49qonWT17cPFqICayhdXaFL7F/7LeNIX3tZkcc+VaKAauhAuOegGsMI1l6jtVDWtgq5Wb5/2MX5vOhvnT96xw+Tpe1uZz+mPLdT2BF5+GSV/fI+IygmHkJIohlB+e0KWMRjUajap56eJ5ipcpLaFixCQfK16jdM5IKC+fwWBha5ngKXnSQCCgbryCggJcLpcKNaUXXWhDkp+VvK8YYaGDGalb8hDp7u6mp6dH8VhHKoxC3n6/n0AgkJATT09PJy8vj8zMTKXCJapTYqxSUlLUQ1CKVLAncsnOzlYPIGmqEOMrD0wAn8+nDJs8cI0tp/K/zWZT1yYYDKp8rxQdAeUJSyu06BHIw1b2VXK5RjUtMfIS3ezLqB7KXOshMKotUFdNxHUTMS1VpQAAbISoeG0NNdu+BM0mYICW6qMe3rxloS7Vd3E1LO2nUd3zNtywGs8Pc+lo9tBXUAtshcUhtt9wLpw7YBeOQWmc7A8/4D7WmvKp0SYz6co9+bPZDy+Hq+D+8HdUe2zV6o0wqxaOGc/tK++ANKh4a88x1GRUKg0DHdOgHFh/YPsyXGhqauKvf/0rZ555Jnl5eSokN9JxjD398qPt7u5Wn0voabPZVA5UbrBQKKRk5trb2xUFSAycceqqEaLab7VaVd5NCktut5u8vDyVthD+os/nU9J1TqdTLSOestFblZtO0gI9PT00NTUpD3mkFqlgj6cVi8Voa2tTBjQ9PZ1oNIqmaTgcDsXBbWhowOv1KgMnuW1ATWCQ9XZ2dtLb28uYMWNwu93E43Ha2trULKucnBx1/qTFVYRaJHUgD1opSIkQSkdHBzabDbvdrq6tUZhHxq9IOqK9vV01BMgobKfTqXR2Ozs71e/L5XIlcFQPxHAeCuN6CClVZmr/MIOUs4KJ+UXQpfXGDfGV0yLwsFXfq1OApe/CxadC2g/grmraflkN50GZ1sP2X54ON6N7szeh805ly+3dXMEf+T73M5m9jyu+ldt4+5enca/23QSDyjnwwdnz+OPfB6QR/gLUlTJ+zFrV2JCAGFzHA/pylxverxu5RHLQq+XLli3DYrFQVVVFcXGxymfC4NHHYoSM/fWSt5QQUEI2CduELbB161Y0TUvoYjKS+I2FKPGM5WYTrzkzM1PNSJKUQSQSIRgMKo9XxoFIakA8YAk1hfEgXozMS/J6vYqeM5x5uf1BjEFfX58aLe3xeMjPzycajdLY2KgKQ4DqfJLqvnizdrtdRQFCg+vr66OxsZFAIIDbresZ5+XlUVdXx+rVqxkzZgzjx49XaR5pJ+3r61M0OkB5ttJxJ9zVSCSC0+lUnrL81oTiJiNvJIqJxWL4/X4lP1hQoFOEIpGISg+JjsHOnTvp6OhQD+jhuIaH0KhWw5XQ92g1NZMqqXjyABX+b+8GOuDhUrihGnIicFe/yvzNO+DmGNvLp8DW/vlShDAdp8HKCNrdGayfPY7f8T0e+p8fcMnSOXoXFvDk3ecpA/sqC/jZj36jf3ZzNek36et/9uHTOXfVS3qzQgGU9o9XrVq9UTeU93STcoPufacNJeayBLb/aIrOUvhJ/3svAtxxgOds+KBpGv/6179oa2ujqKiIefPmMWnSJGUgxcuTsF2Mm9EIRiIR/H4/XV1d+Hw+FZb29vZit9vVbCSZkin8VoHcjEJ/AhKEWKS663Q6ycrKoq+vj7a2NpUjlJvWOIZDimPSuSOG2WazqeMWj1R0VYUYv3t34tDH4cbAUFaKQrt371b57ZkzZ6oRKPX19cpDFw0G2CPenZKSojxO6ZmXcxMOh6mvr1dhvzQTxOPxhImobrdbrScQCKihfxKmp6am0tHRQSQSUR6xqFK53W4yMjKUXkAgEMDn89HW1kYwGFTDBiWdJDlZ2NNcIsfn9XpV3l3SGzA8RtWkHaD/azJVf8ZNONnjegKE4fYquLkFqIMXZ6spqlEsbP/+FLh/NSWaEwd+akzTgBaYVdJPwTKs2sWedtQPV8PrVWh/6z+J44Ev9e97r8bXFjzF86YL0dtSe9EnoJ6BPgCwBcgHNoJ9MgTWUal18wjfBqAqdyO0r4Dr5zD+N2uHNqgG1JxfCcteBk5H5mN9Wmha9af+zkB8lh+U5LdOOOEEjj/+eNxutyoKCT2nsLCQzMzMhHykFD5aWlrYtWsXO3fuJBQKJcygqq+vx+/3U1JSwtixYznmmGOYNWtWgohKOBxWeTwx5JJOaGtrY/fu3VitVtWL3tbWBugkckkDeDweJk6cqFID0udut9sTCmaSswsEAkQiETZt2sTrr79OW1sb27dvV9SiA8XBCiXdbrcqDg0Fo1cvfFRpkKisrKSgoIDe3l527dpFamqqKgbl5OQoyT5Rn5IqvhivrKwsxS1et26dUo+SwpDFYlEMgYkTJzJu3DhcLhdZWVmqTVnkGSUF0NTUpB6+Mn2gr6+P/Px8xowZg8Ohc9abm5tpaGhg165daJrG2LFjKS8vV4ZSIiHRTPV6vSqiCIVCfPjhh3R0dLBjxw6VAtnbOZTIS0R1DiYOg/RfJXC83kMfQS9S+UAXPO3Vyf/98OPQP1tcRf035d3lsHD+noWGUrkqAOZXwXlwRudfeeHeC/Q6WG3/5z/t5fmfXqhX45eZYb0ZVi6GZg1ygGP00Rp8PBkWQ8rV43iEo/as3wVlbdlYDDngmt9V6tNch8KyEEw6vX+e4ac3qMMJUYAKBoPU1taSm5tLcXGxqqyK1Juxa0kq7rFYjKamJpqammhpacFkMqlOGaNhy8jIoLGxkS1btjBhwgQ1AVU4kZJKEO9Sun2kzVKI5FLQGD16tOolNxa6HA6H8lKlOUBuzJ6eHkXFEcUs6fqRB8JIhzF3KJMR8vLy1EgT6YBKSUlRbAiR75PrJQ89CeGl0NPW1obX6yUcDquUgaROpLNu165dqgPOKGwtdKdwOKweoNu2bcNqtTJmzBisVisbNmxg165dasCgPCQkvWQUhIlGo3R0dChPORQKYTabFUe1srISs9lMV1cXbW1tw0r8h0NuVM2weD4s6YAX69D7Qqdh/kk3vfeEgeWwqJTQ123YCNHmGA0BmXbaC5wBBfMPbFNWIA1eNI3GdJoGBdD1aDrO7/Wi9aRz+50/5BbT9UADsApuvpaf/uJW7jQVwovl/SupY94vRjGbVYnr9sF20wR42MyY7/SP0766F90LvQjsAwRd7LYEStlIh8lk4uSTT+akk05SnS1+v195P4WFhcowiqKQEPObm5tpbW1VIV9TU5Nq/XQ6nTgcDjIzM/H5fJhMJgoLCykrKyMYDBIOh1m5ciWZmZnk5eVRUFCgOK1Cj2psbFRE9S996UtUVFTQ2NioRI5dLhc5OTmqYCEFq66uLqZPn86oUaPUjS9jlKULR/6XXngJM42c2ZEGo0qV8GkLCgrIzs6muLiYMWPGqPSFCJ4I7UqMkjAqhOUgTICsrCw6OztVw4VRocxY0BMGRzgcZvfu3Sp1IAplZrNZjTapr6/HZrORl5dHQ0OD8sBdLpeSW4zFYjgcDkXNEuaBhPhms5lQKEQgoHtgEjWJ5ODWrVuZMWMG48aNo7lZ74qU/R6Iw2FoDw2lirPRw+kwKXcFGfV4G5BJlHSan7ARjwXh4/kwczl6GP4V/asuYNFNlDxSS/2F4+Evey8yDUIaetV/02xYAQQ28tHjX2IeH8C9cPPJ93LL5ffAo17gIrj9V7zzi7norV2S1zMTJ3XvhP8rX2PnlflUaMB8Myy/FTAleNsKK3vRJ6peCjxx4McxDCgrK+O6665LaC2UG1coMcZhcaD/aF0uF5mZmRQVFdHa2qr6sUOhEB0dHSq/aeQRymyk1NRUGhsbqampITU1laKiIjRNY9SoUdjtdkXdCoVCSi5OtAgkdJe2SyMPVV6LaHVraytlZWXY7Xa1vHgxMupDaDxtbW10dHQwYcIEcnJyWLVqlSK4DzcGhrFybSwWC0cddZQKvXNzc1UP/YYNG1S3lXSpRSIRJS7d2dlJeno6JSUlSsjE4/Gwc+dOFVUACUwJIyNE0zQCgYBqYxW2hdPpJBgMEgqFiEaj7Ny5kzFjxmCz2dixY4cy1h6PzjeXh6PdbsfpdOLz+dS4cRHTlrRCT0+P6hCTVtq6ujrq6+uZMmUKTU1NbNiwQelPDMeD8RAY1THw3FiyTmumy/owfQ9XY7tVD6VC2GDxr+i74cY91fGpPyAVXWO1Yvee3Cp/eQi4CppXoIujHiCOAZZ2cK62hnlvG2T33gAt1cRS7VwuMV0G/JgVJiDnVP07AOthxS2w6vrZfMPzf3u+64Kyti1sf+bUfnrUmgQq1VDY0VVKxNUNU8fC+muABw/8GA4zhEwvdBxpNZQikRSqACXWIaG9iB5L7tVutyuNS7/fT2trq6JeCX1G8qcWi4VJkyaRk5NDSUmJGkAnhQYxsm63m46ODmpqatixYwcbN27E7/djNpvJy8tjypQpyngIs6CiogKLxcLOnTsTpoJKaNzT06MMg7FaXVhYSCAQYOzYsUQiEZYvXz4s12RfkAeL5CkdDoc6PinoTZkyRdGYRNg7Go3S1NSk9FZFYFy81R07diiyfiQSUZQsKTQJoV/4ww6Hg7a2NjXGRQpGMr5auqAsFgubN2+mtLQUl8ulGBryoOju7lYsA9G6lXyoz+dT0oOASmHIbKvOzk5yc3MJBAL09fVRWVlJXV1dwgj1w41DYFTDsAy6zipAH9E8BOrozzeWw/p1bP/VdPhJN+CE06Ds5Q3A0XA9cP/x8GK/YZ1p2GtjbjUANAObVjFD01g78xiWXXkJpMH/Pnwhl5n6DeR8YC7AanTv0Q1Tz9SVqED3lJdB7+21zAu8zWuZp5JOD5TD9oopVNSsGcyJBbZ2lNMb0YnTVnuIsVl1/Z+UQykQ8PTPzBp5MJlMnHPOOSr3aOQ/ikdh7M83Lgd7vFqh9ABK6q+jo0ORywEl2WYymdTUz/LycpxOJ263O6GjyliVFmMt/f/S4y7Fsvr6eqVOL/uTlpZGVlYWY8aMUcUuozGSbRlbbSWEzc3NHdGUKjk+OS+AylWDTsaXh4ZoxGZkZGCxWJRIuHjzgUBAhdozZ86ktbWVYDBIfn4+wWCQrKwsiouL2bp1qxJfkcKOzBMTwyy5W3lI5uXlsXnzZnbt2kUsFmP79u2qcUD2TdgDgHqwg/5bkeMRXQHRc5BUk/yuhJMM4Pf7FVXui5NTvfJi3YCcBRScnvBR269GAzFYVg3LgJJqnWtaD1/T/snz2xbBQhMWolRoJmreAGImaJ4Dy5bDx8vRw+k1wLkwFd0QrlgB1XO46tZ3+f2VP+S2h3/MYn5PAAfPmI7XtzEVVn9d77J6lQX87JbfwO3r9P0sZ8+MvmbgtBcI2GGzNpFpfMILL5/MGaZH9dHUJVBxo6Fg9WolnLYKbp4NMYjcZQGtjsjt7v6VjXzk5+djMpmUCIpRAhBIIGVL/iwajaoZRFJFzc3NVVSngoICNVJFlm1ra6O7uxun08nUqVOZOnUqTqdTeYviJUv1H/aIWIsYssfj4fjjj1dGxOv10tTUpG50yf36fD5FfDcWsORvEWwxTu2UrqPCwkJyc3MV7WokQqhPY8aMUUZHOprEQw0Gg+q8Sk5UeJ3GkF46oux2O+PGjaOtrU092IziKKtXr1bXOSMjA4fDwZgxY7Db7bjdbgKBgFLDstlsFBUVqbZV0ckV8ZXMzEyAhAeDcVx2OBwmNTUVu92ewDGWCQbCW5bfpnHktqQoYDAN7XDg4BvVmP7vpL+/yJumk0hpNjwtfgI8ehPcBdwAVMPp33mW27kZgOfLL1T98lEsujG8Ad1jtc6HyDRY6IErx8LtwEp0T/CeObo+6pX6d6vH/oqjd+hjri/VXuHaAaH3Al5lwS8m85tffJ+PifI/XMdJV76vf5gFz2qnc+4lL9HDJQDk0AF/GQuLqoFT4EbDzfYTKNBy+Sf9soJ39TcL3LMDSvffKjsSYNQSlbyZeKjGooh8blRihz0trtI1JZ6L0+lUeTApUEh3TF5enuIZSpgonqRI/RkHAIrWgEz4zMrKwmazkZ+fz8SJE2lsbKS2tpZgMKgq+263OyFMNqrI+/1+gsEgAFlZWaqfXbrDJK0xUmFsWhDDKCNspMsJUMZUmh2kwi65UHmQigdYUFBATk5OQrXf5/ORk5OjNFhljLfVaiUnJ4exY8dSWFhIe3s7TU1NisXR19eH0+lkypQp5OXl0d7errRds7KyKCwsVMI18mB2OBwqhdTZ2akeehJRCE1Lcvdut5vu7m71IB84sVfOweE0rAffqD76q/4/poDLxsT8NdS8Udnf/x7ia5c9z/OXT4EPp0PzRkWwV7Br1KyuhFmrdYN53nJYNF8P8V/MgFnoNCgXwC+hbhpX/3CTMqgAlMBDXLXfXf0+v+EH3MfJpj+zXjuFKVduhy4458qXeebJr3Bu9kvc2/ld5rOcC7/+vzx1dTW0r6Lmn5W4T2vQV7IeruVBPmYmf+fsPSt3jYW6HXpOdYRDwij5X8JjIeanpKRgt9uVeIrchJIGGBhqGW8OodZIKFlQUKDU2YXqJGwB4Y/KfkiHjeT+hMOamZlJSUmJKpylpaXhcrlwOByKChUOh1VbpggXC5VI1K16e3tVp5fZbFb942KURyqtSs633++no6ODcePGUVhYqI7RKNMo186YLsjKykqQX8zLy6OvTx/RXV9fr9ga8gAzm83s3r2bnp4eKioqSEtLY+zYsWRlZamopa+vT0UPcp5lXHhOTo5qMW1sbKS1tVUdh+RevV4v3d3djBkzRk1alZHWVqtVjcwGFFtAmBxOp1MZ3eEK+Y04NDlVgW81NXOrYMVGWDkZNtm4iTvwa3fy5qrpLHxkg1LZB3TPs7wG8OOOlfBa6mSqsjfqSlU3Q4nWsKchYIUZXrkJcuDBK7/2mff2Pn7AFdofmWr6iHe0E5lzpR7apxIH30Ye5jvMZzk3cA83tN3DUS3/pm8heM8r1lcwCyxEuazi/3SO7V1Q8+dKPefrO7ik4kMFI/lZuKED50JlZGQoQyqG1aiOb+xaktbStLQ0daO5XC51Awm9SsJL45A5WZeEdSK8IQZYFJkANV9KcnQyTkSaEdrb25XnLK2YPp+Prq4uRQsy6gKIARcyvRRURiIkZSK99EVFRWRmZhIMBtU/8fo1TVNtu9JzL/oG8Xhche5Wq5X6+nqVB5cOKTGIzc3NZGRkqPy3hNuSKzdCmBsSrktOVx7CnZ2ditBvMpkUtcrpdJKTkzNII1e8XklbyINfcq0jSVHsEBjVCuAM3jTZ+KF2O6m8iAsfC3hVLXE3P4bZg8Wf35ldxQvamaQS52z+vueDlcDyfxBlJvXXjAe6mXP8clbUz+X/ihcleKnTHv4ACj/dHj/Ct/mW9r/MNa2GUyDrxWZ8VxfCzMnUOuBx/2K+yRIA/p1/FJv/PYGP+9u1ZvEhF1S8ABHIbdpFDu3UzK3U88qzRn74r2kazz//PMcee6zydIyamAKhOHV1dSnFITGIMtJCfuxyQzidTlWljcfjqsNJcpoyjsNorMXTEv1UMQ5GyUCbzaYaDaRKLV1Wubm5hMNhmpqalOciIa5wWKUxQG548Xi2bt1KY2MjbreboqKiEZtTlesD+gPR4/FQUlKC2+1OaBGWwp2cQzl3ubm5uFwu1U2WlpZGU1OTemD19vYyevToBFZGXl6eyts6HA5Fp3I6napfX1qaRXQHUOdccrMibC3XQ+acSbQSDodxu91kZ2erh7LkTqUhQFIaMpUgLS1NUfKMLc5fnEIVafCcDc6Cr/P0INHpfcFGmK/z9KD3x/9wLWk/LAHaads6mm9rjxMnlRV1pzKrWM9hvvjwSbzH8aw/4ygebLp80DqGwhX8kbq4Hp5PTN3Mam0ym5nAN456jp/9+xa0YhPf999BC/kJ35vIFiayZc8bdVARHkCximhQMDKrxwMh46IlhyhFKuOP0qg4JR6peBmSp5SbWGTkRNZNquviAUuOVgbByXaMaQQxzDJnSrwtm82G2+1WxRa/36++53A4lBi2z+dTxQ05JmO1WGhhsj2hAwWDQYqLi7Hb7Qm6BCMJYjzkQWexWNSY5tbW1oSHonQfyQNJxp6IZy+8XkD15Eu7cElJiZq2Kt6vFK0sFgvZ2dkq1y7XSLilUmRKSUmhu7ubxsZGLBaLEtJxuVyEQiElXSgygPJbkvy2dOSJ/KN4pqmpqbjdbux2O21tbSpnbIw4jCJAhzOvemg6qvojuSjpzN25Eq43U/L3Wv7G+QmLpXMAXDIf1F4zg/EPrqV28wx4ZTUt5PH82RfCJHj6+K9zy7R7wNRCmdZOxQtrmMjm/a5WH9Ln5vfaD+nBwvWmW6g6ayM3//1ncDHcacrkIq2MaXzC0QM7rAYi0kvNTyupuLPfsP4WmPkBoDMCqFux/+McRkjhxmazoWmaklKT8F+8A8nPSZFASPxSABGvU3Jl4s0Yp6Eax1WL12o03kadTvFQxYjbbDZycnKUsr1Qa6RlVtoWjfssXrJsQ3KJRhK7FNiysrKwWCwUFhYqZaSRAKMxGCioIp6geKLhcFid43A4rAyWSOfJw0woc3IerFYrpaWlCXqyYoSN3VgyEtvj8ajzaFS9EraF8UEJOs1Own2r1YrH41Gk/u7ubvx+v2IgyMNPUklGvQZJOcl2rVarKkhKOkQexANxuDzXQ2BUP9EnqDKduaafAetgWRX1pmKONUrhW2F1eP/h8f3ad7je8Qdqn5vRb6Cmcza/5vlXLqTs7xvYzSiIwDPaNwcXvfaB+sfGs00rpOxKnfZ03cN/xLW4iQ5yWH7dbDqu8xDCxswDkO//sXYHv664Fe7UX1fMWEMN/TnXVzYCrx/wfg0H/H4/W7ZsUQUL0cM0Gh5jWCcqRj6fT3XrSL4MUMUfv9+v8pJGmUC5MYx8WCmaSFgo3xPvWVoXhToj4aRQf0TwQ9Zh7PcXwy3GXrwg+V+MgvTJZ2Vl8eabb/LOO+8cvotwgJDjMPKEGxsbyc3NZdSoUTidTtrb2wkGg6rY5vf7icfjal6YhNriUUoE4XQ6mThxotpWZmYmXV1dNDQ0KMK91WolNzeXqVOnqqm6kj+XETkiIi0FrGAwqDxbt9ut0jcyBicSieD1ejGZTNhstgQurFF2UlJDElVJHlW8Y/HWJd0h399XOuBQeK+HqPf/VPjYCTP/DNXnUnHumkGi0TWmYn7Er/c7WG8u77Dav8f4/pxbWPyHp8GqF4gAyGG/BnU3ozjr+T15Xa6HsjMMPNKPIO87LQA48ONg/17K65zMjc8/2N/IsAc1T1cCr6GTX0d+scrr9bJ69WqOPfbYQZ6jFASEO2jMbYrREqqTkPXlxpXKv6ZpKoyDPer+4oUaqUzieQmtStpKRRfVWDwTT0tCULkB5eYz5ofF0zayDIzUsWAwqOY3RSIRHnvssYTi2XBiX6GrHPPmzZsxm8243W6lGCa0tEgkQmNjIwUFBYwePVrRp4xzyCRMF91Veb19+3Z27dqlxpHb7Xbl/QpLoKOjQ3mpEo0EAgFl4EStrKioSDEsjFNQRblKOuRcLpcqZIqco7FYKTO5cnJy1G+pu7ub1tZWGhsblWiM8fzs7dwdQUb1zzCzX+qvHRqjRTgsAwzVo/m8+dOFhO68Fds+DM9uRuHCx/wnVjH10n+z/ptHwZL7gB9Qc2IlNcunAfU8eeklXMKT6ns+XHSwZ5bVDkphOfy/38zVvU8/8HN05b+pYPqHBqYQE7UttJLH6c8vh0fh/70wV43WNsKPgxtND+iKhtWQsji458OlAHX9NLKRb1RBl12THnv5AUv4LV6d8B+FKyjhu1TvxRBKsUq8R7mpiouLleE1TgaQokN6eroiqwMqvSD5OaFGSXgosnaSg5P2RgmBYbDAthh9QKlhSZgsfF15EIx0aJquYbtx40aKiopIT0/nuOOOIzs7Wz2oZFif9Md7PB6ysrKUdoIxxG9sbKSzs5OCggKli9rY2EhTUxN9fX2MGjUKj8ejohBp1hC+q9/vV3Qoo3C4/H56enpoaWlRCmPSapySkkJdXZ0ycqJBIddXxHckl+tyuRR7QH6H9fX11NTU0N7ePmiCxOHGITKqLVAyHnzV8NvX6PotdM0/NaFf3nqel4irgzvuvEmR/4fCWT96FRYD1bB+6VG6GtX8H8Dyl2H5KnBVc3TntkHFpJM3v6c3DywEFsOl2kNQD182PYV2zyglC3jLwz/l9tw79DzoeTZevOJ8Nj4yGezAi/DlP7/D6osGpyl6SIc0E+NfG6yvOv6FtdSaTu+P+kd26C949913OfrooznxxBOVRyrFGmOhw9jWKflP8QrD4TAdHR2KyC/hIqCoPZKXFW9UIF5pPB5XmgJCxRGOpbQfisGX70krq9B7pEBjDBelK8tutytjLV6O5GaLioqIx+Mj4sbcG4bKqa5du5auri7S0tIIhUJqhHhGRgbd3d2kpKTQ1tamRpCI6IpcEznvkUiEnTt3KoWyYDDIzp071VywlpYWRo8ercZUyzXo7e1VxP5wOKzOsRS9MjMzVY5dhvbJbwZQ0wFkDE55ua4aJ1zpSCRCS0sLZrNZ8ZHNZjNer1cVq2KxmJrFNRxdVEYcuslm9evgYgCzLloyAGOz6uDy8bz8pXMIkbH39bQDU9fpfwsVzQ5cfDpwDbwOH4yaN/R3rXDSpS9CXS/lbOODv02DhXo/6m8fvgzTqRq3H9uvyv86cJ5G6yMOtv1tKt8++X90vdSLQ7wkKlpDII04NcdWUpO7519t7gz00P8fez+uEYi6ujrlsYZCIVV8EuERCSeFpmQk/4tRNHYiyU0jRlIMnvzgjYZLvEmz2UxmZiaZmZlKCk5YBOIFixcmDANJDUg/uWxfPGEjPczYvCByciLaYbFYyM/P5/nnnz/owsUHA0ZDIVGEMVIQj1PmeInsosfjUVoJUvm32Wyqqi8COgUFBWpGWSgUYvv27UpKz2QysWXLFjZu3Kh+HwAul4u8vDwlBSj6CbINoawFAgHa2tpobm5WjRfyO0pNTVUesBh+KSAKr1Y84dTUVILBoMqj7t69G7vdTnl5ueJS7yusN/5eDxUOoZ7qs/Dwy0AY2ucPuUTJI7XUm8bTgwUbYV7gDF2omj10rDse/z4/W3IfLIFj572pvvv+6pNgqUf3RJfBd/md+syPg0snPkTRk03caZoCmLnllHu4xXqP3o4fheXM1/mt7S3Ao3z7ETujHtnNexzHPeffwIrnT6XsaxvYfsoUHuBavsJLCfueShxivdScUQkrlwNuYBXkXKF3e7U/DdQcjBN52PDPf/6TmpoaTjzxRCZPnqxCbrlpJfwyTuMUcQ/hDgpVR7w/Y0dPY2MjaWlpKhcLid1bklaQbRrFTyS3CntGrEhqQoyotKiK9yqNAJICEMaCeHher1fNkBeDffXVV4/YTqq9IRaL0dDQgNVqZcaMGXg8HpxOpwqxNU0jOztb0ZLa29vp7Oykvr6eUChEWVkZBQUF5OfnK4J9d3c3Y8eOpaGhgdTUVAoLCwmHwwm8Y8mLS3U+HA6zc+dOLBaL6poTWpUxzy1Rj+S3ZS5YQUEBdXV1bN++nXHjxinDCbo+RUdHB9nZ2RQWFtLW1kZ+fj52u513332X7u7uBJbHcOIQi1TL0766/18iHPghDd5iPre/fQfMX60r+C9fxaORy3nTcpLep69NGbzqKvY6MXX+P1fBwh3w6FhYAvde+l1+sPshXhs1h1OvX8HtP/shy96+BJZdwlfmPcPLpl7+ePp1cD1ULOhPUbTD9p9OgauhzbSLi7WlLOViNaIa0I3yw9XAbCq0GDW3XAG3Pw3tp6OPaDmy0NPTw6ZNm+jt7aWkpCShbx5QlXoxcBJGw56JnBK2G3OfwjOU4XLSFioerAhpOJ1OdROK4RPjKykIMeDSGy5C2pqm0dKin3PJ4YnBl8F/mqYpOpeEkpKLlYaGb33rW7z00kts3rx/Wt7hxlBhrRRxgsEgW7Zs4e2331baC/n5+fh8PlJSUhR/NxQKqYGMwsuVWVDSKSX0pt7eXsaNG6dUyMTYClMjGo3i9XrV9FW5Zsa0jkgFyvoEEnlIfra3txeXy8WoUaNoaWlRdCvpqpLrLL+73Nxc/H4/brebsrIynn32WfUAGU6FKjgs41QAiuE06MRFtmHIVAgbxNDD6+uBFVVUHL+Gmjdm0zWVPeNQPi0WApvGQjMsnPc3/sVc3hp1ItfyAGTCh1SxYN5zRLHolCxOg1c0SDPBgv51/ARoX6cby9fnUHMshN7PgBIrvNK/zFnAWdV6OoI1jP/FWmqnfl3/bvO1EOlgJOuo7g3btm3jmWeeYdKkSWriJqC4ioDS3TSmBoQJIF6rQLiGsIfWImkFSRfIkD7hPopRFrqUrFc8HOE2yg0OehODiLQYUwXiyRpbaDVNU2kDqTCXl5dz6qmnUl9fP+KM6kBjYSzAiZJXV1cXy5cvp7m5mZ6eHr7yla/g8XhUW3B+fr4aMy3MBokSvF6vynsKP1ceSCLaIuImkk6ROVj19fUq7y3dV4FAgPb2dhWdlJeXk52draYKSIEyLy8Pi8VCe3s7ZrOZ8ePHq1SBpDKE9ypMBpEFDIfDrFq1ipkzZzJt2jS8Xu+I4BYfJqPaAD9ZTfNPvDS/fioVJ+ve4M6rJkEOrHl6DsxCN6gNk+GUesDNFfyR27iVIpo+5fY0OM0EdQ/w4v3X6rlYH7w49Xx+/8vFPH/ihfp0gNg/qNCiYLVBpBuWO6n5Q6W+inKgZDqwhpKTa6k/xc2pXa9BmsGbBWrWVipKVe2rM2DR00ApTJ0N6xP7oY8kbN++nRdffJHKykpmzJiRQAaHRGK2vBZPSDxayV2J1yjLCsQDli4r6TeXXKHwHsVgeL1eIpGIaleUEdbSCWT0qo0cVIFwb6XqbSTLi9ctLa1HEgbS3DZs2EA4HFbGJj09nQ8//FCNrPb7/TgcDiZOnMj27dtVW2t7e7tqzxU5wY6ODmVMJc8ueW6ZlNva2ordbic/P19dLyCB1bFt2zamT59OeXk5W7duJRAIYLFYlMp/PB5XbALQaX51dXXKY5Wpq5ICEBpXWVlZQt53ICXQiCO7o2pIvKD/d0qMmvLTcW9q0Mn8OcCijfrQPYB7rMATcOVNrDEdzxkL3yD3hV28wmkHvqn1Jpharf99ff//5EP5VXz3hiV6JmJ5NTBN/2gpsNKpj6a+sn/56mrMV3dTM75S90R/C/FYN8Q69Peeg4opa3RmwscPUXPzVbD1NbB+XadZtcNIH6OyL/h8Ph5//HHef/99Lr30UqZOnaqUkIxCwjKyWvJoxg4cY7gqyxm5pBLayfuSAwyHw7S1tRGPx9W0zrS0NLq6ugiFQhQWFiZ0XknVWDxnyfWJgRWPVRoLAoGAmioq69Q0jdbWVj788EM+/HBvEx1HDgamAiT3KJ7krl27eOqpp4hEIsyZM4fCwkI1T0pagLOzsykpKUmY3dXX10dxcTEulwtN09QAQGkUEFEcaSnNy8ujpKREqVLJZ9IMYsyXt7e3U1xcTGlpqTKEQquSXLekiIQaJ22pGRkZ2O12mpqaiMfjFBQUqByxzEaTJoehuqkOJw6jURWsgq2r8LX/SH+56T7M7ZdT7lmja6hu0ner4KHtxB9Ko+3d0bSdOprG1wqVx/oOc/HtY7LeG1OO4+Tn3oO/oI9tWYyu7h8Dtq6Alf3jWZ47F1ijNyecC+1359C2uhpmVQPQW+eErasBP8Tm07vSyYPa5Vzz/KP6WBVJ9aZdBVurgR/DpP73jgx96v1i06ZNPPHEE1xxxRXk5eWp3KYUr0ToQkJEESGR0B32eI1paWnKqMrf0lIpxSXJyXq9XjZs2EB7ezvjxo2jqKhItVhKXk0MsMymz8rKUtxNI+TmFr2A1tZW5Z3K+mSu1ieffML27dsP+3keCgMN51CvjTAa1lAoxKuvvkpDQwMul4tx48bR0NBAdnY2fX36PC4RoxFh6b6+PgKBAE1NTSpKkHSASOzJNWhra1PjcAoKCti9ezc7duygubmZpqYmJkyYoKhU8XhcFa58Pp/6HYnwjdfrxel0JujA2mw21RgQCoXU/qSnp+P1esnKyqKoqEgNnhSPW3K7wxltDINR1dF3c6b6u8jTCMD2hnHwSjWkVWNhEzZ8cDy0vT6KH3Aff+FCAK7P+IOu+j8UPlzHg1oH535tKc+svxhOWQcUAw9CXSXQDff3c0dLE7+aQzuWqij1x1Tr3ubNAC9ATrU+JmvWOq5Z9ijcD1yNnqr4uAPw9q/h1/DxbGg+HZof+DynZ0ShqamJjz76iFGjRjFq1ChFyhaPwuiBitcqA/WEriPSb7BnJpaE7JFIREkCOhwOLBYLpaWlCRMDANXf3t3drVIPfr+fpqYmpRhvNNqwR6RZjHo0GlXk89GjR6u0A+izkv71r38Nz0k+CJAcq2glRKNRtmzZwu9+9ztuvPFGCgoK8Hq9lJaWYrVa2bVrFy6XK2F6reRCMzIyyM/PR9M0cnNzaWpqUuG5dDZZrVaCwSBTpkzB7Xar4l9LSwu1tbWMHj2anp4epZjlcrmIx+N0dnYqozl69Ggl1CKepoxHkdyr/DPyVOvr61UH3scff0xzc3MC93U4YdIOsExmMlUf5E27Yc61cDkUXLodG2F6SKf+6fHYF7YxKnO3WrLml5VwM7ygnYwLH3NzVzO+bTDpHqBmWqU+OuWpycRJ5ef8N3FSedk0DRgPj6LnU5dUA9VUaGuIkUqtaQbcDhU36flS/b1GyDkdd3MD+akt+rrXL4e/zNeLUXU72BPizwc6gJ2AA30U9meHplV/ru/Dwc0hZWVlcckll3DCCSdQUFCgPBcp9kgnkjQHBAIBVRXOyspSo63F2NlsNuLxuPKShLtolBWUkFQKWJL3lGpwamqqGggoxH7p3TfyWoWtIHPhQ6EQY8eOVV6YFNgeeeSRz2VUD1bF2e12q6kE++JbDvW3vJbKuoh0z507l9LSUkpLSykqKsJisdDS0kI4HMbhcCgxGgm5pfGio6OD/Hy9sUaubygUoq2tjbS0NLKzs6msrFSarMFgkLa2Nnbt2qXGnAh3dNq0aWoyr4T8ookKqIYC0SIQgRSTyaTmaElzSXt7O/X19epv6eqSB/v+zplcK+G9HkwMm6cKXlixGlbk07z4Obj6B1Q8uIaKrw+eUjr+prXU3jWDMDbOePWN/nzl0Cj7ZAPbM/S4PJU4t3ErAGdoR/PdLy2By9fB69NhyfHAM0C/Mv+AM5FGnDHaWFLZoDQGyj7ZQJwCbKyhZlElzBkLK6qBl4Hlhm8fuQWqvaGrq4s//elPtLS0UF5ezujRo6mqqlJz2cX7FDaAFIXkb2O1WTxUqe7KDSbpBJnvLl6mULKkwUCaAWSKa25urip0iG6rKE9JjrGzs5Ndu3ZRWlqq+td37NhBV1cXd9xxh/KKRxIO9KFoNOYDWQHSTfXSSy+RnZ3N/PnzmT9/PuPHj1eqVCJWLbqqTqdT9ebv2rULp9PJhAkTFJVNRuTI+e7r6yM7O1udb+nQ2r59O36/n/z8fDVdNz8/P0F/V9gckl+Xh6poEwjNKzs7G7PZTFNTEy0tLTQ1NbFz504V8ofDYfUwGRj+7+08ynk62Dh0HVUHhBfQPboz+vvkh0Ya8T1GLwKsYEgvFfpFViL1XMEfE96fzQes/mgyzJmuF6bm7OnySiNORe8aKm5agx8HNUdVUvN2JTZCe0Rb+te984xJ1HypXzDFSn+X15hPfeRHIrq7u/nb3/7GypUraWhoUP37kPgDlcKQFCkkDweo96VoZKRpiWc5MGcrkC4uCfON1KmBOgTisfT29tLV1UVHRweapikKTzgc5uOPP+ZnP/uZqmJ/0SAFQelm6+zsZMuWLUpdyuPx4PF41DUxUpYcDkdCEUrErSU0LyoqwuVyJejlChfWbDaTn59Pbm6uKlhlZWWprihZPiMjg5aWFiW8Itqu8iAUvqvxdXNzM7W1tWzdulUZVKFnye9guDGMnqrgZSAfHh1PzaOVUK9b18RRzzr+zDfgLL1wVIMbfjudiu8N9my5q4Q195bADwd/9OA7l3ON6ZfAOqAS6GR3cBQBexvQin5KHoAl11IzPxtOG6uzAqauQw/rl0LOxeA6FV5f2v+dL55nui988MEH6iaZPHkyZWVlikRvsVgUvUdU26VyL8UIyWNKFw6gDCWg8q1GMQ7p1ZcbTwQ1urq6qKurU96wcDDlhuvs7FTdXQ6HQ/Wy//rXv2b37t37OswjEkYvTR5IUrmPxWJs2rRJpUHOOeccsrOzCQQCpKamkp+fz65du5RnGI/rY8YBGhsbKSkpITMzE6/Xq/RQu7q6CIfDahyLXLt4PE5JSQn19fWqo0rGkzudTlpbW+np6cHtdlNfX58wdlomBNTX19PZ2Uk4HKalpYVIJMK2bdvw+XyqwCkPjn15poe7cDUCjCro3UfV+p8l5cBsIhQP6pjy44CFVfBiB+DZexrgJzuYqg394XG8x7naazxz4cVUPKUb5EBOLtAGjIFZY6F9OizZoX/hlX/AK58AN+lNBS++Au3Vn/1QvwAIBoM899xzAMyaNYvZs2czbtw4TjzxRFUg6evrUwIoEr4Hg0FlWCVslNBPwnnxMqUJQP4ZSe7RaJTt27ezefNmlWPLzs4mGo2yY8eOhOmwQsdpaGjAZrPx0ksv8dZbbw3j2Tv02BtLwGQyEQ6HaWho4Pnnn8fj8XDaaacpJkR2dja5ubmKjypjanw+H42NjerBKekeyXMKTU1ocqI7AHqeVAyuRA2iNNXc3Ky2LcYb9IF/Mh5l165deL1eduzYoQY/GptM5Dj3ZzQPp2EdIUbViDAUjIfmZ6j53blDe6Kg73l1LS035+NJbad27gxdAKUfT/BVXUmKvUwY+Msqau6ZAcutEPkHzDlT56MGGKDU3w30AivgRdhT6U8CYP369eTn56t+fTFo0lFlTAn09PQor0kMqtFzNXZhSf50YBOBNAhIm2pHRwehUEhNI2hpaVFeqajTB4PBI7qq/3lgTJ8YqWxCuRJx65aWFoqKilRffSAQUB6mFIMAJk2apFTGZKKAFLBEQzcej5OTk6NocoFAAI/Hg9vtpqmpiUAgQF5eHqD/fmTiRDQaxel0EggEaGlpobe3l82bN6umDwn1xUCOhFB/KIxAo9oAzb8EMuAv4P+eQ9cIiMGbqxf2LxPT6VBbw/REXNRePQNWLOFobSzp9HAtD7CKo/lu9hJIg3PbliZs4ZltFwGvw/1WuGcpcJHOCEDGaw+lUHRkSPgdbkQiET755BPMZjNbtmxh2rRpqrVR+v0BRbb3+/0qdQB7VNuNau5GcWgjTauvr4/Ozk7q6uoU/aqjo4POzk5aWlrYsWNHglc2Um+6TwPj8Qx8f1/Htzdv1Tjy++OPP6ampobp06czb948YrEYxcXFRCIRtmzZgsfjUTJ+Pp+P9vZ22tra1LgZoViJTKB4oZFIRLUMy3XdvHkzVVVVuFwuVqxYoa6htLsOPBbpqhNlM9l3I4YqShmPdajzdjgwAo0q6J6hG1b8g/q1Z1IxY42e17wHfVx1eT7cvw61+xcDkcV8cCHwl3q+ruVzzYZH9Y/bf8kzppuAJcApsEiX/mP5qTC/FlwXg281quMriU+NXbt2sXv3bnp7ezn//POZPn26Gs5n7LWXnKdwUcVLFXFrIXf39vYqz9YopBIIBKirq2Pz5s309vayZs0atm/f/oXMjR4MDGVcJAcpkUIkEuHDDz9U0UJ+fj55eXm43W4aGxspKyvD7XbT2dmpUjjCGRVdBgntY7EYGRm6jGdXVxfp6enq2vb09LB27Vo1/kVGtMhvw1joNL42Doo0Hse+wv6BOeXDjRFqVEHPs7bATCc1x8xnzPubsH1Hl2RrOSUf7/216JzQS6g4eQ2Nc4qIRtKJvF7CNaZHgQ74iwcWHa13VC0phTkluJc24H2uWDeovAC+PPRiUxKfB5qmsXr1asaNGwfAlClTFCFfJn6KnqfX6yUzM1OF9JJ7Ff0Ao6Ht6+ujq6uL5uZm2tvb2b17t5L4W7lyZYIiUhL7h9EIGSvmmzdvJhaLkZeXx1FHHUVFRYWa2JCVlaWmn8o0B/FIu7u7CYVCyihLLl34rhJ59PT0UFdXx86dOwmFQmqO1L48SSOzY+C+f9pjPZwYRvL/p8TF1bqS1ab+f39Bbw29vBoKgNtXoVfnP4CLFyd2S93eC/wDVp4Lx3Trf1NCIrd0ZGGkkf8/DWbNmkVVVRVVVVVq2JwYy66uLnbu3AnolJrc3FzVRCBhXm9vL5s2bVIE8NbWVurr6+nq6iIajdLR0cG6deuG5dj2hUNB/jdiX17ZgWBv3zcKfxcUFHDqqaeyYMECNmzYQHd3N+FwmPb2dkKhELm5uWRlZVFSUoLdbmfjxo00NTWppg6TyURBQQFOpzOhyLR7925llCVqkeX3JtU3MPVxMH/P4glLS+/BxJFjVKlEbzetAbbuZZnT0alSQ3UzZaD3nn7AkaB1eiQbVdAncRYWFmKxWCguLqa4uFh10AQCAaUUJakA6TMXmb81a9awe/fuBHFjv98/IqTd9oaRblT3tryR72s2m8nNzWX8+PFkZmbS1tamuqhEp1X0Z0V0ZcuWLaoLStM0JTTe09NDW1ubEq2RYtNnzXsf7N+zFE3/g43qfxaOdKNqhJENsD/DMLCgciThSDWqgGJtyD/RWRDDZ+zUkjx5LBZTgilG9THYcy6kYi95XONnB2O/Pw8OlVEdwTnVJL4oMN5QSRw49pdvPJgwjvMWiGjOwO0ZC0HG9lCB0WgOZUiH82E/MNVwKIpZSaOaRBIjFIeCsL6vdRqr7/K/0cgO9b2h+uwHrme4I6bDvf1h7v1PIokkRir2xv/cl9c58LO9pSyG21s9lEh6qkkkcYThUBuF/a1/4Of7a0I4kPcOBQ7kOA7FuUwa1SSSGKE4GIWpz/v9vRHpD3Q9w0XEH05POBn+J5HEFwiHyvs6GMb8YO7XcKcQ9oWkp5pEEkcI9mZEDoVHu6/tfB6v89Ps14EUuj7rce6t4eBgIOmpJpHECIORG3ogyx5uHK5tHg5v9FCsP2lUk0hihMFoTA5Fi2YSOg7VOU2G/0kkMcJgNKr74pUeDKPwWdYxXOpPnwb7O65DyaFNGtUkkhhhEKlD6XLaF/b2+VA5w4NlQD7Peoa7IcDo+UvL7cFG0qgmkcQIg2iSDpz2eSR4iCMdn4Zj+5m3caCCKkkkkUQSSewfyUJVEkkkkcRBRNKoJpFEEkkcRCSNahJJJJHEQUTSqCaRRBJJHEQkjWoSSSSRxEFE0qgmkUQSSRxEJI1qEkkkkcRBRNKoJpFEEkkcRCSNahJJJJHEQcT/B+OazXPJnjm4AAAAAElFTkSuQmCC\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -669,14 +703,14 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████| 2/2 [00:00<00:00,  2.59it/s, kld=151, perceptual=0.348, generator=2.49, feature=0.198, discriminator=2.25]"
+      "100%|███████| 2/2 [00:00<00:00,  3.39it/s, kld=149, perceptual=0.372, generator=2.91, feature=0.186, discriminator=1.79]"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 6/100\n"
+      "Epoch 11/100\n"
      ]
     },
     {
@@ -684,32 +718,31 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.17it/s, kld=179, perceptual=0.365, generator=1.58, feature=0.125, discriminator=3.83]\n",
-      "  0%|               | 0/2 [00:00<?, ?it/s, kld=209, perceptual=0.396, generator=1.49, feature=0.137, discriminator=3.75]"
+      "100%|█████| 15/15 [00:06<00:00,  2.20it/s, kld=155, perceptual=0.336, generator=2.94, feature=0.162, discriminator=2.13]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.88it/s, kld=98.6, perceptual=0.314, generator=2.96, feature=0.145, discriminator=2.31]"
      ]
     },
     {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 400x150 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 12/100\n"
+     ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████| 2/2 [00:00<00:00,  3.08it/s, kld=108, perceptual=0.384, generator=1.93, feature=0.183, discriminator=3.43]"
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.23it/s, kld=1.21e+3, perceptual=0.379, generator=2.97, feature=0.186, discriminator=1.68]\n",
+      "100%|██████████| 2/2 [00:00<00:00,  4.23it/s, kld=817, perceptual=0.401, generator=3, feature=0.189, discriminator=1.66]"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 7/100\n"
+      "Epoch 13/100\n"
      ]
     },
     {
@@ -717,32 +750,111 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.15it/s, kld=407, perceptual=0.38, generator=1.84, feature=0.127, discriminator=3.41]\n",
-      "  0%|                | 0/2 [00:00<?, ?it/s, kld=427, perceptual=0.37, generator=1.94, feature=0.124, discriminator=2.84]"
+      "100%|█████| 15/15 [00:06<00:00,  2.21it/s, kld=118, perceptual=0.377, generator=3.04, feature=0.168, discriminator=2.01]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.45it/s, kld=72.6, perceptual=0.365, generator=3.06, feature=0.179, discriminator=1.59]"
      ]
     },
     {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 400x150 with 3 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 14/100\n"
+     ]
     },
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████| 2/2 [00:00<00:00,  3.35it/s, kld=302, perceptual=0.393, generator=2.02, feature=0.133, discriminator=2.79]"
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.24it/s, kld=2.05e+3, perceptual=0.386, generator=2.48, feature=0.177, discriminator=2.18]\n",
+      "100%|███| 2/2 [00:00<00:00,  4.27it/s, kld=1.31e+3, perceptual=0.326, generator=2.54, feature=0.166, discriminator=2.24]"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 8/100\n"
+      "Epoch 15/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.18it/s, kld=1.19e+3, perceptual=0.337, generator=2.82, feature=0.173, discriminator=1.79]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.00it/s, kld=730, perceptual=0.329, generator=2.82, feature=0.17, discriminator=1.78]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 16/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.18it/s, kld=383, perceptual=0.348, generator=2.8, feature=0.144, discriminator=1.78]\n",
+      "100%|████████| 2/2 [00:00<00:00,  3.79it/s, kld=204, perceptual=0.328, generator=2.87, feature=0.146, discriminator=1.8]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 17/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.22it/s, kld=327, perceptual=0.349, generator=2.62, feature=0.0884, discriminator=3.06]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.21it/s, kld=198, perceptual=0.337, generator=2.67, feature=0.0891, discriminator=3.01]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 18/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.17it/s, kld=780, perceptual=0.363, generator=2.98, feature=0.0928, discriminator=2.89]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.25it/s, kld=522, perceptual=0.379, generator=2.94, feature=0.0919, discriminator=2.82]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 19/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=711, perceptual=0.346, generator=1.89, feature=0.0815, discriminator=3.88]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.29it/s, kld=413, perceptual=0.327, generator=2.01, feature=0.0848, discriminator=3.68]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 20/100\n"
      ]
     },
     {
@@ -750,13 +862,13 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.15it/s, kld=356, perceptual=0.365, generator=2.34, feature=0.166, discriminator=2.39]\n",
-      "  0%|               | 0/2 [00:00<?, ?it/s, kld=345, perceptual=0.357, generator=2.35, feature=0.159, discriminator=2.52]"
+      "100%|████| 15/15 [00:06<00:00,  2.17it/s, kld=329, perceptual=0.339, generator=2.13, feature=0.0703, discriminator=3.87]\n",
+      "  0%|              | 0/2 [00:00<?, ?it/s, kld=298, perceptual=0.338, generator=1.85, feature=0.0606, discriminator=3.84]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVUAAACFCAYAAADrRWu1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABVi0lEQVR4nO2deXhU5dn/P2f2fSaZ7Isk7CAoAnWpoLhU9HVDqxQtVlpxLVba17p0c6i+otUqVVu1akXBWpf6s9ZWq1apooAiuxDWBLJvk0kms2Vmcn5/DM/DTBIQazABz/e6cmXmzJmzPGfO99zPvXxvRVVVFQ0aNGjQ0C/QDfQBaNCgQcORBI1UNWjQoKEfoZGqBg0aNPQjNFLVoEGDhn6ERqoaNGjQ0I/QSFWDBg0a+hEaqWrQoEFDP0IjVQ0aNGjoR2ikqkGDBg39iCOSVKuqqlAUhfvvv7/ftrls2TIURWHZsmX9tk0NvaGN85GHOXPmUFZWNtCH8ZVhUJHq4sWLURSF1atXD/ShHLYYbGMYDofx+XwaSe7FZ599xuzZsykuLsZsNlNUVMR3v/tdPvvssy+13bvvvptXX321fw7yc/DRRx/h8/kIBAJfyf4ONwwqUtVw5CEcDrNgwYKDJtVTTjmFSCTCKaeccmgPbADwyiuvMHHiRP7973/z/e9/nz/84Q9cddVVvPfee0ycOJH/9//+33+97a+aVBcsWHDQpPrEE0+wdevWQ3tQgwiGgT4ADRrSodPpsFgsA30Y/Y6dO3dyxRVXMHToUN5//31yc3PlZzfddBNTp07liiuuYMOGDQwdOnQAj7T/YTQaB/oQvlIcVpZqV1cXv/rVr5g0aRJutxu73c7UqVN577339vudBx98kCFDhmC1Wjn11FPZtGlTr3UqKiq45JJLyM7OxmKxMHnyZF577bVDeSpfKebMmYPD4aC2tpYZM2bgcDjIzc3l5ptvJplMyvXSfdGfN27Tpk1j2rRpfe5L+M+qqqokeSxYsABFUVAUBZ/Pt99j7cunOm3aNMaNG8eGDRs49dRTsdlsDB8+nJdffhmA//znP5xwwglYrVZGjRrFO++8k7HN3bt3c8MNNzBq1CisViter5dLL72UqqqqXvsX+7BarZSUlHDXXXfx9NNPoyhKr/XfeOMNpk6dit1ux+l0cu655+53Gn/fffcRDof54x//mEGoADk5OTz++OOEQiF+85vf9DmW6fD5fCiKIt8rikIoFOKZZ56RYzxnzpyMdSsqKpg5cyYulwuv18tNN91ENBqV2xDXfvHixb32l37NfD4fP/3pTwEoLy+X++trLPd3Hum/s9///vcMHToUm83GWWedRXV1Naqqcuedd1JSUoLVauXCCy/E7/dnbPNvf/sb5557LkVFRZjNZoYNG8add96Z8XsWEPuwWq0cf/zxfPDBB33+fmOxGHfccQfDhw/HbDZTWlrKLbfcQiwW2++59YXDylLt6OjgySef5LLLLuPqq68mGAzy1FNPMX36dD7++GMmTJiQsf6zzz5LMBjkhz/8IdFolN/97necfvrpbNy4kfz8fCDl4zr55JMpLi7mtttuw2638+KLLzJjxgz++te/ctFFFw3AmfY/kskk06dP54QTTuD+++/nnXfe4be//S3Dhg3j+uuvz1j3YMbtYJCbm8ujjz7K9ddfz0UXXcTFF18MwDHHHPOFj7+trY3zzjuPWbNmcemll/Loo48ya9YsnnvuOebPn891113H5Zdfzn333ccll1xCdXU1TqcTgE8++YSPPvqIWbNmUVJSQlVVFY8++ijTpk1j8+bN2Gw2AGpraznttNNQFIXbb78du93Ok08+idls7nU8S5Ys4corr2T69Once++9hMNhHn30UaZMmcLatWt7keHf//53ysrKmDp1ap/nd8opp1BWVsY//vGPLzw2S5YsYe7cuRx//PFcc801AAwbNixjnZkzZ1JWVsbChQtZuXIlDz30EG1tbTz77LNfaF8XX3wx27Zt4/nnn+fBBx8kJycHoNeD4mDw3HPP0dXVxY033ojf7+c3v/kNM2fO5PTTT2fZsmXceuut7Nixg4cffpibb76ZP/3pT/K7ixcvxuFw8JOf/ASHw8G7777Lr371Kzo6Orjvvvvkeo8++ijz5s1j6tSp/PjHP6aqqooZM2aQlZVFSUmJXK+7u5sLLriA5cuXc8011zBmzBg2btzIgw8+yLZt276Ya0UdRHj66adVQP3kk0/6/DyRSKixWCxjWVtbm5qfn6/+4Ac/kMsqKytVQLVarWpNTY1cvmrVKhVQf/zjH8tlZ5xxhjp+/Hg1Go3KZd3d3eo3v/lNdcSIEXLZe++9pwLqe++992VP85CirzG88sorVUD99a9/nbHucccdp06aNEm+/yLjduqpp6qnnnpqr/1feeWV6pAhQ+T75uZmFVDvuOOOgzr+vsb51FNPVQH1z3/+s1xWUVGhAqpOp1NXrlwpl//rX/9SAfXpp5+Wy8LhcK/9rFixQgXUZ599Vi678cYbVUVR1LVr18plra2tanZ2tgqolZWVqqqqajAYVD0ej3r11VdnbLOhoUF1u929lgcCARVQL7zwwgOe+wUXXKACakdHh6qqvcdS4I477lB73rp2u1298sor97vuBRdckLH8hhtuUAF1/fr1qqruu/bp4ybQ8/rdd999GePxeeh5HmJfubm5aiAQkMtvv/12FVCPPfZYNR6Py+WXXXaZajKZMu7Rvq7ptddeq9psNrleLBZTvV6v+o1vfCNje4sXL1aBjN/vkiVLVJ1Op37wwQcZ23zsscdUQP3www8P6lxVVVUPq+m/Xq/HZDIBqSeL3+8nkUgwefJk1qxZ02v9GTNmUFxcLN8ff/zxnHDCCfzzn/8EwO/38+677zJz5kyCwSAtLS20tLTQ2trK9OnT2b59O7W1tV/NyX0FuO666zLeT506lV27dvVa7/PGbSDgcDiYNWuWfD9q1Cg8Hg9jxozhhBNOkMvF6/Tzslqt8nU8Hqe1tZXhw4fj8XgyfjdvvvkmJ510UsaMJzs7m+9+97sZx/L2228TCAS47LLL5G+mpaUFvV7PCSec0MsdFQwGAaTlvD+Izzs6Og643n+DH/7whxnvb7zxRoABvaaXXnopbrdbvhfXbvbs2RgMhozlXV1dGfdi+jUV9+7UqVMJh8NUVFQAsHr1alpbW7n66qsztvfd736XrKysjGN56aWXGDNmDKNHj864pqeffjrAAV2MPXFYTf8BnnnmGX77299SUVFBPB6Xy8vLy3utO2LEiF7LRo4cyYsvvgjAjh07UFWVX/7yl/zyl7/sc39NTU0ZBHO4wmKx9JqiZWVl0dbW1mvdzxu3gUBJSUmGHxHA7XZTWlraaxmQcV6RSISFCxfy9NNPU1tbi5rW7KK9vV2+3r17NyeddFKvfQ8fPjzj/fbt2wHkDdcTLpcr470gS0Gu+8PBku9/g57XdNiwYeh0ugP6Qg81jjrqqIz34todzDX97LPP+MUvfsG7777b6yEkrunu3buB3tfPYDD0cs9s376dLVu27NeN0dTUdDCnlNr+Qa85CLB06VLmzJnDjBkz+OlPf0peXh56vZ6FCxeyc+fOL7y97u5uAG6++WamT5/e5zo9L8jhCr1e36/bUxQlg5wE+goU9Af2d/z7W55+bDfeeCNPP/008+fP56STTsLtdqMoCrNmzZK/gS8C8Z0lS5ZQUFDQ6/N0qwhSpFBYWMiGDRsOuN0NGzZQXFwsSbnnQ0SgP8a457YP5b72h//2mgYCAU499VRcLhe//vWvGTZsGBaLhTVr1nDrrbf+19d0/PjxPPDAA31+3pPoD4TDilRffvllhg4dyiuvvJLxI7jjjjv6XF9YFOnYtm2bfEqJ1BWj0ciZZ57Z/wd8mOLzxg1SVm5frgNhHQjs72b9KvHyyy9z5ZVX8tvf/lYui0ajvfIshwwZwo4dO3p9v+cyEQTKy8s76N/NeeedxxNPPMHy5cuZMmVKr88/+OADqqqquPbaa+WyrKysPnNBe44xfP44b9++PWM2t2PHDrq7u+U1FdPhnvv7b/Z1qLFs2TJaW1t55ZVXMvKZKysrM9YbMmQIkDrX0047TS5PJBJUVVVlBEyHDRvG+vXrOeOMM770+R12PlXItEJWrVrFihUr+lz/1VdfzfDDfPzxx6xatYpzzjkHSN0U06ZN4/HHH6e+vr7X95ubm/vz8A8bfN64QepHWFFRkTFG69ev58MPP8zYloisD2T1jV6v72VVP/zww72ssOnTp7NixQrWrVsnl/n9fp577rle67lcLu6+++4MF5RAX7+bn/70p1itVq699lpaW1szPvP7/Vx33XXYbDaZrgSpMW5vb8+wcOvr6/ssErDb7Qcc49///vcZ7x9++GEAeU1dLhc5OTm8//77Gev94Q9/6HNfMHDXtC8e6Orq6nWskydPxuv18sQTT5BIJOTy5557rpfba+bMmdTW1vLEE0/02l8kEiEUCh308Q1KS/VPf/oTb775Zq/l06ZN45VXXuGiiy7i3HPPpbKykscee4yxY8fS2dnZa/3hw4czZcoUrr/+emKxGIsWLcLr9XLLLbfIdX7/+98zZcoUxo8fz9VXX83QoUNpbGxkxYoV1NTUsH79+kN6roMRBzNuP/jBD3jggQeYPn06V111FU1NTTz22GMcffTRGT4uq9XK2LFjeeGFFxg5ciTZ2dmMGzeOcePGfWXnc95557FkyRLcbjdjx45lxYoVvPPOO3i93oz1brnlFpYuXcq3vvUtbrzxRplSddRRR+H3+6UF43K5ePTRR7niiiuYOHEis2bNIjc3lz179vCPf/yDk08+mUceeSRj2yNGjOCZZ57hu9/9LuPHj+eqq66ivLycqqoqnnrqKVpaWnj++eczUqFmzZrFrbfeykUXXcSPfvQjmbY1cuTIXoHZSZMm8c477/DAAw9QVFREeXl5RgCvsrKSCy64gLPPPpsVK1awdOlSLr/8co499li5zty5c7nnnnuYO3cukydP5v3332fbtm29xnPSpEkA/PznP2fWrFkYjUbOP/98SbaHGt/85jfJysriyiuv5Ec/+hGKorBkyZJeD06TyYTP5+PGG2/k9NNPZ+bMmVRVVbF48WKGDRuWYZFeccUVvPjii1x33XW89957nHzyySSTSSoqKnjxxRf517/+xeTJkw/uAA86T+ArgEgH2t/fnj171LvvvlsdMmSIajab1eOOO059/fXX95uycd9996m//e1v1dLSUtVsNqtTp06VKSTp2Llzp/q9731PLSgoUI1Go1pcXKyed9556ssvvyzXOdxTqux2e691e6bmfNFxW7p0qTp06FDVZDKpEyZMUP/1r3/1mQb00UcfqZMmTVJNJtPnplftL6Xq6KOP7rXukCFD1HPPPbfXckD94Q9/KN+3tbWp3//+99WcnBzV4XCo06dPVysqKtQhQ4b0SkNau3atOnXqVNVsNqslJSXqwoUL1YceekgF1IaGhl7HOn36dNXtdqsWi0UdNmyYOmfOHHX16tX7Pb8NGzaol112mVpYWKgajUa1oKBAveyyy9SNGzf2uf5bb72ljhs3TjWZTOqoUaPUpUuX9plSVVFRoZ5yyimq1WpVAXleYt3Nmzerl1xyiep0OtWsrCx13rx5aiQSydhGOBxWr7rqKtXtdqtOp1OdOXOm2tTU1Oc1u/POO9Xi4mJVp9N9bnrVge7PnuMJqC+99FLG8r5+0x9++KF64oknqlarVS0qKlJvueUWmU7X8x596KGHJGccf/zx6ocffqhOmjRJPfvsszPW6+rqUu+991716KOPVs1ms5qVlaVOmjRJXbBggdre3r7f8+uJQUWqGgYW+/uxf91x0003qRaLRU0kEgN9KF8YglSbm5sH+lAGDZLJpJqdna3OnTv3kGz/sPKpatBwqBGJRDLet7a2smTJEqZMmdLvGRQaDj2i0Wgvt8Czzz6L3+/vs8y6PzAofaoaNAwUTjrpJKZNm8aYMWNobGzkqaeeoqOjY795zBoGN1auXMmPf/xjLr30UrxeL2vWrOGpp55i3LhxXHrppYdknxqpatCQhv/5n//h5Zdf5o9//COKojBx4kSeeuqpI1KK8OuAsrIySktLeeihh/D7/WRnZ/O9732Pe+65R1Zn9jcUtadtrEGDBg0a/mtoPlUNGjRo6EdopKpBgwYN/QiNVDVo0KChH3HQgSpF8R3Cw9DQE6rq+9LbGOga7a8b+is8kZeXh5rKIQf2L15zuKK/fpfpY3IwYyT2q9Pp5J/Vau1T7+HLQIv+a9AwCKHT7ZtEHogwDley/aLE2td5HqzS1v62l/7g6k9opKpBwyBHzxv/cCXSdAzkOaST6X8jE/h50EhVgwYNXysIQj1UxK4FqjRoOIxwJFipA4l0Qj1UY6lZqho0DDL0DMD0XKbhiyN9/A6lPxU0S1WDBg0a+hUaqWrQMIihWahfDgeySDVLVYMGDRoOA2ikqkGDBg39CI1UNWgYxNCq4r4cDjR+h2pstei/Bg2HAb6qUtWDqVzScGBopKpBgwYJjUC/PLTpvwYNGo5YDET2hGapatCg4QvhQNaslgKmkaoGDRr2QlXVXoS5P5Lsi1j7Y90jARqpavhKYTQaM1o9p99cyWSSRCIxEIf1tcHBao6mr9fd3S0JN50ge66brv/a13b7+vxQk+tAyCYeAaR6I2DtscwPPDkAx6Lh83DJJZcwfvx44vE48XicZDIJgNlsZvXq1bz++usDfISDE/1BAAfaRno9vCBPIYun1+uxWCwoioJOp8NgMMjvJJNJQqEQyWQygzQFcYrX+xPc/iq0Db5qke/Dn1Rf90JZ2vu7gL/YBuhgNKTjnHPOwePxUF1dTVtbG4qiUF9fT1NTE7FYDIPBQE5ODhaLBVVVaWho4OSTT6akpISuri7eeustQqHQQJ/GoMChJgZBfmazWe5L7M9gMGAymTAYDNjtdjweD4lEgvb2djo7O7Hb7fIB2dOSTSfVRCIhiTqddNPdDkeCW+AwItUx8OR3wNNjcQnQAJwZh3lG+MsyoIMU004EnFBWDlVv97HNNUDk0B3y1xQej4eysjKKiorYs2cPwWCQzs5OkskkTU1N6PV6rFYrJSUlZGVlYTAYeOONNygoKGDKlCmEw2EqKys5/vjjKSgowO12U1ZWhtVqZc+ePTzxxBNA6maPxWIa8X4JqKqKXq+X7UW8Xi8mk4muri66uroApLvG6XSSl5dHbm4u4XCYRCJBOBwmJyeHRCJBNBoFUl0L0q1VYdEGg0Hi8bhclk6s6cdzuENRD/IsBq5HlQtyfgI+YNp+VpkNnAgTH11OKdXYiLCOCdzM/Vyl/Bk27ed7c4Gqva8bILWTwYHDuUfVRRddRF1dHdFoFKPRiM1mo7Gxkfr6eoxGI2VlZRx11FGMHDmSgoICurq6qKurIzs7G5fLxccff8yaNWtIJpPSOpo8eTJFRUU0NTXR3NxMPB6ntLSUiooK3nrrrQE5z57oL0LIzc3td8LpKX2Xbo0ajUbMZjN5eXlYLBbsdjtGo5G6ujppfTocDkpKSigpKUGv1xMIBKitrcVut9PV1UUikaCtrY1oNIrFYsFqtWK1WonFYkQiEcLhMMFgkEQiQSKRIBKJyGMSrWN6HmN/oi/pP0VRcDqdVFZW9uu+DgNLdQgs2/tyNTAnDEttMIEUKa5UgY3cvfZpbq9blFrPAB1eIy16b+p9FEiPf6wG5jXCk/mp7ViAN4GbXUAczXr976DT6SgtLWXXrl20tLRQWFhISUkJVquVUCiEwWCgsLCQY445hpKSEnJzc+VNmUwm8Xq9KIpCPB7HbDaTnZ1NNBolHo/T2tpKdnY2Op2OUChEIBAgkUgwevRoJk6cyGeffcbrr79+RFg6/YUDjYXwjwrC9Hg8mEwm3G43RqMRo9FId3c3yWQSi8VCYWEhHo9H+sBtNhvDhg3DYrGQTCaJRqPk5OTQ1NQEpAKSVquV7u5uurq6cDqdhMPhDJeAOMZIJNJnv6nD9VoOYlLNBy6Gxfmpt8uAHcB1NiggZWGubGSZegGTY6uxN+3rNfN63umcn/tvaGkFPoXJE2GcknIVvLkBxh0DPAo3+1KEuxo4E1j5EwgAZ68C3vhqTvMIgMfjwWq1UlxcTG1tLTt27MDj8VBaWkpZWRnRaBSDwUBeXh5nnnkmxx57LN3d3ZhMJpxOJ93d3eTk5EjryGg0csYZZzBy5EjC4TA1NTVUVlYSCoVwuVwYDAbq6+upra3FarUycuRIJk2aRGdnJ++//7688b/O+DxC0uv1MhOjtLSU4cOHU1tbi8FgkL5VYUFaLBaKi4sxm82Ew2Gi0Sh2ux2HwwFAIpFAp9PhdDrR6/XEYjFUVcVqtUrL1eFw0NzcTDKZRK/X43A40Ov1JJNJuru7M/ytB3P8gxmDk1QNPpgDzE9bNg94BJjng+E+WAfcnM94NvAL810seu/2feuuI2WBvuMFHgb+DjN8nHfnS9gI86ISAeYyv20hi5S93zMAfwGWAgwn5Qp4iFQmgYb9wWazccEFF7Bt2zY2btwop/xWqxWHw4FOpyMYDBIKhSgsLGTEiBEoikJtbS35+fnk5eVJK6Wzs5OGhgby8/OZOHEi2dnZJJNJ2bI5HA7j9XpxOp0y9SoUCtHY2IjD4eDEE0/EbDbz5ptvDuSQDGoIK9FiseDxeHA4HJSXlxOJRLDZbITDYRwOhyRNYWVarVaMRiOwr1leug9VvM/KypLTfLfbTSKRwGg04na7qaysJJFIoNfrycrKwmQyUV9fj8vlIhgMEovFBmZQ+hmDsEzVl7JK5/f+5KQfvgseH0wBGuCk+97FFoqy6F+3wywfNIB6j4L6scKxb69Mbcvig1k+au708vpPL+X7PA2MAUtJ7x28CUOaK5iv/hEuAQgekjM8kuD1eonH42zbtk1O4wwGAwaDQQYyAoEA0WiU3NxcHA4HwWCQmpoaOjo65HZUVSUajeL3+3E4HDidTunry87OZsiQISiKIm9SnU6Hy+XCarVmWDWjRo0aiGEYVOjLyhPLhIXqcrkYOXIkpaWldHR0UFtbi9/vl9kZra2tKIqCy+WioKBAugqMRiMGgwGz2YzJZEKv18tAlLA4xXqKopCbm0thYSEGg4F4PJ5hjXZ1dWGz2bDb7XL7kJk10DM39nDAILNUs1NBJ08fH82AFc7TU37UAPCOjxW3+7Cep+6drg+HceBbB+XqTNYre62VqA8KfBRP83P8sv9wjnFZaqr/jg8wZ+7jbNjtHM0ihNVrJeVj1dATHo+HkSNHMnXqVJYvXy6n+DqdDpPJBEBbWxvxeJxAIEBBQQHjxo3DarVSX1+P3+8nEAjQ3d2N0WgkEolQVVVFU1MT+fn56HQ6ebMmk0ncbrdM5QFkQCWRSNDa2kpLSwt6vf5rXzywP0JVVRWDwYDFYkGv1+P1euX41dXV0draisFgIBqNkkgkiMViJBIJXC4X2dnZGVN04SIQMBqNvQhTkKTdbsdkMtHR0SHXSSQSBINB9Hq9tJpNJpPcr1h+uLoABo+lavHBbT+C2/bz+V3ASlKkehvwqg/uuRem3AtlJwAnyFXnKC/sfWUFrLz64HRq/gMf//tUSMCyt09gtlrMNBkB24u5e/exElgOUNxPJ3dkQafTMW3aNMrLy1m3bh01NTUkEgl507pcLkwmE83NzdTU1KCqKpMnT+boo48mHo/T3NxMLBaT1o2qqtTX11NVVYXX6yU/Px9FUUgmkzJybDQaKSoqQq/XE41GpcVlNBpxOp2oqsrOnTvZsmULTqdzoIdo0CA96d5kMuHxeCgsLOSoo44iHA7T3d1NZ2cnqqpmkF5nZyd6vR6Px4Pb7QYgFotJfyog065MJhMWi0XOUEwmEyaTSbqBAOLxOIqiyPSsaDRKLBaju7sbRVGw2Wx4PJ5ehQE9rdfDAYPEUp2bIjHLQay6CVj3Nkyeiq5hHt2dtpQLdMKIHmdzMUNUE7u3jgbepWQlsAyaVCe5dZ2cysfcWHTvvtVbIINjJwP3fAdu832ZEzsikZOTQ0NDAy0tLdLqEPmOHo+HoqIidDqdvFkLCwspLy/HZDJRV1dHS0sLLpcLr9eLTqcjkUhQX1+PXq9n7Nixcrmo1hGFAmZzamYRCoWkFTR8+HBGjBiB3+8nHA6zYcMGaSUdrpbOl0FfFUviz+l0ctppp9HV1UU4HKajowOz2SwfTgaDgc7OTiwWC06nE5fLRX5+PslkEp1OJ32jIs1KWMBWq1VWVHV1ddHd3U13dzfxeJxoNCrzXUXgymQyyWvc1dVFJBIhLy+PUChEa2trn+cjyBcGfxBrEJCqEWaX9E2oTwIv91hWsxn4EKZ9i2Hb17O9YCOMmw1LQbUpsAUWjHkbHN9iOr9jwqh7uPC6t1BeUCEAeZPT/KTFG1K+2wRwNjABjK93EPe54LwOWOoiVQb7cP+f9mGKoUOH8o1vfEMGpcQ0UafT4fF4OP744xkyZAgtLS0EAgF0Oh1FRUV4PB46Ozuprq6mo6OD0aNHc9RRR2E0GmVxQEFBAXl5eTKqHI1GaW5upq2tTfrvIpEIVquV8vJySkpKGDp0qEzNGjt2LHV1dbS3t8uyyoaGhgEesYGHcMkUFRVRUlJCIpGgqqoKgEgkgsvlwm6343Q6icfj2Gw2rFYrNptNkmhXVxdmsxmz2SxnJcJvLvah1+sxmUyyeioejxOJRGQea25uLt3d3VgsFpkeF41GaW1txWQyEQ6HZRqW2Gdf+bqDHQNPquN+DksrYWk50AqvelNHVQEsegKoTa230sf8Exay6Ke3w/2AAbYvOBYuORZeXkbV0TNRLlXh5VaY7IXVPh5/aQFPzISb1Tvh8Q1AGbzjSlmkK31wog8WLYNFAB/CypOJ50xLvb/NBbPjkOOFS3zw2P/xdfev6nQ6cnJyUFWV4447Tlqj1dXV1NXV4fV6mThxIiNHjqS9vZ1AIEA8HpfTx127drFz506SySTl5eU4nU7q6uqorq6mvb2dUaNGSQumo6ODpqYmqquriUajuN1uYrEY8XicESNGYLPZcDgc5ObmSj/hMcccg9lspqqqSlq369ato7q6WlpLXzeIfFRh1dtsNmw2G8FgUBKazWYjKyuLvLw8DAYDVqtVBhxF9oaYiQAyLcpoNMqHqnAbGI1Gua6ouhJWbElJiXQTmEwmqS9gMpmIRqMEAgGKiooIBAJ0dXVlZAN8GaWrr9qyHWBSnQabXsPYMo2umIKyRU25AXyVsKgcGANTroZNUHDCLv7Cdyi4bxcN998IswBfK9zmBZYx5N1myAEWeWH+C6ksARZw9d9AyfoFf1ZncPmCV1O7PRs425d63TAN5kDuHUNpPu0ocMCIm9azrW4CyxdOZOqCT6ETYDxwAfAAqTLYrx+ysrI46aSTMJvNTJgwQabM1NfXs2LFCtavX09NTQ0jRoygqKiI/Px84vE44XCY2tpaEokETqdT+uUikQhr166lvr6ekpISvF4vRqORpqYmqqqqaGlpwePxkJubi9frpa6ujs7OTknIqqpiNpvl1DA3N5esrCzGjx9POBymrq5OLl+5cuVAD98hR89pv6gaMplMFBQUUFBQgNlsxuVyUVhYKEtTRd5oXl4e3d3dcnk8HpczkEgkIl01qqrKmUN6QFGv18vAo81mIzc3V6ZX5ebmEo/HpatB5BJ3dXWh1+vp6uoiPz+ftrY2qqqqaGxspLS0lPr6enl9dTpdRjCs5zkPFgwsqeZMgxZoc+ghBpvOGMa4l3cCfphfAkSgAQradjFPGUYc8DXCWPVTGpNR/NFiuKcGAOUTFfeiBtotChBPEaEXlLUqdMLlj7+KerWCagHdfSozFz7Di3+7MuVLrYLmnaUQgD+8N4fr654BYErdGtSrFRqK3BTe/1IqQHbPEGDjVz5UgwHJZFLWegurxWazUV5eLomztraWpqYmbDab9OUJCzM7OxtFUejo6JAiKsLvmp+fj8WS8gFFo1E6Ojro7OzE4/HIqWlhYSHBYBCz2Sz9eem15MJCstls6HQ6zGYzsViMrq4ujj32WKqqqmhvbx+w8TtUOFAKlbA4CwsLcTgcRKNR2tra6O7uxmq14vF4iMfjmEwmmWmhqio6nY5YLIbFYskIOIngoSBfMUsQ11mkwYlUKYvFIq+B8InH43FisZj8XRgMBtxuN2azGbfbTVNTE3a7XQawhF82Pe1KnONg9LMO/PQf2GEexrKi05g//nG4GfjLJAjcC5wPOzbQsOoYfr4RfOPhZ3m/ZItSQ8pyfAhqroGSn8Btb9N+27fkNh+Oz2WZAowGZgDXVcL5EDMD91TyYvTKVIVWpw8WG7nw6aEUra0nQBa/K7oGAC+tzK77KwV17ZyqJvnPOcCyb8Oib8OrX7/CAKfTKctPt23bRjwex+PxMGLECEaPHk08HqeiooIdO3aQnZ2N2WwmGAwSDofJzs4mLy+PgoICmdITCAQwGAxkZWVRWloqydDj8VBQUCCnlaFQCIfDQVZWFm63m46ODnbu3EkgEJBWk9lsljexmFaGQiFJIHl5eQwdOpT33nuPQCAw0EN5yCEsVZ1Oh9VqlbOAYDBIc3OzJEVhcQpfqbBEhVUqglRms1nq3QrxFCGMI6b8Iq1OVFAJwtXr9YRCIZl6FQgEaGtro7OzU/6GiouLpWvC7XYTDAbx+/3yQRuPx3vpsQ7WYOQAkmpxqmrqfriX23heuTBFgOtAvUrhkfuv4mn8rPlsSqq46fdpX110AUNv+ozLaQB+zZ1PL6RizhDGbK1KVVJ5ZtOiXMEGoGDLLhpOG0quqoe6vd9/spw75ir8xAxu7gB+xt/G9OEIr4LZO1PLi8SXc0ild/EjePXr5Wc95ZRT6OjokNZOW1sbTqeTnJwcvF4vBQUFktCEb06v1+N2u6UvLRKJyJtYyMgJH5rBYKC7uxun08mIESPIysqivb1dysyZzWZ5k1VXV7N27VpisZic0ubm5krL1uFwEAgE6OzslBqgTqeTb3zjG7z9dl+KZUcWBPGYTCZGjx5NVlYWsViMQCDAnj17ZOqbuA5ut1tG54UFKEhRTNvF7EQQqMViyci0EOsI1wGQ4R4ACAaD1NbWsn37dpnFYbPZMn4niqLIfFlxHrm5ubIgQWwXyHAHHMhiP9AY9TcGME+1JEWqtPK8cgmc54V7gEWtMAHm/f4p1ihT+PPRMyh5abv8Vil7YDHoSaBXFqJXFuL7PmxTdqcqraKbZSaBH6hfPAyWqTzAT9heVMJW+4hMcRUA3kwR92JS2QYvkypZjW5AGaaysGg+zyvfB0faV26Dr1seq8PhwOtNidSIqZuYDoZCITo7OzGZTOTl5WG32zGbzTidTnnDGo1GeaMCMsfUbDbLVBzYJ4rs9XrJy8uTkWLxucViIScnB4/HQywWo6GhgaqqKnbu3ElVVRXNzc20t7cTCoWkWIvIic3JyWHYsGGy5PJwx4FIQ6RBeTweFEUhFArJqjWRoyoeSiaTSU7nhaaq8Lemu3IMBgMej4ecnByys7NlKbKwZkWQKxqNyt+EIGBBrKL8VVwTke/a1tZGU1MTbW1tRCIRkslkhntHaAsIH2u6KAwMnlzWgZ/+T9irJHUXqYg/D8PJoAzt5jL1TzzJXGqsI+AnqdX8yjPcwzMklEwb0QpggVPVPfzn/LFS0s/3fahRcyiprUVnSF1U37W3ol4HW2LAbB8s9cGsVcAd8LqSItUEMPkYWB3HRhhQ4BdpO3QAj8xJaRJ8TTQChMXX2tpKOByWN2EsFqOtrY329nby8/MpKiqSlTQiiV+k4fSseioqKpLkKaaKwleaXmkTCARkMMTpdDJhwgQKCwv5+OOP2bBhA4lEQiaQixp2cZx2u136bhOJBF6vl+LiYjZu3EhbW9sAjuihQTrJiHzfjo4OkskksVgsgwABqeQvCjEEmXV3d2fMDgA5y0jXAhB5q3q9HoPBILchXAni2ovfS0FBAcXFxbS3t6PT6cjKypKJ/7FYjM7OTvldQcSxWAybzSaJON1C7dldYKAx8KS6dD/LZyn8uekqlHNV1NsVfHfs+6ivQsQdQHuViRhmcu/sxJfWleMJxc8daS1XxNC/AajrFGrVbEqsrXAeqXSrN2FKfWqK+D2e5Xz+znwe7z1a00gVI9z2I3jdd5AnfPiioqKCYDCV55udnS2DS6Js0WKx4Ha7sdls8kZMtz7FDS4CG0Luz2KxyMBVevBB3Dwigi1uXuELzMvLY9iwYTK/cdiwYeTm5sqMhPSbL5lMSpdFMBjE4/HIaPORDHH+8XicRCJBR0cHWVlZskxVXL+uri4cDocsthC+U3EtxHUTJcjppaQivUok/Kf3tAJk+avRaJRarSeeeKKUbxTT/lgshsfjkboBYjviOMLhsPTHNzc39+osIDDQ5DrwpJqO2WAJ/Aj+uQBaQMn/AG5DEqpvDiiLq+Xqi9X/5coTX8S3ChqBBwxxPs/H6RsBTIaa51O1Bb5NYFX8Kc2BpY2Qkw9/gQ/qzuL5ogsZxba93+yAGldKPrAn5gKvjwG2fLnzH8SwWq20trbS0dGBzWYjPz8fl8uF0+mUyfrCshG+NUFq4XCYtrY27HY7LpdLrium/+kWjwigiJtSbENM89JJUgSpnE6nTL0SyeqqqpKbmyvLJYWLQbgtOjs7KSkpYciQIezevXtgBvUQQ5CL0WgkJyeHaDQqZxvZ2dk4nc4Mi1L4rQ0GA6FQSAb7otEoNptNblPI+4kglrjWkUhEkivs6xggavqFv1RRFIYMGUJJSepmEi4Co9EoffOiS4CophKzF3Ed3W63tGiFf3WwYOCOxnNOisjS/3ww1r0Z3+Wg7la4Rv2UhnvSfCReSFFhCfAkc855AWWViu+RzE1fDGSp15ClXsMdmVVvKI+qKGaVv6tXMhHIUa/CpV6JOlmBTfmo6xXUMQoY4HLlZib9ZzPOWBDmuvYWCfSB4aRKWtP0B440jB07lqKiIqZOncoZZ5zBN7/5TY477jiGDx8up/n5+fnS75U+jdyxYwdvvPEG77//Pjt27KChoYF4PC5JVgQ8wuEwLS0thEIhGfkXlTViCiksl/TSR+HXS8/LzM7O5qijjiInJ0dK2TmdTjnVjUQi1NbWUlJSQllZ2QCO7KGFsOpF9kVeXh5ZWVnY7XYMBoMkVeF3Fg82QFqwQmUsvVGjaNyY7gsXZafpJaWwj9yF4n9bW5sMTIoZirBGhTJWeqpW+sxFWNCiuiudxAeDPxUGklQDq1JJ+DtI1fKvS023Px0/FQDfdvg+T1Nwv0qWek3md+8BJvhSav08xLU/XJTx8TEnwPyrH6eaUnTeLnx74EY9LPCpcCbMe/o33JC1mAtnq9x4xZPccM5ilJdVGBfnlaJzAFAiXcBGyAF7azeXPfGnA5/PecAj55DqjdWzu+vhD6PRyPHHH89FF13EGWecwcSJExk6dCg5OTnyxnW5XJLcAHmzdHZ2UldXx5o1a1i2bBm1tbW9pN26u7tpbm5m27ZtBAIBOc0XJNjY2Cj9ou3t7TQ0NMjE/vLychwOh/QZdnZ2AimNgtLSUtxuN06nUwbPBOFHIhEaGxsZMWIEZ5111hEpxCL8p0JtKi8vT063xfURClZ2u10GrwDpw2xpacHv9xMKhTLUqISVKsjR7XbLaybaqQjys9vtMi9ZtMQRFqpwN4hMAxH4En/p03vxEIhGozidTvLz8zNIfDAQ6wDazQYWL/wOnAmd0bNRTz6L3/1CgRD4PgEX8BjXcs3//o75v30c31r40/2XAbekiHg2KcV+XH1vvgFa8HKl+iRlpVvwTgc8EOlUCOJMyf8tfY0LlzzPv9/4JpwN89X7uTL0DI8UXQVPGoHr6S78AhdpGrB6DhTc+l+PymCFSEkSaVLi5jGZTJKs0gMc4oYwGo3k5uaSn59PZ2cnVVVV8sYR1o6oEw8GgzQ1NUlSFPtQVZXm5mZZ9trY2Ijf75dBq+LiYunfFeWOsVgMk8kkrTIxrU13KYjIcygUktb2kQRhtYtGfoLAsrKy5BRelKCK8REEJVwqQhVMVLgFg0FZXSXcNoIUk8mkDGKZTCbi8Th+vx+/3y8fvEajUfpuA4EA9fX1cuovUu4EaYtr1FeSv7CYhVD2/hoJDsQ1HTifas4k5igvYAn4cbychPEwbvkn3PTjb8A37qVEvZia00aw6L1rGfO/axjJOrb/59hUutRtKgxXUgr/wB9Pu4lx6jflphfsnAzDfTyjWGHKrbDcl7JEW1KfP6M4EU3+/qZAUP0Z+GDRytvhdR83znuS2x/+FY/7rkX3iAoF8O3v7C+i1gMWBpunul+gqirV1dU4HA6ZoC1KDs1ms0x9Eb414QOzWq2UlpYyduxYGhoaZHM4kXIjbjRxgwtt1KKiIhnsUtVU+2q/3080GmX79u2SGMTN7XA45E28Z88eCgoKpJWrKAqRSISWlhaZhyluWOFeSL+ZjwQI8hEPDkGGIhtCjIF4+CWTSfx+v5y+i9JVm80m9VCFGyYYDJKbmyuvW1tbm5TxEwplgsR3794tNVKF1ezxeGTxQCwWk5kkwWCQrq4umakg0DNlSoi5COHr9NbYPUl0IIJWA3f7t2yAaccQ9VhgDqx4egIAJ928EhYZ+R038e1Z/2S+8iBg2/ulDnjVxafDjmYSm/ce/XhY5mOTMgamfIcVH0zgH8P+h7soheuuTwlab/Kx4ugJFFKH9f9UQIXRClRshvPG8q6ygRfV8yklFQTz8hQjmmpYmP/rVEFCBfx11sV782q/nlAUhebmZsLhMDabjfHjx+NwOEgkErS0tMiyx9raWnbv3o3FYpElrKJixu12U11dzfr162XJq7Ayo9EoFRUVbN68mc7OTqxWK2VlZaiqSl1dHRs3bqSlpQWn00koFGLKlCkykCGqtgKBAOvWreOzzz6jtLSU4uJimpubqa+vlxU60WhUpv+ky8odaYQqzk1E/K1WKx0dHYRCIbxer5wBiEyNZDJJbW2tHAdRFpxebQXI6qjCwkLZdUGI34TDYQoLC1FVVQa4qqurZasWIdxSUFAgrVy9Xi+tWZECF4lEZFBN+OcB+QAwGAzYbDa8Xi+NjY29rNl0DESq1QDaVLXwyDHQaYMTYePT4zmfv8NtFiDOt2tfSfWkesyWSuoHeNMF98OkcZ/t28wjk2De32H+d2ARnB17k/aVBanKp3mkEvp9cPbSvZ0AfgEsV/Z2FxibWvb6Mczc/QrugrSolhugFV7em0crif0AeIRUilVN/7a8HQxYvnw5M2bMIB6P09LSIkVOEokElZWVcuq2adMmNmzYgN1up6ioiFgsRkFBAX6/X9Z7b9u2jfb2dpLJJIFAAL/fL+XoWlpa6Orqwuv1Skuyurpa+uEaGhowmUxSz1VYseFwmPb2drZv305NTY10LbS0tMjPhWsiPbFd5E+KSPXhhs8jDfHQc7lcJJNJTCaTLA9OJBKyjbTf75dyjd3d3bLKSZBje3s7nZ2dst2K1WrF5XIRi8WkAE5XVxc7duzAYrFI9SnRn2zFihW4XC6Ki4ulz1a4Zbq6uti6dWuviilRiCCyOdI7DghLOhQKDbprp6gHSeOK4uvnXbuA75JKgXoG+DmMAza1wjxvahodJRUA8pB6HyAVnOokFQ86c++yl0kFvZbv3XQnKQtzby+rDPHpKKn+Uwb2TdWXI4sFaAGe9KVez/el0qXSMQ5SCVx94Y20DX05qKrvS2+jv/1JF154oZwCCtk9QYzCgqivr6elpUV21xRanfF4nNraWlpaWjKivqITq6qqBAIBIpFUe3CXy4XL5ZJWjyBhEfXPy8tj5MiRRKNRmpqaUBRFkmgkEpHBEhHUEDmw4vvCQrXZbLS3t8te9l+mE2t/WUS5ubl9Tmf3t/2+loupstVqlXmpBQUFjB49WvohFUWRIifBYJBgMEhDQ4O0/EVmRyKRoKKigrKyMik0PmLECJxOJzqdjsbGRrZv3044HGbIkCE4nU5sNhtFRUWsX7+elpYWWltbpa6D0+mUQUa3200gEGDDhg2Ew2FZ7ioi+0IUR7gIxPlGIhGcTieRSESWMovPBQnvb3zEb0Gn0+FwOKis7F8jaAAt1Q7gUeAc4Gy4DqgBNvnhkVqYcAysU2GHkiLS0aRSmhLAIxvAcEyqVfU44M17Yd2tcOLeTT/yAjAN5uWnyDa9WmBRJawrh2WtqdLY0T0O62zgyRtTr6eQsnQz8Ff2mc7p2EJ/EepgxapVq2QteXd3N01NTTJPVFFS/eOHDh1KNBqlpqZGlhwCHHXUUZSXl7N161bpe/P7/TQ2NpJMJhk6dCgWi4Vdu3ZRV1cnk8SFlur48ePR6XRUVVVhMpkYMmQI7e3tNDY2SuUp4acrLCyUQiFCVk4o3fe88URGQU/F+cGAg30o9qX2D8gsh2AwKDUVRB4vIElLPCRzcnJwuVyyzbgIYAlZwKysLEmM6YUcXq9XlpiKYKUg9GHDhpGTk8OePXtkWpyYNYgHsgg4ulwuotGofNAKdar0FDtAtoCJRqMyV3YwBRkHkFTLYNocaAD3ugZM5j0AzGUJdRTyTzws4FdcX/cMLxWdx0zj3+EdYDWMURMsZDoznP+CNz8lV70M2CO33DzjOynee6QREvkQgNznU5+b70uwPaTwoH0+P1NmwfITyG1LfdY89agUUW/aO+VflvrL/SRt2/dP2/d5Opbnw9JpsPxeINJ/wzSIcNJJJ1FcXCynZqKmX0SNRYsUVVVpbGykqqqKtrY2CgsLGTduXIYf89hjj6WxsZEdO3bgdDoZN26czCVVVZXjjz8em81GIBDA5XJRWlpKIpGQNedjxoyhra2NVatWUVVVRSAQoKamBo/Hw9FHH43H45HE2tjYSE1NDW1tbTKpXSSxe71esrOzj1i9VZ1Ox1FHHUVBQQGTJk3CYDBI/Qbh9ojH47hcLmw2G3l5eeh0OlpbWxkyZAgul4vOzk7Z5gZSs4R0sRW73U4ymcRut5OXlycFxI1GI6WlpeTl5TF8+HBpUcZiMenfrauro6ioiJEjR0p1qqysLBKJBLW1tVRWVspCgHRSFW6LA/lTPw+Hytc6gKRqhWWVQDm1FGOvSw1Yc5GDT5nEM8r1PKz+iBuuWpySAxTT8Hmw5ZyJzDjzXylJv6Uf0lz6oxSJjt7795jYxzJ4LA7k07zyWyyrPIFpv1yFdcdeMWwq4S54iUvx0Mbpy97DbyiGm8Nwng1e3wzLx/IKFzGlbg0ACvu5EFNI9bWafAKwgSNNC2DSpEny5gQyOnOKVBrhnxRtpUXzuOzsbFwul1SjcrlcuN1uWapqt9tluWpRURGRSIThw4fLnkiipj+RSFBeXi7zTk0mE+Xl5XR3d0vrJjc3VypcpQdYwuFwhrydiHBHIhHMZjNnnXUWH330kUznOpzQ1/RWWORiZjF27FgKCgpkcE9EzNNzPIUlKVqeCItUUZSMQg3Yl+gfDAZlq5bS0lJZiJFuDTscDlRVlSLYohqrubmZwsJCIFX2LCxbgJaWFmpqaqQ8YFdXlzxPEbyy2WzSaj0QqX7VwaqBI9XbvgOTQT1JgbSZ14msZJfyKpwJWy6dCG9+Cqsnpfyk80i1NnnVBzP+D7gSSHBN9e+YqsznSfUNIlj5w6xp/B1Y8KSa0haYAMc/+B9u4TeceuebzFHOYZn6B55ZdT28CtN+vwrmqQxRt+JUK9j9f6NTftpXx8L9MHXKLXQFZmEMfc45WYBN0+DsaVDj69fhGmg4HA6cTifZ2dkZVTQdHR00NjZSWFhIVlYWgCxNTRctjsfj7N69m+rqakaMGIFOpyM7O1uWtIr8V1GTnp+fD6RIwWAwyPUKCgqkn0+n05GXlyf9hyIQk5OTI/19nZ2dtLS0YLFYpIBIeouPrq4uWltbcTgcR1QGAOzzmXq9Xply1tbWJmv1TSaTJDjhpxRtUERqHKQeSAaDQV5PkaomiEp0VPV4PPJaC5UpkbaVTCYxGo2SpIWVLPKXRb2/y+UiEonIUmLxAEz3g4ptiLLXwfYgHPCMyniq220PwrJy2dt/4v+1z6DipXMoU26AAp+U9FMVBYV74JISeDkbaGcHME1JVUP9XWzGAxe+9zzfZzFrlbfk1quAxWfcwOK7b4AZEJ8O/1JP53xlKn9W1/Hqzy+i+uelXMGz3DCjDEfnDzGGQD2Ybq9R+lZ8OcwRCoVoamqSMnwiLSmZTMqI/MiRI7FYLLKKStxsIvlcRIJFWpOwesS2hKCy2WyWEV1x48C+unNhaYmghtfrlYQp9AeEyLKosBJCMCKCnF4XL9SzjgT0TIK3Wq1SRb+9vV1mTDidTiwWC8FgUJJdOBzG4XBgMpmwWq3SOhRZAELQRPhSRRGH8L2KB5vI8hDriiqo9Mi9qOMX1yoUCskUMKEV0dHRIUm1Z44q7MvB7XneA40BJ1XTHBU2wS+2/4wsAnuXTuR5ZTvwVz5W99bTN9wLd6VrYE7bS7L7919++9tL+evvZvPqBZeztsdnvnfZF9gCfGe8C7f9m8umKFzyj79hWqeyYpob+Dsee4Bf2m/nru/ffeCTiQKTlwJHnkCHTqeTau0FBQWyJFEQXGNjI8FgUJJgVlaWTOx3uVwZqlIFBQWy6kZYh+LGttvtGXXg6cLIQvwakDeuWCYKEcSNLmrWW1tbqa6uZs+ePXKaKJLGhSCLzWYjFosNuLpRfyC9Vl5UVBmNRqltml71JjIl0psnivbRYlxEVoXIK+3s7MwoGhCpWcJtEIlEiEQiGR0ExH9RFCLeiwep3W6Xvm6TyURNTQ1VVVX4/X65rnAtif+ioEMIXQ+mWcbAkuocoLMSeIa7/nF3Kn3qRIAw8CEQZ6byI/6gPpf5vZEwW93AUuUE5qsBHvzdz/bWR2VinHIF47gC3/zPPxTfu3DHuwo+wHcxYAJh89Yoz3EXJiAOyw4gbnwXpAj1yOsGYDKZaGtro7m5meLiYqkulUgkyM7Oprq6mlWrVjFhwgRKSkrIysoiOzs7QyO1rKxMKlu5XC7i8bgMXonKKBGAEFN5QbxiKiokAAUpCktHBKUAqR+6a9cuampq2LhxI7W1tTIq3TM63tLSwrZt2/Z77ocj0q02oTYlou6i/YnoFSX8q0JkRUgCCvISqWmCQMVMQ5CcmOaLXlTp7iEBUY6cLucoLNi8vDxpacZiMdrb22lra5PXOF0URuxfp0t13BU9rsQDsS9r9euT/D+OVK7ppg+BbJgP8BqsnAa8QqoHVRW56ii2MQq38jP5VR9wrXINS86/hoeU1PuJwIWXqDJ/9Y6z+54KZAM3zVOhBtQqBZaAcm+qFFVgAcAiGKeeyyblH8BM3NFs2mcYU0UF6ZgDrG6EOfl7+1YdeYQKKTWoSCTChg0bpFK88NWdfPLJVFVVsWfPHiorK8nOzsZms0mlfzFNs1gs5OfnS2tTVNyIIIbIzxR5lMLPpiiKvKnFTSOm7emJ+yKPta2tjZaWFqmhKhLa04M04sYOBoPU19cPzKB+BUhv1Cd8leKaCAtfEKQQpRGaDrFYDEVRMsZaNAQUhCryjYGMfGCxfaHXKtraCCtXrC/6jylKqq2K8HOLwg/YVwhQWlpKR0cH9fX1GcEwyEwjG2gMHKn+Ze9fYDZMgYnbl7Nm1QWo/1RQTtlbpz9LpVl5kUXzb0ct/xm+SvDNht1LcoGUTfijdc34jturC7UMJjYvZ82nU/D9L/h+23u3Rkhtex4sPGM+f+AGzlryN2KY+R7P8p3YC5xufpcF991BI/nMYQw+9Rm2Morn+UHmxnaQIlReg8VXc6RF/NMhAjmVlZVYLBYZXbdareTl5WG1WmVgKBKJ4HA4ZEAkGo3KYAcgp5RdXV00NjYSi8Vkmw4gw5oSSE+nERF84dsTiMfjhEIhWltbpeiyKJcV3xNBGHETCsI90pBOdA0NDRlVTsICFSI5wsoUAR8hrSgIUHQyFZ8JV4AQnRb7EeulC+EIf67wfYoqNrEN0Xk13a0jXBbpojyiektkJlRXV8sH7f7OXeCrjv4PnErV62+k/juA4bBG+Q/MhkkLPkCtUGDWX2GewlmqBUaDujq1+s+W/JKy3bWUPddEmXIDynEfcJsI/rU8yhrlHZgF59//YsburKRquLIB/hKGM8P8TJlCze9G8FbuhfxH2cxVynM45ib5WFnJr/kVZ/IO56lHczl/Tm3kzU9TBQqJvX/LIVXAUAt9OiCOHKxevZrs7GxMJhMtLS3s2rWL6upqqd6u1+ultSn8nSJoEY1Gqa+vZ+vWrWzdulUKd0DKCmlvb6empkY2FRS+1L7IMx6PEw6Hqa6upqGhQSaAi7JUkeCf3tra4/HIyLTYtpjKHomEKiCscp1OJxvpARndGsTDJt1HLazNdP2A9PWCwWCvdieAnFH05QsXr0X/MUAqnAl3g/CxppeqivQ78UBsbm6WWhM9dVTFcQ80Bl4yOwrs+JSJ6qmwA67jcXzzQL3/EjDAW8ox8A7oblI5B/gOf4H7jTB7O3Ay8A432RelwlWW64GLYce9vXZz2xyV/52lMusSFXJs4LGB4dswfxm0PEGqpCuBWqSwSf0jAMV1fv5eN5MRdTV7t1KVItPbgAlLU2leXxNUV1czYcIEjjvuOEaMGCFzEoVIsEgqLyoqkiInghQBmatYWVnJzp07CYVC0joVQTCRGSCi8emiyaJflagv37p1q/SRinWEhev1ejPahYgbWwRixHT2SCdUcd7p1qnImBC+bCG7KK6VwWCQ7h2RiZGuewupklbhPw2Hw9JKBeQ4p2dpdHV1ZfhHRX6w0AAQMxexLRHoEg0eRRpfIBCQ7a3TU6sGm/L/AAaqalI1+FGAMtas98I4uHr+Um5VffyMJOrdCsoEFV72AS4MwP9TtvMZCkffrIJlBNz1IX/88U08Pm4+f994Buff+G8oOwZ4Se7J9y9YcBWoqzL9rCZzO/EcK3AM16uP8egvf8LP7vwlCz/9NSdNeleuN6noA9ZcPyVVwlrGXjLdnVZk8PVAQUEBHR0ddHd3U1hYKHvJw77mbyaTiXA4LNNxxI0k1m1sbKS1tVVqaIqumna7XVo3wooSN7u40UVOYnNzMzqdDrfbLWvXe6ZIxWIxWltbpQ5rKBSSwa9QKCQDX4MRXzY9KF1zVKSyCQFuoQ6WbqWL65ROrsFgELfbLd00Ipc0PSglrrPQg4CUSIpQvkpvgxIKhaQ4tsgQEIHKeDxOU1OT1FbdsWMHwWAQr9crc17NZjO7d++WD910ub/BYJ2mY2BVqiruZah6HmGs5LOd9RUnojymQjnwJiR/poenM781Bji6QoXRb5CazOfDIh/8A87P/Te0bIbZY/n7FTPZnNoL1561CGpSIijKJypUQclN24krLwAR3NGZXMKP4U4I4OH6SQ/wfZ5GtUB59hZ2K+2pbgMz9h7EbcB553OkT/l74tFHH+WGG26QSdqib1FTUxN+v5/CwsIMy1AEG8Rr4Werra0lEAhgsVikyr/QP00vZRX+QFVVyc7OBmDbtm0kEglZBABILVcRTGloaOCzzz5j8+bNUsNVuChUVZUW0mDHwZLr/shFBH02bNjA2WefjdFopKOjg7q6OpmCJvpLCcswXcxaPECFlZiTkyN93cLnme4CEL2tRNmqSK8T118IXtfV1REMBkkmkzITpLW1laqqKurr6+UDT4iwCFIW4yGsU0HafZ37weBQ5bUObEpVzq08xlTqKGLOj19IpVRNeQPogNEn85vRd+xVkvKhqwlRW/C/bFJvTyUGEAbfOZBzAszzpdabAd33Ho3uQRXlrntg3K3gg7sUBebelNrnk0AFjLxpKzXzrmbow5+xw1+IzvIZUgqQ7WxUxzM3+0l2Kw3w5LSMnFbKAPIP+fAMNqxevZr33nuPa665RvaL9/v9fPLJJ1itVoqLi6X1IVKfhHXT1NTExo0bWbdunfwsXQzZ6XTKAImoBBK+v927d1NZWSmrbYYPH47dbqe5uZnm5maZb5qbm0s8HqeiooIVK1bIPEdB8kajUa5/pKInwQorMBQKMWTIEAwGA1u2bMlQsBJI92On95sSaUywT4RFkLL4nlgeCASkBZtOquJ4wuEwDQ0NdHR0yAeny+Wio6ODSCQi82CFW0dISgYCgYyuE+IBORiv5cA6I1re5qzrP+A7oRdRb1dS02sMe/+MUp4vN76HXxc42Ah0Yd6b9P/tVDuVxcBcX2p7T7aiu0+FCoAIeGDMt9dwT2cTPFnDCUXL5K7/XXc+zIJdtx+NbqEKbEm5VdcBs0ewvPRbzDn/BSiblkmoib375O1DMiSDHUK0WKgf7dmzh6amJmw2m7QeRMvpdPj9fjZv3kxra6tMNk/vNySEiYPBoFSZVxRFTvFDoRBms5ni4mKp+i+k6lpaWmhsbKShoYE9e/awa9cu4vE4eXl5svGfEEk+ktGX5SUCfc3NzXR3d1NWViZzPBsaGuTsQDzA0gNAIvqfHjgCZA6rcCGIaL8Qj45GozIYKfyp6a6IZDIp82YjkYi0TtPLkMWsQ5yDOB6B/Vmpg4FkB7ii6kN47EOsjwkrsQMmf4tjP1nJeuUN2FQFXE+z8j6/oBooASUMNVEoscDr8G11KVYibFYAXoR7UsErAJb72KKMB15DrV2AcrUKE4Bl8FnRULgVWLo59T2KUzoBrwM1HTDNlSLZADBu7/sAsG4ZR6JgysHiL3/5C8cccwyJRIItW7ZQVVWFzWaTU0PhJ62vryeZTJKbmyvTqyKRCF6vl2OOOQa73S5l3RobG4lGo+Tl5ckbUKgb2Ww2cnNziUQisuhA3Mgej0f67FpbW1mzZg27d++ms7OT0tJSCgoKSCaTUiKwsrJyUNx0hxo9zzGRSPDxxx+j0+k4++yzKS0tpb6+XlZZicqpjo4O2d9LFAGIoBPs6xkmEu7FjEKsI/Ja07MvRBWV3W4nGAxKaT/Rqlzo7Irv5ubmylbiiqLI7BJRhpyuqTpYLdUBL1NNYTfcPxbOdsHNsP72E2H5iSkfpg+4f3ZqtdFAgw1KfKQUqq2UUs2iX97OkgnXMG9tkH+TYIsyBNi4d9t7//8Grnnid7zG+TTc9TrHta7l2CUrWc+JKTL1XI36WeqJPL3oVd5SLoCAAusagUczha6/xohGo3zwwQcce+yx7Ny5k7q6OoYOHSoJtb29nY8//piNGzdiNpsZOXIkEydOpLi4mNGjR1NbW5sRUS4uLsbj8RCJRGSvqIaGBiklKKxeYQWLAJTH45G960Vu49atW2loaCAnJ4e2tjYpbB2Px9m8efNAD91XDmFhdnd3097ezoYNG3A6nQwdOlR2AhBBQzGd3r17t5QCLC4ulj7U9BbVokAjvR4f9qVwiRJX4U4QBQeCIB0Oh3zQdnR00NraSn19PfF4XPpz0/UF0suTxX76wmAh2EFCqqvgL+ekptnzgPMa+XThaUx6bDO8Ssp6hJRYdQ3cvrabhf+eAmf6mMCW1Ge/Aq9yK5snAHszqpQVakrRCuA/UKjMp+H1mwA/8RYX60tOTFVSVfh4atTlUJdadSG389aEC2Gd79Cf+mGIV199lebmZsrLy6X4c2NjI9nZ2Wzfvp13332X3bt3y2T+8vJyvF4vubm57Ny5U0aWjUYjJSUlsjzR7/dTV1dHe3u79LGKih4xZYxEIlRXV0vVKUEcQoDZYDBQVVUlVZK+jujpVxWpac3Nzbz99tvccMMNlJSUkJeXR0NDA4FAgGAwiMfjoaqqClVVZbcAq9UqA0WhUCgjJQr2Cd6kayqIqbtwMYTDYbKzs6WYeFZWlszSECLYnZ2dtLW10djYKP2m4tjFA1UEML9McOqrwCAhVWC1D6YMh+tmgyefScpmQIWX0/xEOcDNy1g499dw5hvALcxRIsD/ofAW6q6zoB1eOA6+M469faj6QjGMXgbUwITZnDfqJX5Q97z89EnmwrrXDsVZHhFQVZU9e/ZQWlrK0Ucfzfbt21mxYgXbt2+ntraW+vp6GeBobW2lpqYGt9uN3++nra2NyspKkskkJSUlsuJG+E+bmprIycmhtLRURvfFTSzU44WAsugOKtwI7e3tMtihoXcrlmg0Snd3N3/4wx848cQTOemkk7DZbHz00UfSWhS+bL/fz6ZNmygsLJQpTELpKx6P43Q60ev1bN++XWqhCr+6UPSPRCKsXbuWcDjMsGHDiMViuN1uVDXVOsdutxONRmUrFeE6gn0tqNNlHXuSajr+G4I9AkWq+8IOeMwH/ARWusDRw/E+GVg0LSVaPfmcVJM9hw1afgw8Q1n5FnaPGM2F6vN85/nL4fL91eFPg3tGpIJS0d6f6kmwt6BVw36wZ88e9uzZw6RJk+RNuHHjRmmNZGdn4/F46O7u5pNPPmHLli00NzcDUFdXR2dnp0zoF9aoqJopKyujrKxMWqJCZWnjxo2y3HXUqFEkEgkaGhqAfSWqgUBgoIZkUKFnOpZ4Lchx06ZNWCwWxowZQ3Z2NrFYTKa3pSf5i1JkIR3Y2dmZkU4HKT1VkRtsMBikTzQSiUj3ws6dO3E6nRmSguJ6i+NTVTUjQCWs0/Sy4r7Oc7BhcJUiSDycIsx07CAV7fcAswALuAMNqTr+ZTbguzzDlfx1+//wt0svgweAs42wycdE9UwoAt/JpIiUjhRB/wIwwEfJb0qtVNUCS2LfA1Yd+tM8AvDpp5+ybt066QMTPrWsrCxZthoMBlm7di2BQEBaoA0NDbLUtKWlhWg0SmdnJ+3t7bKSJ71GXVEU9uzZw/bt22loaKC5uZmOjg6pvJRIJMjNzT1idFH7Cz1JR0Thm5qa+OCDD4jFYgwZMoRRo0bhcrnkdLykpER2V7Db7ZJ4a2pqCIVCsuJKqI6J/GRhqYqofywWkw0Z29rapHi5OJZoNEppaanMKIF91mnPYFRPK3UwEioMOktVIA5zX4P7L9ibZkUqaPUY+9SkboYF5juYz93wCy8UuJh22aqUX3Y58DhwYQe8+QBrxvlQ7kq7AHMnpRL4FwMngt+wGV1VF+6CVtpr8sG74Cs6zyMDQpR67NixVFVVAciae7fbTW5uLsOHD5c93/1+P6FQiK1bt6LX62VpqyDS9vZ2KXIsbi5h+YrqqJ07d2b4VUU6jkaq+3CggI5Qrnrssce45JJLmDBhAg6Hgy1btuD1ehk/fjxNTU3yOnZ3d1NRUUFraysbN27E6/Vis9lIJBJSL1fkHYt0K/FZZ2enLEFNJpNkZWVRVVUlszba2tqk20H89az2GqwE2hcGKakCrIGbjZBzTsqqBHgSJn6ynPeSpwPg9MdpUb3c9X93pyzWRZtTylc5Y3nigtmIVqiOlc3UWooBCOttFN4cSJFzJ6neUvd8C+6HdgpS29HwhbF161Y8Hg8XXHAB27dvl6WFDocDt9uN2+3GbrdjMplk18zKykrq6lLRQZvNJm/gPXv2SBEUkbgvpOGsVitGo5G2tjaCwaDcFsDmzZsPm2qpQ43PK+EU1VbxeJzly5cTiUQ499xz0el0cmovkvvj8Ther5e8vDwZrV+/fj0ej4eCggIZSBIBSPGQ6+rqoqioSOqjijzkXbt20draKjtBiJlKuibqV0GkR2ZF1ediFcwJw6a9if6rYY0yETddQCWnqltZVncOd835FTxpgZVjUyRZANdctITb1V+xUDmJTod973f2ogB4BJjwKTKnVcOXxscff0x+fj6nnnoq69atIxKJ0NHRIev4A4GATNzPycmhs7NTNncTEWEh8VZRUUFeXp7UBhDrCSFls9lMS0sLdXV1BAIBmpqa2Lx582Fl0XwV6Is4BGmJ6XZNTQ0Gg4FLLrmE4cOHy/FuaUlZGOldAUTHh9bWViKRCB6PR07j6+rq8Pv9mEwmVFWlra0NRUm1LjebzVRWVtLY2EhjY6MsHBBZHaJ66vMs1MPh+g5yUgXYnSLKu4BpwKa9DvJ7yvnPSeUo89VU4Oo6UjKCBuARUEcodCSNLKQr5Z+dTUq2D1JVUWcCrOFIbSc9EFBVlddee42LL76YsWPHsnPnThmMEK08YrEYdrtdVl6JZeIGslqtuN1u2SpDWFOiFYrdbmf9+vVUVFQM9Oke9hDkKspA//nPf1JQUJAhsSfcKq2trTLQJNrWQKp3WTAYxO/3s2PHDpqamvB4POTn59Pe3k4wGKS7u5usrCz8fr8sYwYyep2lH09fhHo4kKmAoh7k0SqK7xAfyudhOOBNe39Oyi+a/rGDFHHe/BopWcAE8AIwghSBHj6q/Krq+9LbOFTTm89DYWEhZ555JhdffDE7duzA7/dTW1srLRO9Xi+DIPX19ej1eiZPnsywYcPQ6/XU19dTWVlJS0sLL7zwArCv3BIYtFP8/rrxc3JyZAS8Z1pUfyI9AGS1WqWrRgSaYrEYWVlZfOMb36Cjo4O8vDzC4TB1dXU0NTXJdjdFRUVytrB161apAyB8q6ISq62tLSMYlS7flx6cOhT5qD0JWgTVHA4HlZWVX3r76TiMSPXrhcOZVPuC2Wzm4osvpqOjg/b2dtk5VSST5+bmUlRUJDsFvP3223z66acDfdhfCIczqYrqJ6HZIPykLpeL0aNHEwgEcLvdsuZepK5Fo1FZjtrV1cWuXbskMQpVMnGNBcH21Gfty//b3wn+GqlqOOJI9euAw41Ue243XVoPkH5U0aFWrCOKAcTxpb8W6W3CChXklX4+PX+XPYVS+jq2/jpH8fpQkuph4FPVoEHDoURPi1FAVGGlyyf29T1BxoI4RUFHz+0d6AHxVUT6vyq/rEaqGjRo6BPpKU7p1qZAXxVb+9vGgV739X5/yw4HaKSqQYOGAyLdB9qXBdoTB1Off7gS5sFAI1UNGjQcEIIke073+1ovHV/GP3o4k65Gqho0aOgTfU3Rv+iU/8vu83CERqoaNBwGGCxk09Ni/bLbOhKhkaoGDYMMPaPkgy01Lj2AdbDrfp2gkaoGDRr+K3wdCfNgMEj1VDVo0KDh8IRGqho0aPja4VC6VDRS1aBBw9cC+6sc629opKpBwyDDwaQtafjv8FWMrRao0qBhkEGv1++3zr4n0oNFfWUN7O/zL4ovEvHvbxyKgNihPA+NVDVoGIToWb20P2LZHzn091R3IC3mQ/EwOJSpahqpatAwyNCXSLOWvvTl0HP8NEtVg4avEYQOaXrTw/T6e41g/3ukk2lfylv9AY1UNWgYZEhvLdKTVDV8eaRrvx4KaKSqQcMgg9lslr28+rtXk4Z9Dy29Xn9IyPWg26lo0KBBg4bPh5anqkGDBg39CI1UNWjQoKEfoZGqBg0aNPQjNFLVoEGDhn6ERqoaNGjQ0I/QSFWDBg0a+hEaqWrQoEFDP0IjVQ0aNGjoR2ikqkGDBg39iP8PDmN37m73C44AAAAASUVORK5CYII=\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -768,14 +880,62 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|████████| 2/2 [00:00<00:00,  3.20it/s, kld=237, perceptual=0.37, generator=2.35, feature=0.176, discriminator=2.37]"
+      "100%|███████| 2/2 [00:00<00:00,  3.01it/s, kld=203, perceptual=0.336, generator=1.99, feature=0.078, discriminator=3.71]"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 9/100\n"
+      "Epoch 21/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=174, perceptual=0.353, generator=2.58, feature=0.0856, discriminator=3.15]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.24it/s, kld=114, perceptual=0.274, generator=2.73, feature=0.0881, discriminator=3.83]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 22/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.21it/s, kld=195, perceptual=0.36, generator=2.49, feature=0.106, discriminator=3.85]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.47it/s, kld=141, perceptual=0.343, generator=2.38, feature=0.0823, discriminator=3.8]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 23/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=407, perceptual=0.355, generator=2.13, feature=0.0831, discriminator=3.37]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.19it/s, kld=190, perceptual=0.316, generator=2.47, feature=0.108, discriminator=3.25]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 24/100\n"
      ]
     },
     {
@@ -783,24 +943,1327 @@
      "output_type": "stream",
      "text": [
       "\n",
-      " 60%|████▏  | 9/15 [00:04<00:03,  1.87it/s, kld=194, perceptual=0.35, generator=2.63, feature=0.156, discriminator=2.57]\n"
+      "100%|█████| 15/15 [00:06<00:00,  2.18it/s, kld=380, perceptual=0.375, generator=1.69, feature=0.108, discriminator=3.62]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.01it/s, kld=234, perceptual=0.348, generator=1.86, feature=0.103, discriminator=3.33]"
      ]
     },
     {
-     "ename": "KeyboardInterrupt",
-     "evalue": "",
-     "output_type": "error",
-     "traceback": [
-      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
-      "\u001B[0;31mKeyboardInterrupt\u001B[0m                         Traceback (most recent call last)",
-      "Cell \u001B[0;32mIn[22], line 36\u001B[0m\n\u001B[1;32m     34\u001B[0m optimizer_D\u001B[38;5;241m.\u001B[39mzero_grad()\n\u001B[1;32m     35\u001B[0m loss_d \u001B[38;5;241m=\u001B[39m loss_d_r \u001B[38;5;241m+\u001B[39m loss_g_f\n\u001B[0;32m---> 36\u001B[0m \u001B[43mloss_d\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mbackward\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m     37\u001B[0m optimizer_D\u001B[38;5;241m.\u001B[39mstep()\n\u001B[1;32m     39\u001B[0m \u001B[38;5;66;03m# Store\u001B[39;00m\n",
-      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/torch/_tensor.py:479\u001B[0m, in \u001B[0;36mTensor.backward\u001B[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001B[0m\n\u001B[1;32m    432\u001B[0m \u001B[38;5;250m\u001B[39m\u001B[38;5;124mr\u001B[39m\u001B[38;5;124;03m\"\"\"Computes the gradient of current tensor w.r.t. graph leaves.\u001B[39;00m\n\u001B[1;32m    433\u001B[0m \n\u001B[1;32m    434\u001B[0m \u001B[38;5;124;03mThe graph is differentiated using the chain rule. If the tensor is\u001B[39;00m\n\u001B[0;32m   (...)\u001B[0m\n\u001B[1;32m    476\u001B[0m \u001B[38;5;124;03m        used to compute the attr::tensors.\u001B[39;00m\n\u001B[1;32m    477\u001B[0m \u001B[38;5;124;03m\"\"\"\u001B[39;00m\n\u001B[1;32m    478\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m has_torch_function_unary(\u001B[38;5;28mself\u001B[39m):\n\u001B[0;32m--> 479\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43mhandle_torch_function\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m    480\u001B[0m \u001B[43m        \u001B[49m\u001B[43mTensor\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mbackward\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    481\u001B[0m \u001B[43m        \u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    482\u001B[0m \u001B[43m        \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m,\u001B[49m\n\u001B[1;32m    483\u001B[0m \u001B[43m        \u001B[49m\u001B[43mgradient\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mgradient\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    484\u001B[0m \u001B[43m        \u001B[49m\u001B[43mretain_graph\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mretain_graph\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    485\u001B[0m \u001B[43m        \u001B[49m\u001B[43mcreate_graph\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcreate_graph\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    486\u001B[0m \u001B[43m        \u001B[49m\u001B[43minputs\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43minputs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    487\u001B[0m \u001B[43m    \u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m    488\u001B[0m torch\u001B[38;5;241m.\u001B[39mautograd\u001B[38;5;241m.\u001B[39mbackward(\n\u001B[1;32m    489\u001B[0m     \u001B[38;5;28mself\u001B[39m, gradient, retain_graph, create_graph, inputs\u001B[38;5;241m=\u001B[39minputs\n\u001B[1;32m    490\u001B[0m )\n",
-      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/torch/overrides.py:1534\u001B[0m, in \u001B[0;36mhandle_torch_function\u001B[0;34m(public_api, relevant_args, *args, **kwargs)\u001B[0m\n\u001B[1;32m   1528\u001B[0m     warnings\u001B[38;5;241m.\u001B[39mwarn(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mDefining your `__torch_function__ as a plain method is deprecated and \u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[1;32m   1529\u001B[0m                   \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mwill be an error in future, please define it as a classmethod.\u001B[39m\u001B[38;5;124m\"\u001B[39m,\n\u001B[1;32m   1530\u001B[0m                   \u001B[38;5;167;01mDeprecationWarning\u001B[39;00m)\n\u001B[1;32m   1532\u001B[0m \u001B[38;5;66;03m# Use `public_api` instead of `implementation` so __torch_function__\u001B[39;00m\n\u001B[1;32m   1533\u001B[0m \u001B[38;5;66;03m# implementations can do equality/identity comparisons.\u001B[39;00m\n\u001B[0;32m-> 1534\u001B[0m result \u001B[38;5;241m=\u001B[39m \u001B[43mtorch_func_method\u001B[49m\u001B[43m(\u001B[49m\u001B[43mpublic_api\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtypes\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m   1536\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m result \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28mNotImplemented\u001B[39m:\n\u001B[1;32m   1537\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m result\n",
-      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/monai/data/meta_tensor.py:276\u001B[0m, in \u001B[0;36mMetaTensor.__torch_function__\u001B[0;34m(cls, func, types, args, kwargs)\u001B[0m\n\u001B[1;32m    274\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m kwargs \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m    275\u001B[0m     kwargs \u001B[38;5;241m=\u001B[39m {}\n\u001B[0;32m--> 276\u001B[0m ret \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43msuper\u001B[39;49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m__torch_function__\u001B[49m\u001B[43m(\u001B[49m\u001B[43mfunc\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtypes\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m    277\u001B[0m \u001B[38;5;66;03m# if `out` has been used as argument, metadata is not copied, nothing to do.\u001B[39;00m\n\u001B[1;32m    278\u001B[0m \u001B[38;5;66;03m# if \"out\" in kwargs:\u001B[39;00m\n\u001B[1;32m    279\u001B[0m \u001B[38;5;66;03m#     return ret\u001B[39;00m\n\u001B[1;32m    280\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m _not_requiring_metadata(ret):\n",
-      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/torch/_tensor.py:1279\u001B[0m, in \u001B[0;36mTensor.__torch_function__\u001B[0;34m(cls, func, types, args, kwargs)\u001B[0m\n\u001B[1;32m   1276\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[38;5;28mNotImplemented\u001B[39m\n\u001B[1;32m   1278\u001B[0m \u001B[38;5;28;01mwith\u001B[39;00m _C\u001B[38;5;241m.\u001B[39mDisableTorchFunction():\n\u001B[0;32m-> 1279\u001B[0m     ret \u001B[38;5;241m=\u001B[39m \u001B[43mfunc\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43margs\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[38;5;241;43m*\u001B[39;49m\u001B[43mkwargs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m   1280\u001B[0m     \u001B[38;5;28;01mif\u001B[39;00m func \u001B[38;5;129;01min\u001B[39;00m get_default_nowrap_functions():\n\u001B[1;32m   1281\u001B[0m         \u001B[38;5;28;01mreturn\u001B[39;00m ret\n",
-      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/torch/_tensor.py:488\u001B[0m, in \u001B[0;36mTensor.backward\u001B[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001B[0m\n\u001B[1;32m    478\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m has_torch_function_unary(\u001B[38;5;28mself\u001B[39m):\n\u001B[1;32m    479\u001B[0m     \u001B[38;5;28;01mreturn\u001B[39;00m handle_torch_function(\n\u001B[1;32m    480\u001B[0m         Tensor\u001B[38;5;241m.\u001B[39mbackward,\n\u001B[1;32m    481\u001B[0m         (\u001B[38;5;28mself\u001B[39m,),\n\u001B[0;32m   (...)\u001B[0m\n\u001B[1;32m    486\u001B[0m         inputs\u001B[38;5;241m=\u001B[39minputs,\n\u001B[1;32m    487\u001B[0m     )\n\u001B[0;32m--> 488\u001B[0m \u001B[43mtorch\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mautograd\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mbackward\u001B[49m\u001B[43m(\u001B[49m\n\u001B[1;32m    489\u001B[0m \u001B[43m    \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgradient\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mretain_graph\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcreate_graph\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43minputs\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43minputs\u001B[49m\n\u001B[1;32m    490\u001B[0m \u001B[43m\u001B[49m\u001B[43m)\u001B[49m\n",
-      "File \u001B[0;32m~/PycharmProjects/GenerativeModels/venv/lib/python3.9/site-packages/torch/autograd/__init__.py:197\u001B[0m, in \u001B[0;36mbackward\u001B[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001B[0m\n\u001B[1;32m    192\u001B[0m     retain_graph \u001B[38;5;241m=\u001B[39m create_graph\n\u001B[1;32m    194\u001B[0m \u001B[38;5;66;03m# The reason we repeat same the comment below is that\u001B[39;00m\n\u001B[1;32m    195\u001B[0m \u001B[38;5;66;03m# some Python versions print out the first line of a multi-line function\u001B[39;00m\n\u001B[1;32m    196\u001B[0m \u001B[38;5;66;03m# calls in the traceback and some print out the last line\u001B[39;00m\n\u001B[0;32m--> 197\u001B[0m \u001B[43mVariable\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43m_execution_engine\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mrun_backward\u001B[49m\u001B[43m(\u001B[49m\u001B[43m  \u001B[49m\u001B[38;5;66;43;03m# Calls into the C++ engine to run the backward pass\u001B[39;49;00m\n\u001B[1;32m    198\u001B[0m \u001B[43m    \u001B[49m\u001B[43mtensors\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mgrad_tensors_\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mretain_graph\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcreate_graph\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43minputs\u001B[49m\u001B[43m,\u001B[49m\n\u001B[1;32m    199\u001B[0m \u001B[43m    \u001B[49m\u001B[43mallow_unreachable\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43maccumulate_grad\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[38;5;28;43;01mTrue\u001B[39;49;00m\u001B[43m)\u001B[49m\n",
-      "\u001B[0;31mKeyboardInterrupt\u001B[0m: "
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 25/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=207, perceptual=0.345, generator=1.8, feature=0.0924, discriminator=3.78]\n",
+      "100%|█████████| 2/2 [00:00<00:00,  4.41it/s, kld=129, perceptual=0.348, generator=1.97, feature=0.1, discriminator=3.72]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 26/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.21it/s, kld=294, perceptual=0.334, generator=2.76, feature=0.119, discriminator=2.83]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.38it/s, kld=211, perceptual=0.355, generator=2.52, feature=0.123, discriminator=2.9]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 27/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.20it/s, kld=384, perceptual=0.361, generator=2.86, feature=0.126, discriminator=2.7]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.77it/s, kld=164, perceptual=0.341, generator=3.05, feature=0.147, discriminator=2.77]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 28/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.22it/s, kld=257, perceptual=0.354, generator=1.4, feature=0.0816, discriminator=3.77]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.09it/s, kld=173, perceptual=0.356, generator=1.36, feature=0.0792, discriminator=3.7]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 29/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.17it/s, kld=166, perceptual=0.366, generator=1.22, feature=0.0643, discriminator=3.9]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.98it/s, kld=92.5, perceptual=0.314, generator=1.46, feature=0.065, discriminator=3.55]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 30/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=171, perceptual=0.331, generator=1.94, feature=0.0693, discriminator=3.74]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=196, perceptual=0.319, generator=1.9, feature=0.0694, discriminator=3.44]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████| 2/2 [00:00<00:00,  3.36it/s, kld=143, perceptual=0.311, generator=1.89, feature=0.0648, discriminator=3.33]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 31/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.16it/s, kld=264, perceptual=0.363, generator=1.98, feature=0.0766, discriminator=3.99]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.75it/s, kld=178, perceptual=0.348, generator=1.96, feature=0.0681, discriminator=3.98]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 32/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|███| 15/15 [00:06<00:00,  2.20it/s, kld=85.9, perceptual=0.308, generator=2.05, feature=0.0725, discriminator=3.94]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.43it/s, kld=55.1, perceptual=0.327, generator=2.17, feature=0.113, discriminator=3.84]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 33/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.20it/s, kld=110, perceptual=0.293, generator=2.17, feature=0.0944, discriminator=3.92]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.94it/s, kld=110, perceptual=0.329, generator=2.01, feature=0.0707, discriminator=4.03]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 34/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.26it/s, kld=203, perceptual=0.329, generator=2.42, feature=0.0917, discriminator=3.65]\n",
+      "100%|███████| 2/2 [00:00<00:00,  2.71it/s, kld=106, perceptual=0.29, generator=2.39, feature=0.0954, discriminator=3.58]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 35/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=282, perceptual=0.28, generator=2.44, feature=0.0842, discriminator=3.62]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.21it/s, kld=206, perceptual=0.284, generator=2.42, feature=0.0789, discriminator=3.64]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 36/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.20it/s, kld=313, perceptual=0.333, generator=2.3, feature=0.0794, discriminator=4.01]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.14it/s, kld=192, perceptual=0.285, generator=2.4, feature=0.0781, discriminator=4.01]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 37/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=101, perceptual=0.297, generator=2.4, feature=0.0699, discriminator=3.96]\n",
+      "100%|█████| 2/2 [00:00<00:00,  3.69it/s, kld=56.2, perceptual=0.279, generator=2.44, feature=0.0671, discriminator=3.96]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 38/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|███| 15/15 [00:06<00:00,  2.17it/s, kld=94.7, perceptual=0.296, generator=2.37, feature=0.0693, discriminator=3.91]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.23it/s, kld=64, perceptual=0.239, generator=2.42, feature=0.0572, discriminator=3.95]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 39/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.22it/s, kld=154, perceptual=0.293, generator=2.28, feature=0.055, discriminator=3.9]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.99it/s, kld=93.5, perceptual=0.27, generator=2.25, feature=0.0545, discriminator=3.9]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 40/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.20it/s, kld=268, perceptual=0.227, generator=2.26, feature=0.052, discriminator=3.98]\n",
+      "  0%|              | 0/2 [00:00<?, ?it/s, kld=371, perceptual=0.264, generator=2.19, feature=0.0581, discriminator=3.92]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████| 2/2 [00:00<00:00,  3.34it/s, kld=247, perceptual=0.269, generator=2.15, feature=0.056, discriminator=3.95]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 41/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=195, perceptual=0.231, generator=2.14, feature=0.054, discriminator=4.01]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.25it/s, kld=128, perceptual=0.238, generator=2.14, feature=0.0585, discriminator=4.02]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 42/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=312, perceptual=0.238, generator=2.29, feature=0.0563, discriminator=3.91]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.29it/s, kld=217, perceptual=0.24, generator=2.29, feature=0.0595, discriminator=3.89]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 43/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=653, perceptual=0.225, generator=2.5, feature=0.0637, discriminator=3.79]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.31it/s, kld=390, perceptual=0.256, generator=2.43, feature=0.0642, discriminator=3.72]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 44/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.21it/s, kld=860, perceptual=0.261, generator=2.38, feature=0.0658, discriminator=3.85]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.70it/s, kld=513, perceptual=0.241, generator=2.41, feature=0.0746, discriminator=3.82]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 45/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.22it/s, kld=422, perceptual=0.282, generator=2.38, feature=0.0676, discriminator=3.99]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.23it/s, kld=325, perceptual=0.234, generator=2.5, feature=0.0701, discriminator=4.01]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 46/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.19it/s, kld=2.07e+3, perceptual=0.257, generator=2.42, feature=0.0706, discriminator=3.89\n",
+      "100%|██| 2/2 [00:00<00:00,  3.85it/s, kld=1.21e+3, perceptual=0.247, generator=2.43, feature=0.0692, discriminator=3.88]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 47/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=338, perceptual=0.263, generator=2.39, feature=0.0861, discriminator=4.03]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.18it/s, kld=248, perceptual=0.246, generator=2.5, feature=0.0764, discriminator=3.86]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 48/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=331, perceptual=0.246, generator=2.47, feature=0.0839, discriminator=3.71]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.31it/s, kld=205, perceptual=0.243, generator=2.39, feature=0.088, discriminator=3.79]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 49/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██| 15/15 [00:06<00:00,  2.19it/s, kld=3.41e+3, perceptual=0.248, generator=2.58, feature=0.12, discriminator=3.76]\n",
+      "100%|████| 2/2 [00:00<00:00,  3.71it/s, kld=2.19e+3, perceptual=0.26, generator=2.55, feature=0.125, discriminator=3.59]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 50/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.21it/s, kld=1.09e+3, perceptual=0.246, generator=2.76, feature=0.128, discriminator=3.32]\n",
+      "  0%|           | 0/2 [00:00<?, ?it/s, kld=1.13e+3, perceptual=0.237, generator=2.61, feature=0.107, discriminator=3.34]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVUAAACFCAYAAADrRWu1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABVdklEQVR4nO2deXhU5dn/PyezZNZM9n0lYQdlE1BB4lb0J7XYKoUWK77uVqu21qXaOra22lp3rVq1YqHV11Jrra22pYiKBZSyIxECZN8zmcy+n98fk+cxCUGxL5iA53tdXGTOOXOW58z5nvu57+9934qqqioaNGjQoOGIIGW4T0CDBg0ajidopKpBgwYNRxAaqWrQoEHDEYRGqho0aNBwBKGRqgYNGjQcQWikqkGDBg1HEBqpatCgQcMRhEaqGjRo0HAEoZGqBg0aNBxBHJekWldXh6Io/PKXvzxi+1y7di2KorB27dojtk8NB0Mb5+MPy5Yto7y8fLhP43PDiCLV5cuXoygKmzZtGu5TOWYx0sYwEAjgdDo1kuzDrl27WLp0KUVFRaSmplJYWMg3v/lNdu3a9X/a789+9jNeffXVI3OSn4J///vfOJ1O3G7353K8Yw0jilQ1HH8IBALcfffdh02qp512GsFgkNNOO+3ontgw4JVXXmHatGn861//4tJLL+VXv/oVl112GW+99RbTpk3jT3/603+978+bVO++++7DJtVnnnmGjz766Oie1AiCfrhPQIOG/khJScFkMg33aRxx7Nu3j4svvphRo0bxzjvvkJOTI9fdcMMNzJ07l4svvpjt27czatSoYTzTIw+DwTDcp/C54piyVCORCD/60Y+YPn06DocDq9XK3Llzeeuttw75nYceeoiysjLMZjPz5s1j586dB21TU1PDhRdeSGZmJiaTiRkzZvDaa68dzUv5XLFs2TJsNhvNzc0sXLgQm81GTk4ON998M/F4XG7X3xf9aeNWXV1NdXX1kMcS/rO6ujpJHnfffTeKoqAoCk6n85DnOpRPtbq6mkmTJrF9+3bmzZuHxWKhqqqKVatWAfD2228za9YszGYzY8eOZfXq1QP2WV9fz7XXXsvYsWMxm81kZWVx0UUXUVdXd9DxxTHMZjPFxcXcc889PP/88yiKctD2b7zxBnPnzsVqtWK32znvvPMOOY2///77CQQC/PrXvx5AqADZ2dk8/fTT+P1+fvGLXww5lv3hdDpRFEV+VhQFv9/PCy+8IMd42bJlA7atqalh0aJFpKWlkZWVxQ033EAoFJL7EPd++fLlBx2v/z1zOp18//vfB6CiokIeb6ixPNR19P+dPfHEE4waNQqLxcKXvvQlGhsbUVWVn/zkJxQXF2M2m/nKV76Cy+UasM8///nPnHfeeRQWFpKamkplZSU/+clPBvyeBcQxzGYzM2fO5N133x3y9xsOh7nrrruoqqoiNTWVkpISbrnlFsLh8CGvbSgcU5aqx+Ph2WefZcmSJVxxxRV4vV6ee+455s+fz/vvv8+UKVMGbP/b3/4Wr9fLt7/9bUKhEI888ghnnHEGO3bsIC8vD0j6uE499VSKioq47bbbsFqtvPzyyyxcuJA//vGPXHDBBcNwpUce8Xic+fPnM2vWLH75y1+yevVqHnjgASorK7nmmmsGbHs443Y4yMnJ4cknn+Saa67hggsu4Ktf/SoAJ5xwwmc+/56eHhYsWMDixYu56KKLePLJJ1m8eDG/+93vuPHGG7n66qv5xje+wf3338+FF15IY2MjdrsdgA8++IB///vfLF68mOLiYurq6njyySeprq7mww8/xGKxANDc3Mzpp5+OoijcfvvtWK1Wnn32WVJTUw86nxUrVnDJJZcwf/58fv7znxMIBHjyySeZM2cOW7ZsOYgM//KXv1BeXs7cuXOHvL7TTjuN8vJy/vrXv37msVmxYgWXX345M2fO5MorrwSgsrJywDaLFi2ivLyce++9lw0bNvDoo4/S09PDb3/72890rK9+9avs2bOHF198kYceeojs7GyAg14Uh4Pf/e53RCIRrr/+elwuF7/4xS9YtGgRZ5xxBmvXruXWW2+ltraWxx57jJtvvpnf/OY38rvLly/HZrPx3e9+F5vNxpo1a/jRj36Ex+Ph/vvvl9s9+eSTXHfddcydO5ebbrqJuro6Fi5cSEZGBsXFxXK7RCLB+eefz7p167jyyisZP348O3bs4KGHHmLPnj2fzbWijiA8//zzKqB+8MEHQ66PxWJqOBwesKynp0fNy8tT/+d//kcuO3DggAqoZrNZbWpqkss3btyoAupNN90kl5155pnq5MmT1VAoJJclEgn1lFNOUUePHi2XvfXWWyqgvvXWW//XyzyqGGoML7nkEhVQf/zjHw/YdurUqer06dPl588ybvPmzVPnzZt30PEvueQStaysTH7u7OxUAfWuu+46rPMfapznzZunAurvf/97uaympkYF1JSUFHXDhg1y+d///ncVUJ9//nm5LBAIHHSc9evXq4D629/+Vi67/vrrVUVR1C1btshl3d3damZmpgqoBw4cUFVVVb1er5qenq5eccUVA/bZ1tamOhyOg5a73W4VUL/yla984rWff/75KqB6PB5VVQ8eS4G77rpLHfzoWq1W9ZJLLjnktueff/6A5ddee60KqNu2bVNV9eN733/cBAbfv/vvv3/AeHwaBl+HOFZOTo7qdrvl8ttvv10F1BNPPFGNRqNy+ZIlS1Sj0TjgGR3qnl511VWqxWKR24XDYTUrK0s96aSTBuxv+fLlKjDg97tixQo1JSVFfffddwfs86mnnlIB9b333jusa1VVVT2mpv86nQ6j0Qgk3ywul4tYLMaMGTPYvHnzQdsvXLiQoqIi+XnmzJnMmjWLv/3tbwC4XC7WrFnDokWL8Hq9dHV10dXVRXd3N/Pnz2fv3r00Nzd/Phf3OeDqq68e8Hnu3Lns37//oO0+bdyGAzabjcWLF8vPY8eOJT09nfHjxzNr1iy5XPzd/7rMZrP8OxqN0t3dTVVVFenp6QN+N2+++SYnn3zygBlPZmYm3/zmNwecyz//+U/cbjdLliyRv5muri50Oh2zZs06yB3l9XoBpOV8KIj1Ho/nE7f7b/Dtb397wOfrr78eYFjv6UUXXYTD4ZCfxb1bunQper1+wPJIJDLgWex/T8WzO3fuXAKBADU1NQBs2rSJ7u5urrjiigH7++Y3v0lGRsaAc/nDH/7A+PHjGTdu3IB7esYZZwB8ootxMI6p6T/ACy+8wAMPPEBNTQ3RaFQur6ioOGjb0aNHH7RszJgxvPzyywDU1taiqio//OEP+eEPfzjk8To6OgYQzLEKk8l00BQtIyODnp6eg7b9tHEbDhQXFw/wIwI4HA5KSkoOWgYMuK5gMMi9997L888/T3NzM2q/Zhe9vb3y7/r6ek4++eSDjl1VVTXg8969ewHkAzcYaWlpAz4LshTkeigcLvn+Nxh8TysrK0lJSflEX+jRRmlp6YDP4t4dzj3dtWsXd955J2vWrDnoJSTuaX19PXDw/dPr9Qe5Z/bu3cvu3bsP6cbo6Og4nEtK7v+wtxwBWLlyJcuWLWPhwoV8//vfJzc3F51Ox7333su+ffs+8/4SiQQAN998M/Pnzx9ym8E35FiFTqc7ovtTFGUAOQkMFSg4EjjU+R9qef9zu/7663n++ee58cYbOfnkk3E4HCiKwuLFi+Vv4LNAfGfFihXk5+cftL6/VQRJUigoKGD79u2fuN/t27dTVFQkSXnwS0TgSIzx4H0fzWMdCv/tPXW73cybN4+0tDR+/OMfU1lZiclkYvPmzdx6663/9T2dPHkyDz744JDrBxP9J+GYItVVq1YxatQoXnnllQE/grvuumvI7YVF0R979uyRbykhXTEYDJx11llH/oSPUXzauEHSyh3KdSCsA4FDPayfJ1atWsUll1zCAw88IJeFQqGDdJZlZWXU1tYe9P3By0QQKDc397B/NwsWLOCZZ55h3bp1zJkz56D17777LnV1dVx11VVyWUZGxpBa0MFjDJ8+znv37h0wm6utrSWRSMh7KqbDg4/33xzraGPt2rV0d3fzyiuvDNAzHzhwYMB2ZWVlQPJaTz/9dLk8FotRV1c3IGBaWVnJtm3bOPPMM//P13fM+VRhoBWyceNG1q9fP+T2r7766gA/zPvvv8/GjRs599xzgeRDUV1dzdNPP01ra+tB3+/s7DySp3/M4NPGDZI/wpqamgFjtG3bNt57770B+xKR9eHMvtHpdAdZ1Y899thBVtj8+fNZv349W7dulctcLhe/+93vDtouLS2Nn/3sZwNcUAJD/W6+//3vYzabueqqq+ju7h6wzuVycfXVV2OxWKRcCZJj3NvbO8DCbW1tHTJJwGq1fuIYP/HEEwM+P/bYYwDynqalpZGdnc0777wzYLtf/epXQx4Lhu+eDsUDkUjkoHOdMWMGWVlZPPPMM8RiMbn8d7/73UFur0WLFtHc3Mwzzzxz0PGCwSB+v/+wz29EWqq/+c1vePPNNw9aXl1dzSuvvMIFF1zAeeedx4EDB3jqqaeYMGECPp/voO2rqqqYM2cO11xzDeFwmIcffpisrCxuueUWuc0TTzzBnDlzmDx5MldccQWjRo2ivb2d9evX09TUxLZt247qtY5EHM64/c///A8PPvgg8+fP57LLLqOjo4OnnnqKiRMnDvBxmc1mJkyYwP/+7/8yZswYMjMzmTRpEpMmTfrcrmfBggWsWLECh8PBhAkTWL9+PatXryYrK2vAdrfccgsrV67k7LPP5vrrr5eSqtLSUlwul7Rg0tLSePLJJ7n44ouZNm0aixcvJicnh4aGBv76179y6qmn8vjjjw/Y9+jRo3nhhRf45je/yeTJk7nsssuoqKigrq6O5557jq6uLl588cUBUqjFixdz6623csEFF/Cd73xHyrbGjBlzUGB2+vTprF69mgcffJDCwkIqKioGBPAOHDjA+eefzznnnMP69etZuXIl3/jGNzjxxBPlNpdffjn33Xcfl19+OTNmzOCdd95hz549B43n9OnTAbjjjjtYvHgxBoOBL3/5y5JsjzZOOeUUMjIyuOSSS/jOd76DoiisWLHioBen0WjE6XRy/fXXc8YZZ7Bo0SLq6upYvnw5lZWVAyzSiy++mJdffpmrr76at956i1NPPZV4PE5NTQ0vv/wyf//735kxY8bhneBh6wQ+Bwg50KH+NTQ0qD/72c/UsrIyNTU1VZ06dar6+uuvH1Kycf/996sPPPCAWlJSoqampqpz586VEpL+2Ldvn/qtb31Lzc/PVw0Gg1pUVKQuWLBAXbVqldzmWJdUWa3Wg7YdLM35rOO2cuVKddSoUarRaFSnTJmi/v3vfx9SBvTvf/9bnT59umo0Gj9VXnUoSdXEiRMP2rasrEw977zzDloOqN/+9rfl556eHvXSSy9Vs7OzVZvNps6fP1+tqalRy8rKDpIhbdmyRZ07d66ampqqFhcXq/fee6/66KOPqoDa1tZ20LnOnz9fdTgcqslkUisrK9Vly5apmzZtOuT1bd++XV2yZIlaUFCgGgwGNT8/X12yZIm6Y8eOIbf/xz/+oU6aNEk1Go3q2LFj1ZUrVw4pqaqpqVFPO+001Ww2q4C8LrHthx9+qF544YWq3W5XMzIy1Ouuu04NBoMD9hEIBNTLLrtMdTgcqt1uVxctWqR2dHQMec9+8pOfqEVFRWpKSsqnyqs+6fkcPJ6A+oc//GHA8qF+0++99546e/Zs1Ww2q4WFheott9wi5XSDn9FHH31UcsbMmTPV9957T50+fbp6zjnnDNguEomoP//5z9WJEyeqqampakZGhjp9+nT17rvvVnt7ew95fYMxokhVw/DiUD/2LzpuuOEG1WQyqbFYbLhP5TNDkGpnZ+dwn8qIQTweVzMzM9XLL7/8qOz/mPKpatBwtBEMBgd87u7uZsWKFcyZM+eIKyg0HH2EQqGD3AK//e1vcblcQ6ZZHwmMSJ+qBg3DhZNPPpnq6mrGjx9Pe3s7zz33HB6P55A6Zg0jGxs2bOCmm27ioosuIisri82bN/Pcc88xadIkLrrooqNyTI1UNWjoh//3//4fq1at4te//jWKojBt2jSee+6547IU4RcB5eXllJSU8Oijj+JyucjMzORb3/oW9913n8zOPNJQ1MG2sQYNGjRo+K+h+VQ1aNCg4QhCI1UNGjRoOILQSFWDBg0ajiAOO1ClKM6jeBoaBkNVnf/nfXzR2lgMN4ZKWf1vMHbs2AFFQbSwx5GFyKRKSUnBYrGwZcuWI7p/LfqvQcMIw+AqS8NdwOR4REpKyn9VzepwoJGqBg0jDJplenShKIok1KMx1ppPVYMGDRqOIDRLVYOGEQZVVQcUAdem/0cW/a3To2GpaqSqQcMIxOE++J+VcL8oroXDGZejNRYaqWrQcAzji0KSnxXDaeVrpKpBg4bjFoNfOoJkj+bLSCNVDRo0fGHweVj2WvRfgwYNGo4gNFLVoGGE4WiJ0jV8PtBIVYMGDRqOIDRS1aBBg4YjCC1QpUGDhk/FoaRJgxMVNGikqkGDhkPgcDSeYpuhtv2iEq1Gqho0aJAYTI79dZ2f1SIdvK8vCslqpKpBg4ZDkungz5/kBvisxzjc7x1r0EhVg4YvOA5FdjqdDkhKvFRVJR6Py/U6nU5arv1TQoVFO5RVe6hl4njHCzRS1fC5obS0lBkzZhCJRAiHwwSDQSD5YBmNRiwWCxaLhVWrVg14gDUcPQxFqAaDgezsbAKBwCEJVZCqWC5IUVVVwuEw4XCYlJSPxUWf5jo4noJdxxipzmLAKS88G5YCbUAN8PhPgcEtLdKAycD7Q6zTcLSQmprKN77xDUwmEw0NDbS3t6PX62lrayMQCBCLxTCZTNjtdsLhMG63G4vFQmlpKd/61rdwu91YrVb++te/StLV6/UkEgkCgQBut3u4L/GYx+ApvaqqGAwGMjMz+fKXv0xnZyfBYJDe3l4gSbZ2ux2dTkdmZiaqqtLb24vNZkNVVUKhEL29vWzbto22trYBpCr2/0XAMUSq34UNaWAbYtU9wFbnoIXnQvoscHtgZxosPTtJvv3hBkKDv6fhSKCkpITe3l7q6+tRFAWv10tHRweqqpKenk5+fj6hUIiGhgb27dsHgMlkIjMzk5aWFhobG8nOzua8887DZDIxfvx4ioqK6O3tZd26daxYsWKYr/DYRX/rtP/fer2e0aNHM3PmTLq6uiRZ6vV6UlNTycvLIxqNsnr1ajIyMohEIqiqykUXXUR2djY+n48DBw7Q2tpKaWkp8XicWCxGPB7H7/fT3NxMJBKRx0tJSRnSd3usk+8xQqppcPkQhBoCFgLFwAInzO5bfudyoAncVXBPVnK7p/p9T+ynDliQ1vchCgSP/Kl/waAoCieddBJ+v5+2tjasVitGoxGASCRCRkYGVVVVFBQUkEgkSElJYfbs2QQCASZMmEBWVhaJRAKdTofD4UBRFHp7e9m7dy+RSIRAIIBOp+Pcc88lOzuburo61q1bd8w/iJ8HDuU7FTOB7OxsMjIyCIVCeDwe6uvrCQQC2O12xo0bh9lsJhaLUVlZSUNDA7FYjLS0NNrb29HpdAQCAQKBAJWVlWRmZmK1WgkGg/h8PtxuN+FwWBIxgN/vx+/3YzAYDumHPRZxDJBqn4VqGmLVbJLLz4FrnnmQB/3fQxcD404VXnICO+DORXDneJikJMn3ze3gPAEuBMqBDd9N7msrcPVrwOajf0nHIRRFweFwYLVaaWpqIh6PY7fbcTgchMNh4vE4GRkZnHrqqYwdO5Z4PI7NZqO8vBy9Xk80GsXhcNDT04Ner2f27NlMmzaNaDRKQ0MDmzdvpqenB5PJxL59++jo6KCxsZGpU6fi9XrxeDx0dnbi9XqHeyiOCQiCNZlMqKqK3W7nhBNOIBaLUVtbi8vlwu/3y20KCgrIysrCZrMxZswYWlpaUBSF/Px8DAaDdOEkEgkcDod0E3i9XtxuNy6Xi8LCQmw2G+np6ZjNZjZv3kx9fT0AsVjsuKl5MIJJdRpUnw+3MfSUfzUQW8uN3vU8rFzMk8/O5MnlapJkywGnE54FmpzJ7Rc6WfCTP2AhwMtKO4T6/LFi33OA+86HN8+HtQDOo3dpxxlKS0uxWCyEQiFcLpd8SFNTU1FVFb/fTygUIi8vj6qqKhRFoa2tjQkTJlBaWopOpyMejxOJRNi3bx92u53p06dTVFREPB4nPT2dnp4eDhw4QEpKCtFoFJfLRSKRwGKxMGnSJDIyMmhtbeW1114bMMXUkMRQVmpqaiqzZ8+mp6eH9PR02traMBgMdHR0EAwGicVipKamkpmZSXZ2Nnq9HkVRCAQCZGdnY7fbSU9Pp7e3l56eHvx+P5FIBKvVislkkvcqEAjQ3t6O1WrFYrGgKAppaWnk5uYyduxYmpubJZEfD23VRyapnuOEq4GqT9hmE5jcJzCB56C8GOqC4AZ1uQKZwHh4u3Em1Us2wktOmn6SRfH3u1l7/yy61B+y5iSSpNofC/r+uYE5dwA/PfLXdpwhJSUFm81GJBKhtbUVnU6HwWCQQYpIJILP50NVVXJzc0lLS6Ojo4O2tjaqqqpISUmRU75wOEx7ezsWi4Xs7GxMJhPxeJyUlBRGjx5Na2sr0WgUo9FISkoKOp2ORCKB1+vFaDRSUlJCeno6HR0dwzkkIw5D+VDT09OZOnUqer2ewsJC+TLs7OwkGo2iqiopKSmkpaWRl5eHqqrU19fT1tZGTk4OZrOZeDxOT08PLpeLzs5Oent7MZvNpKamAhAMBolEIpJso9EoXq+X9vZ2IpEIpaWl5OfnU1VVRVNT0wCZ1rGMEVhQpTrpJ/0kQn0YWAlTHVu5sv43Hy9/Cd7eMpNn/rUU5c8q1cr5fSucFL3ogl86qVa+TgV1n3wK6cCFBpLKAQ2fhJNOOomKigo6Ozsl0aWkpBCPx+nu7qa7u5tAIEBZWRnTp0/HYrHg8/nkdN3v95NIJIhEIuzdu5eWlhYyMzNJTU2Vkp1oNIrFYiEjI0P6WwV5JxIJXC4XDQ0N1NbWMm/evOEekhGFwRZqSkoKDoeDiooKJk+ejMlkwuVy0dLSgs/nkxIp4WfNy8sjOzsbj8fD/v372bdvHx6PR84sxAuys7OTcDiM1WrFbDZLCzUSichgVTgcJhQK4ff78Xq9pKSkkJKSgtVqBRigeT2WMYIsVQNQBU9VJ6fin4RnAyxRX+JanmBu+bvwrAEuBzb8lGplGWAHVEAPL/2H69R/ofxHhQVwyV+eJJdW2LQOaubAuEMc405gVSbgOULXd3whPz+f6dOnYzAY2LhxI+FwGIPBgNVqJTMzE0VRiMVi+Hw+HA4HZ5xxBtOmTaOurg6Xy0VqaqokReEO2L9/P0VFRVRWVsp1brdbPuy5ubm43W4ikQg6nQ6TyURGRgaZmZnEYjFaW1ul9lXDQIiAlF6vZ/r06VRVVVFbW0s4HKarqwu9Xk9eXh6BQEAGlOx2O6NGjZKugQMHDhAOh1EUBYvFQkpKigxOAWRnZ1NYWIjBYKCrq4tQKCTJWRCmCE4ajUYMBgOhUAir1SoDVQLHssU6ckh1xh1JCzS937KdJPWng7HQQjl1/J35gCH5nSmjwXkHf1uo8P9IADsoU79C/UfjOIsf8LjzFq77yy9Ix00hLbBqDnT122cXfb7U/tAe0KGgKApZWVmEQiH27t0rdYw6nY7c3FzGjx9PLBaT0/CysjLGjx+P0Wiku7sbr9dLeXk548aNkz62jo4OzGYzU6ZMISsra4DvVExNhYUqglw5OTlMmzaN8ePHEwgEePvtt/nggw+Gc2hGFPrrUFVVxWq1Ul1dTUFBASkpKXi9Xtra2lAUhbKyMiorK+WsIR6P43A4yMjIoLOzk66uLgKBAFlZWWRmZgLgcrnwer0kEgnS09PJzc1Fp9PhdrtpbW3F5XJhtVoHuIP0ej0ZGRmUlpaSlZVFamoqNptNznD6n3f/v48lgh0hpDor6d9M77doJ7B4O6w6AUN10lqMvpqWDD7dDPcqP/44KLUTWAmqRYHdwPjVYDub+TzClLH38W9Ogdf/w+PKOTDlBNh6IHms+0gGvH4JNAGzwfB637GK00B/DcScn8P1H1s45ZRTKCkpoaamhlAoJPWG6enpnHrqqUyePJnu7m66urpIJBLk5+djNptpb2+nsbERRVEYO3YsxcXF0trx+XwUFBSQmZkppTs+n4/m5mZaWlrkdN9isTBu3DgpARo3bhw5OTmEw2EmTJhAc3MzPT09kui/qBgs7Bcvwjlz5qDT6WhpaSElJYVIJEJaWhqZmZnk5OSQmppKNBolGo2iKArBYJDm5ma6urqk5ZqWlobf76enp0dao8KP2tPTQ3NzM42NjcTjccxmMxaLBbvdjl6vJz09nZKSEgoLCzGbzTLYmJubK61mnU4nLev+13OsEOsIIdVuuLHvz3LgcZIaUlbDhUVEi7OSLoE2YEMULgSbz43v5pzk9P3Gtbx81wMo16iY7nMB28Hn5Ok/3Q25oMxJYPN14cvPSSYKLHgb3G/D1XmAB9Z+HapXwrNLiYQdAGwInsjJBVuhrQqo/RzHYmTDaDQybtw4MjIyqKiowOfzsWfPHmpra6Wecfz48fj9ful7MxqNuN1udu7cSV1dHZmZmVRUVKDX69m9e7e0asaMGYPNZpMBqwMHDrB3716i0SgVFRWYTCays7MpKCjAbreTkpIipTs6nU5KtcrLy3nnnXfo7e0lFAoRjX5xM+kEEel0OimJEn7UnJwcurq6yMzMlGqNtLQ0YrEYfr+fzs5OmpqaOHDgAF6vl1GjRjF27Fh0Oh09PT10dXVhMBhITU0lNTUVv99PR0cHBw4cwOVykZWVhdVqlfcoLS1NvjgzMjIIh8P4fD4UReHEE0+ksLCQv//97/K8hyLW/tc0UjECSPVyqC5G/Z3C3sJixtzdCAsOwLoKKP4ulEPOuw1cq5QBEFSd/OLvd+FbnJO0NNcCrGWRkpRChdIzgSikO6HkbpSTItyo3sfDym2wGFgQhdpLWFC5itevORdegvx5+2l7daAUYHbLNtT/KFxe+BjPFTihzfm5jchIxsyZM6msrKSoqIiqqir0ej1NTU2sWbOG9957j5qaGqqqquSDFI/HZVDKYrGQk5ODoijodDo8Hg/vvvsuXV1dzJw5U07729vbqampoa6uDr1eT0VFBbNmzSIWixEMBrHZbDKQpaoqsVhMyn/GjRtHfn4+U6dOxePx8Nprr7Ft27bhHrZhQX9CGjVqFDNnzqSnp4f8/Hw5u7BYLCQSCfx+P4FAgJSUFMLhMB0dHbS3t9Pc3Ew4HAYgMzMTn89HJBJh165dBINBxo8fL61Ul8tFR0cHLpeLeDyOXq/HbDZjNpux2WwUFhZisVjweDz09vbidruJx+NYrVbGjBmDoijMnTuXtrY2vF4vBw4ckBIrUdzlWMDwR/+vKwY9qCaocjVxzV0PYvPZkpZp0z+hDXTESAOcs+D3fAPO8cDrwCS1L/XUADRDdSApiSIIPiAO4OHhS28H/gIvAayGOxVev+aipHTKDW27RiWN0VjyPPq/ap5tuR6uA/Kdn8twjHREIhGZDy4eisLCQiZPnkxBQQEtLS20tbWRSCSIxWIEAgG8Xi+KolBSUkJVVRWFhYUDZDcAeXl5cpko4CGsXCHTycjIwOFwSKL2er34fD6ZmRMMBolGo9JyjcViFBcXSwI+nKLLxyP0ej1FRUXk5uYSjUZpaWmht7dXTsdtNhuKotDV1YXb7aanpwev1ysJLz8/n5KSElJTU+nu7qa9vV26dsxmMw6HA5PJhF6vx2QykZqaOkBapaoqqampxGIxuru7aWlpoba2VtaEaGhooLu7G7vdzrRp0zjllFMYNWoUkyZNki/QWCw2zKN4+BgBliqwup2ULJVkquhymJIDvAFkQu1rtG08n++xie9tdIGyGrKvSRLkWc3wy2LOVcfzxqVfheWBpI8UD49FL2etQnI/y2cBzXAP7L7jGsYb6iiO7qXxijEo3AWTZgFFQBEpJGCxwsMvXiVPb+kdz7DyzitgnBNqtgN7gR2f4wCNDOj1elJSUmhubqauro59+/ZRXl7OlClTGDt2LGeffTY7d+6ktraWvLw8YrEYbrdbCv8LCgowGo2kpqaSk5ODy+WSD2JmZqYUjIvvJhIJurq6cLlctLa2Sn9ec3Mzu3btkgkAotiKUBQICU9XVxc9PT1MnDiRvLw8Dhw4wEcffTTip49HCmL6nJKSgsFgwOPx0N3dTSgUkoSZk5Mjx87tdmM0GgmFQgAyUCU0qXq9Xn4/FothtVpJS0sjPT2dUChEMBgkkUgQDodlAoioWqXX6+nq6qK7u5uOjg4ZDLNarZJQrVYr2dnZAFitVhYsWMB7771HXV0dzc3N8rpGun91mEn1q8lU06vzkh93GmBxM+orCsoPVL734j08oMyB2U7Y6WT0xG3snXw2vB6FLgMnq3u4iu8lA1Hpfbu8GmY+VEKX8hzbgXz1FOLoSeUs5vM441rqWRudRXXJRniQZOBr2blwc9/3fcDlcOP4pwee6jL6tjkBXj8BbjPwRUtptdvtjB07FpfLRSQSIRQKYTQaGTNmDCaTCYfDQWVlJXq9Hr1ej8PhwGKxyMhzamqqzNTR6/UyjbW5uZnu7m4qKysBsNlsVFZWkpqayocffigLs2RnZ5Oeno7BYKCtrY333nuPYDCIwWAgLS2N7OxsLBYLBoMBs9lMR0cHLS0tQNIXPGvWLGpra48pq+f/CiFjSiQStLa2sn//fmKxGAUFBRQUFMiou0hJFYRqtVplZpRY7vf7pYyttbUVu90uLVUhkzKZTNIvbjQa8Xg8srpYW1sbDQ0N9PT0yHMSWlWTyYTVasVms8ksuvb2dsaMGYPL5aKtbWA1pJHsXx1eUs0+AaYcvLi+IgfccBVP80D6neBei5qjwBWgNKmwwID6NwVFUSlX67Dj7SumEoNz4P3x87hZXcAu5XVal1eiXJpghXoRs9jI/sJ85rW8D8sBV98Bl78B55ybDJLZ6HMTfAIWALedyxeNVAHpJ1UURU71xHS8u7ublJQUcnNzsVgsmM1mmVuu1+vR6XSkp6fj8XhIJBKSeEWCQCKRkD40RVHIzs6mqqqK7u5uent7CQaDOBwObDYbpaWl1NbWsm/fPnw+Hz6fj0AggM1mw263Y7fbpf9PVVW5ft68eaxdu/a4rtfa380hSDUej8sMJzH2YgyCwSCBQGCAxS+s/tTUVBKJBMFgEEVRsNlsWK1W8vLyZLBQuFaEHlV8V5QDFC/Z1NRUORsJhUKSEIVeVZxrKBQiHA4Ti8XIycnBaDRSWFhIc3OzzLrqf60jjVhHxvRfYANgclKuGAAnY5Srk4Gos5zwyN04n4X7UMANzlJYq86iWvkuV6pe1EoFhf1wThR4jN/yLabzOs5LoUnNpri5mRR9nES+lZnq23AVMBdY6oSVTli8ESY5PybU10lKtSAp3bqOgaO1wQCzrwGePMqDMnLQP48/OzubvLw8srKyiMfjtLe309raypgxYxg1ahQ2m00SqfCPipRWMS2NRqMUFhaSnp5ORUUFOp0OvT45yJFIBIvFwqhRoygsLGTfvn0EAgEp3RKyrjVr1rBhwwYikYgkabPZTDAYxO12E41GZdbV3r17KSgoYPz48ezevfu4Jtb+ECQqZhPhcBiTyUQsFiMcDuNyuYhGo5LAzGYzRqNRBgAFaQlL1Gg0YrfbsVgskqyFSyAej5OamorRaJQvNOF+EEHKRCJBc3OznDGIIiuiKllnZyexWAyv14vdbic/P59Jkybxxhtv4Pf7icViIzpwNXJINQY8/CGTVD87z74DVv+TZFGVdah3z8V5V3Kz/nL8t5T3UZsXw6WgjFO5Ub2Xhx+5nT/e8D5fve5uWRLlGcXFXZgBcD4D1/IA77/+FiigHlBoVjMpVp5PnoPAbVCs7qWcOtYpZydrEfQfLRvwah4s/OIQayQS4aOPPgKS9VIzMzNJT09Hr9ejqipms5mcnByZIQNIn574HIvFpEUUiUTIz8/HbreTm5s7QPydkpIiH2iDwUB6erq0ZkVUuaSkhHHjxtHc3ExKSgolJSWUlJSQSCRobGyUyQeqqhKJRGQVKxFU+SKQav8ZQVFREVarVWqFhe/T7XajqirZ2dnS8hPaYaEPFhamyWSSU3uhc3W5XHg8Hrq6uohGo3IqLwJVOp0Om82GzZasXtTd3S1fniaTiUmTJlFRUYHFYqGlpYVAIEB3dzeRSASDwUB+fj56vZ65c+eyadMmGhoapFtppFmpMKykak7m928FVgGveoC32bnrmmTkf/XZwHbgBEmok4GvLfl4D/95EZxFyb/z1f08fPvtUAvzvvcGe+PgXAJsAWe/rCznFfCrTd/jyTkqNN6NcyekKS7gVKj5ENZO6LNQ21nDGYxuaUK5U4UZfGy5ClQBM/Jgk5kvQvZVdXU1+/fvJz09nYyMDBk5FpaIiAILi1OQZDQaxefzyWml8KUJ3amwakVR45SUFJm+KmCxWACkhEoQorCajEYjBQUFFBYWotfrsdlsuFwu2tvb5RQUkjU8VVVl/PjxMnnheIWqqphMJsaOHcuYMWMoKiqS1ruYxodCIVpaWuRMIj09XepQPZ5kIozFYkGv12M0GgkGg7Kso9FoJB6P4/V6ZalA4dcWpC3K+YlZRiKRIC8vj7a2NkKhEDk5OUyYMIGSkhJ57xsbG6W7R3SMsFqtFBYWkp2djdlsZt++fbJq1kgj1mEk1cxk8eil6+DNOfzsT3fxg5KHki6ANnhDrebc0WtZsPcP0Pdsfe17oDxw18e72Opk94nlvKTUc5VSKRc3AyeuUuFVIATqtxWcTyTXORvgkZIrUe9QeO1nkK1eRgQjKJkwpa+gtQ9OVncxuqUJgNafpFNwz79g7XSoHnQZy4GFt0Kt84iP0EhDRkYGJ598MqWlpYwdO5aMjAwZEY7FYowaNUpm5QhCjEaj1NbWsmXLFioqKpg4caK0YBwOB2lpadJF4PV68Xq9OBwOjEbjgGCEyWTCbDbLoId4kMTUMRqNymSAjIwMcnJyZCX6zs5OaWl5PB6CwSAWi4UpU6awa9eu47oGq8Vi4ayzzqKyslJO+dPT0wf4na1Wq4zmi8CUqN2gquqA4ihi5mCxWDAajXi9Xpn/n0gk5D7C4TDRaFRaw+JvYTmLHljp6elSK+vz+eTLVLxYRRUy4aIYNWqUJH2fzyeJeCRhGM+mGWbALeq/4B74wZKHYBy8e9l0vvbkSs6tWAu1z/D6pReRoV458KtznEAa+GC8Usf56vgBq0+YBVzohJVA3U/58+NfkuuU/Sp3he9G+ZXKV5aqXH/xs3zv5F+xQr0Itj4KN3tgZRNmAvI7ea5eUtrGJf2sQ2ElUO4kqZc9flFZWcmZZ57JjBkzqKiokFN3oVcsLS3FarXKiK6oMtXa2sp//vMf/vOf/7B161aampokCfbP+e7o6GDz5s0y0isCHGKKKqypQCAgi1kXFxfLegGALCVoNBrJz8+noKBAyn4Egfv9finnmjdvnrRijyeIF5Lo+6WqKi6XC7fbLafzFotFziosFouMvPv9ftmYMRQKyTq5XV1dsrqUyMAKh8PSzy7uo0jSEAqRUCgk3QmialVWVhb5+fkyEcHtdtPZ2SnLRPZP6hDJIx0dHaSlpWG32znrrLPkS2Kk6Y+Hl+LPgTviP4V8UBsVHlmdHJw//mspXAeLVCNXPv8INz7wNM4t8Jtf9s399cDi70Id2HydPM1VOH8Ozu8N2v/lyY1v4BEuAZxbgOUwPXUTnAWsfI2vrHgRumAHk+Hy77BbPYGIu4R/dXxZ7kYJwdfz/vfQ12EjaRVz/REYlJELYUGISv5CutSfsIQVKcjSYDCQkZGBxWKho6OD3bt3y4wbEUQS036/309rays9PT3yWKKMYEdHh3zghEBdp9ORkZHB6NGjKS0txW63y5oBoVBI+vJEcWSj0YhOpyMajco0WuGzO94gLHkRuGtubmb37t3U1NTI+9Te3o7X65XVxURDxd7eXsLhMKmpqej1egKBAB6PB7fbTTAYlKQXiURk4Eq0zRHWqMFgkKoCYVEKyzMajcrqYqKwS2trK21tbdTU1NDe3o7P55PXIazc/gG1srKyIXtcjQQM7yv6QnA8HoEFoGxQmbTuA3bedBI87AS+y8uvXsLD717F+O9tZgxbARitwl4lCssNsBJ8S1/k19U38Ou1S4EsJqkfcPe+GVB1d18LllupnwqjVqlwEZTtrWGN0gg44SUnf1accB/8QikDnKx+5izG+Z8D4IPCScx8pE/kv4qhOxAI6IEb0+Dh49e/Wl9fj6qq5OTkkJaWRkZGBkajURbYENN4MW0UUeaKigrGjRvH1q1baW5uZuzYsYRCIbxe74DpYjAYpKenRwYp+kd4Rb1PVVWpq6uTrgBhlWZlZcnsLZcrqZUThZFFGUGfzyfrAITDYTweDz6fjylTptDU1DQsY3qkMZhkotEo7e3tst1JV1cXeXl5BINBmZoqJFFut5tYLCaz0mw2m3xJ9fb2SnlcIBCQig7RYbW/TEqQp3DpiP2JmYfFYiE1NVVmvXk8Htra2mQxHJFE0N9XKtwG4vz6+9jFDGakYHhJVU9SqrQU1q+Yklz2EAQesnCm4oR1b3Cj8hBgkV/JjDXDYkOyAMta4M3RSWF+bRY0/ZOdSi1QysfOz//g2FDEm6nnUPC1Fsp/2gGMhXEKLI4Cp8Jt23lZ/SMlNDLFv02e20xlR7Jgyz0kj/dpBs1SjmtS7ejokF0xMzIyyM/PJxaL0dnZKeVTTU1NNDQ0SL9pQUEBGRkZlJSUsGnTJpqamti5cyfRaJSOjg6Ki4spLS3FaDTKAirhcJiioiJGjRols6q2bt1KV1cX+fn5uFwupk2bxsSJE2XeeiwWo7e3l7q6Onbt2iU1sW1tbfT29sr1gmTF9PJ4ClQNZbX5fD62bt1KeXm5tC6FDtTr9RIMBiVZCfeA6BdWWVkpv+PxeKRrpb29XcqhysrKpIUqtK5CaypaVottRdAqIyNDkqComdvS0kJTU5OcYYjarzqdTv6WxL79fr8sbK1ZqoORTtJPORt2rJjMl/kL48LJUL0j1EbvjHOTpCuKVr8JruoiWK7CS2IwT036NK8GFp4NM86GdcA9eUnL8ubp9C6Fc1a+mdz8TmCd0peBZQDOhkmwqP4VHPndyRHJEifYDavkh0/GWpLncZwSKsC6dev40pe+JDNj8vPzCYfD7N69W5Z227FjBzt27MBsNpOWlkZ3dzd5eXkyvdHj8bBnzx7ZhqOrqwuPx4PD4aC+vp7u7m7i8Tg7diRnCKqq0tDQIEsANjQ0AMniHq2traiqSltbG93d3XR2dlJTU8OBAwcwGo2yi6ewrEQQRFhMJpMJg8FwXPRFGgxBNm63m9WrV7Nw4UJ0Oh0Wi4UDBw4QCoVwu91AsrVKSkqKHENVVenp6aG0tBS9Xi9rPYjc/3379smsJ1GLoa2tjdbWVnJycqT1KV5a8Xiczs5Oenp6sFqteDweqRIRx21ubpaWrkgksNlssmxg/3oCwtcqrNmRZKXCcJNq1x9h9iygnSsvWpEsSL0zmkwBjZE0NstJRuRNJGVNTcDDSrIGKsCdacnCKKI99eMkI/LFfGysroVeZ5+ZeVvfMl/f/zaS7aufMtArTNGXgDon3Og8+JwnAbQPcTHbgfcO67KPVQj/ViQSYcuWLbS0tBAOh2lra8NisbBr1y4aGxulDEZUKBIBDa/XSyQSGWA9hkIhmpqaMJvNuN1ubDYboVCI9evXU1NTI6ft4XCY9PR0+UC1tLTwz3/+Uz7QkUhE+t1E4En45YQvFZAVl8SDuGfPHrnsWMfgUnmADAy98847FBcXc+KJJ7Jr1y5ZCUpogMULRrx8RMRf+MpF3yphgcbjcXw+Hz09PUSjUVpbW+nq6pIuGpGKLPzuIjnA6/USDofl70Kv19PT0yOj+P1TjkUxFZGhJboFeL1eVq9eTTQalbKq/mMw3BjmsOcOkuy3Gl6fnpzGV/cR6gZgnQobFNjkgdfTkgT4MEmibSLZZjoGrPo57Lw1uQ7g8f8lyah5cE7fNra+7d8E5vwHzpkOb26Em2cd4tzOSqaj7gQ29V8+1E3zcLwTKiTzv7ds2cKJJ56ITqejvb1dZkkJ7emUKVMIBoM0NDTQ1dWF3++XNQMmTpzIrl27SElJoaKigra2NhobGwkEAlRUVDB27Fg++ugjmpqaMJlM+Hw+vF4vNpuNM888E7vdzv79+/H7/RQVFZFIJOjo6JCBDFFZKSsrS2YF9e+NFAgE5NQykUhImVB3d/dwD+1RgyAZIVcTZCUIymQykZ+fL5M43G43fr9fEpUgRWAAuYnqYv37T0WjUWlBiiCSaG0tugGIl6IgXfF9oVuuqqqS59g/KCauRafTEQ6Hqa+vH/JlOBJ0q8NMqpfAuAocW8swpjbIpZ1KKdDOr9Rb+Tr/S9ZNwWSgaBJQDTvfquS7PMg/LvoKrPKQoy6hU4lCzJB0Fzz19aQ74PF2iOUlLdmXuuHCLLhZ5Qy1lX+1KFQXvsGHNBx0Vp2m0mT/qnySRVRuhpxvNtBZUAqrFBiXN/ALXXnJlthr1zJET5bjBhaLhfnz58uqUpmZmXJ6GIlEKCgoIDc3l0gkQl1dHR0dHaiqSlVVFRMmTJBTQrvdzkknncSBAwfYsGEDdrudOXPmkJWVRVpaGhaLhcmTJ8vK/4WFhZx66qlYLBbKy8uJRqOMHTuWaDTKnj17aGlpobW1VdZNzcvLG9A2u7m5mdbWVjo7OwkEAvKhS0tLY8yYMaxbt+64KbIylLUKMHv2bM4880y8Xi+VlZXodDp8Ph8Gg4GysjIURcHj8cjOqpFIRFqT/S3P7OxsYrEYe/fulcGi/Px8KbcSwUohuxo1ahQOh4OysmQ9ZOEPFeUGu7u7ZRArPz+fU045BUhmXdXX10uViE6nw2w2k52djcFgYNasWbz11lvymCMJw0yqb0LNIpopwtqSQDVBaeYeYDmkL+Pajcu5duFyprWuY/PZc5IugLVvMGnuPli3MWl58h6dJecyXt3MbvO0pKvg6iagmBw1nCTbrQZ4ydBXvOUV1ihfQylWub3xR9zNXQPOaJb/fa74ya9ZqYyH9DmwdSOPffMZrmt5DmWVCnO6YecgP2s2SbfDlGqIrT2qIzacWLhwIVlZWeh0Otk1UzzEQsgvppH5+fmyxbRoadze3i6zeUTa5OjRo+XDYrfbKSoqQlVVxowZQyAQwG63S7LV6/WUlJSgKIrskxSNRklNTSU9PV3WIBg1ahSVlZVYrVYpKA8EAtJdIbKx9Ho9Pp+P008/nX/+85/DObRHDampqbJGaVlZGc3NzbKGg5CgpaamypKLKSkpmM1mvF4ver1eZsMJVYfNZqOiokIW1BEzAnE/4ONU5KysLPLy8mS9h6qqKhKJBHa7HZvNhs/nkz5TRVEYPXq0TNrw+/2ykI7wmwq3TmFhIUVFRbz33nsjjlBh2En1Gn6vLuQkPuDWwp9TTh1NSjOQl/SfPgW0qWz+/hxY7YRqJ9jO5eR317BeWQ/0+WMbH+HXN90AIWdyt/lO7mpTuPsFNekSWA6kp6HuUlC+p/LrFy/mip0rUZRt3Fv+Y2YeeBuA9y+YB9dB2Zk1kD0OimGJuovrWpISqztP/QH3MFgM2w8bgBmZfFz+6vjBiSeeKKuzizJw8XicQCBAR0cHY8aMkemMQlIDyFJ8fr9fTu1zc3Ml2Z544okoiiKTBgS55ufno6qqnJaKKXtaWprMthF96ROJBIWFhZSVldHS0kJaWhqFhYWkpKTIgFhHR4cs8iH6L6Wmpkof4fEIVVXl7KKiooJgMEhHR4fMKhMFVfqTm+ikKmRWYnxEnVRAWp56vV4K/w0GA7m5udIfK7KuhM5YdNs1Go0yo0ukJougVFFREfF4XCYCCP8rILW1/bOyBsuuDmWlf94YPlKd5AQnnBf/G9/Qz+f76v38gYvAVg0+WPLP3zCDTXz3B0+ijLkLMLPvjgIqz2plvdICr96RJMs+qDlKktQAdt+N81KSwajXQa1XUC5UCTkAExQrK3EC6lMnwiZ4su8+bPwy4AA2gnKzys5bK5nYsh+AkAPueeBnSb/voXB8zCCHxJw5c6QmUDw04qGrr68nPT2dqVOnSj+meNjEwxMMBmUnVUHIoiMqJH13YoonfHfCIhWWighmiPMQ/jtRPUmkXgprSxCE8M0KIhYqANHW5XiE0ItarVbZ+balpYWOjg56e3tl8C8ajeJ2u9HpdLIuqlBIiPEVYyRelsIKFX5sv98vC6n0DwjqdDrZYUC4fkRJSEgG0URFK+GXb2hokGoP4bft3/pFJBkIxUZ/f2v//4cTw0eqCz5hXTm8qMR5kamUqGLDGNPCW5KZUFQn/Z2v/pykhCkD5x3AHQN387Vvr0T37ThOBQzrPZhfUmEKnPsynNsCNIDrGRPXrg7CbLh2Fex+rZxxZ9aT+Y9mnuVyHuIH/KLwOm5VlgHd8PonSKxmqxyPViogrQpRicrhcKDT6TAajWzdupX9+/fT0dFBUVERRqNRbuNwOLBaraiqyqhRowiFQuTn58spp9AgClK1WCwy0izSWIWQvL8F1dvbK/WpgAyYiWOJFtmNjY3Spyo0maKsnchjFw/v8QiRy9/e3k5bW5usJiUsdq/XK7uaCnlZ/ypjIiJvt9spLCzEbrfLlGEh7BcJFcFgUEqehIUq1ACBQEDORtrb22XGnKizGovF5H1qaGiQJCxkV1lZWZSUlJCdnS1nGP2JdCQEqASGj1TvA2zwJ+8FAHROLaX64Y1JqdQ9gOkKCDlZpHyHX6m/6/vSbVxz+wu0/cDBn1goA/HXPHI3G9QTeYpkC5RrlGt5A5ikXIxzFixTf8VWxcHLQB6g2FQMdR6iM9LY99OCpK/1cmAdjFeWQd0dOGLdPKy/nYeaf8Ct4x9Lrr/xE67ndUhKC45PmEwm+eCJtibCN5mfn8/evXv5xz/+wemnn05VVRW5ubkA8kFNJBJMnDiRsrIyzGYzVqtVTkGFpSkkPcK6FHIeRVEIBAJymimkOSJ4IiwXEfCIx+N0d3ezZcsW6urq2L17Ny0tLTI/XRxHYOvWrcMxpEcFg6e/wrIXhU+Eld4/ZVfoVS0Wi/wnCosLa3f06NGy31dHR4dskyNK/Ol0OpmSKtJWhbUspuz9XUHiBSeyq8Q9F0kEwn0krGaLxUJeXh7p6em43W62bNkiA1j9y0yOBGIdRtXsH6EclikvMV6dBVs3QvX/JqP2Ta9BSIVsJznqWPYwlnblBdqVF3j7BzMpuNTNu5wmlzlvhJNv2soLiocX/noNs+9TKVKXUg4ofpUXFDMTpvQ79AKSrahnQ4/SlrSaz1oHTRuBc6HcQK8tn3nqmyhlarIk4NWfcCm1wG0rgY1HZ6hGAH7zm9/Q3NzMhx9+SEtLi0wjzc3N5Utf+hJz5syht7eXDz/8ULYdVhRFTtNEnrhok6woCi6Xi82bN7N582Y6OjrkdLOjo0NqFwWEy0CQqGhVnZOTQ0ZGhuxAEIvFZA656E3f1dVFKBQiEolIC02cU01NzXFbV1XUThDNGsX1C79mUVERxcXFQDJJwO12ywBU/ym/0Whk1KhRZGVlyfqpjY2NdHZ2Sl2p8HWLaLyQRQm/u7h3Yp/ifgyWZIkWLcJC1el0mEwmWaPV4XAQiURYv369lMiNNAwjqVr6quwnp14vq/fAsq/zrjodnj0f2AH3QKfSwMM33Y6zIvmtvzMflsFbVHOpmsOlag5O2aPv+qQiYBK8xvnJstRTgJXLhj6FWshQ82Et7FMvQm2e3fdPQW1W2Ng7E2LdsHBC0rLeNPRueLZvZ8cxRKZNTU0NW7dulSSYmppKaWkpkydPpri4mGAwKCsZCVKNxWL09PTg9/slqQnfbH19PXv27JHN4EROvtAnCjG6mK73r9UqAhX9fawej4eGhgZcLpesKyCsHVHjU1Q2EtbRSLBujgaE6qG9vV1adF6vV9aeHTt2LJMnT5bdF4RvNJFIyEQLr9crg31CliaqVonpvyirKCxHk8kkVQPBYFDeM3GvzGazJHzhgtHpdNjtdnJycsjLy5Pb5OTkUFVVRWlpKbt378bv98uaBMIS7n//vtiBKvaC81y4zcJu5Q2ujj0FMZgzeXNf1tIrcLUH2AwPr04mMQl5aPWjtKV/h3L3tQBcqWbADwHMSfJb8Ayo6exUbwdlO6wsglMhDcjsdwbXffALruMJWA2VF7Sy4E9/4CmupviKbm5/5keElAPAavjlLVCrJJUEM/rtYDVwowo8dhTHaeSguLiYmpoadu3aJSU0GRkZ0rdaUFBAMBiUJd6EpCoUCrF//35JthUVFZSUlMhpu2jsVlBQQDQaldPH/g+MsHL6d0oNh8OkpaXhcDhIJBJEIhGam5vx+XxkZGTIhoN2u12SighOCTnV8YbBEfCenh7WrFlDdXW1rHPrcDhkHVNhtQKyw6mYzlssFtmSOh6PU1RURGpqKlarlXg8LjPsRLdVkUwgeoKJzCthTYoMKPFSFC9MoScWMwZhmcZiMXJzcykuLkZVVXbs2EFPT4/0xYvykSOBSPtjGC1VV1InvxBAjyu/CK4G507Y8JICdzqBExg68HM9uNuTvasoB2DTPQq/Vr/VF8hKA+BdToPFJwAxlLjK9xarLCZBX8ErHmu5lTBGaFsHr67kdeU0ipd0w0uwlmrq1HPZpz5MJDuFJfN/M/AUfMCNzwB3H+Icjz8899xzTJgwQcqeRAApJSWFjIwMKisrpTi/u7tbWhKiv3woFGL79u3s2rVLisDz8vIwGAyy3JyYAorpvIg4C9+dIOgPPviAhoYG6a8TigPxIBYVFckmgcJnm56eTm5urhS+H48Wan//IiQr7m/bto3Ozk7ZfyozMxOr1SrlVGIchIZXTLuFuF9InDweD1arleLiYjk9FySdkZFBVlaW7BwgKoKJdiyAzLgS8jgxaxFBS1GPQLwM8/LyZKAzkUjQ1NTE1q1b2b59+0FtekYShr86730AMV7tnM8W5R84vw23Pu7kdn7Eve4fJ0X1gNKpsgKFDwF+qcDWPFgZAFz8+qbv8vSkG2mlJalt/eXXgT9QrZxLNbBefZWbeIhzWt5G8anJGgNAZ6GNNRcsAKJQPCcpv1qroNyW/JGVtXQCML3wXTZfM+fjc36d5HHoOMqDM7IQi8UoKyvD7XaTlZUldamikpCwkjwej3xARcCjqKgIRVFob2+nu7ubYDAoA1HC0hXWpOhhJaaiBoNBBk18Ph8NDQ10dnZSUFAgZUDCRSA6vPbvsyR8s6LC/fFS5u+TINQToiFiSkqKnF0YjUb8fj9utxuPxyN9noIA+5dUFG4VMc0vKCiQ6gAxk7Db7TKyLyRbohJWenq6DCCJViz9favCJeD1emlra5P1UsWL2+Px4PF4ZHaeaIs+kuVww0uqPuDVADnqxSwcfwfcCXefA1RAZm0zPO78eNtJDzIeWDr1J9zb9GPocpKczJuT9Vef6dvuWWAB/GXOItn4r5w6zlXWJjOyQn+E/K/hyTOQe7EXXu3bqs0JbaDco8Kz8MiOG1BNUJG5m3qlN0n+C4E2Pi648gWDXq9nxowZeL1eWQxD9Izv7e3F4XBgsVjo7e2V/lGdTifbFosgVX19PW63G4vFQiAQkCmKYn/in8/no6WlBYPBQF5eHoFAgJqaGhobG2WlelEOTljEaWlphEIhPvroIzZv3kx7e7u0VFtaWo7r1imHQv/24CaTiebm5gEaU6ElDoVCcuodj8fp6emR0iVhwQr/p4CYIQgr2GKxyCIr0WhUTutF1TARaISPW7aIkoOivm1RURGZmZky6Cgs7f7ty/u32hlpGF5SDTmBWzgQrsD6doI1uSdzpvJDQM+PdKu48eqnk2cYA55qAr7HD7fcnuwA2DUZnF9Lpohe5xy43xpYuOP3TFG+AUCpciNMuiFZQvCp0dB2gDxfW7L+qa3vu0/9Ec75WvLvrg/5Lg9yeeaz1Ctt8Gz1x1WwJv2RZCGYLx6am5t59NFH+elPfyqDGpFIhM2bN5NIJJg6deqAdtT9K/t7vV527drFrl27pFUp9IzCLwof19wEMJvNxGIx9u3bx44dOzAYDHR1dVFaWkp6ejpdXV3SxydK+cViMQ4cOMCaNWtobm6W5elEI7njWZMKB/tURTWuxsZGcnNzZcBHFLvR6/Xk5uZiMplkaqp4uQnFgJgliEr+gyt9uVwuDAaD/D1EIhEp3RIzFlGERcxERDIHIDWpIuFAFC8XBcmFhKv/bEbMTkYihn/6j5cMXw8RHJz59L+T1aR88A2+yg0//DXKAbVPA2rGAERI7avo/7Wk5XgzcLkT9Hd/vEsT/Hn0Ev7lO+vjZbYmZu7Yx/td86AY4jEPTfOzKF7X3ZcJZUjKpq4GfjmBdSUTWDfl7KTLdjbJbZwA9Ud1NEYyVFXlb3/7G1dddRWFhYV4vV6amprYt28fBQUF8mGz2WxSliMe8O7ubrZt20Zrayvjxo2TWkihSw2HwzIyLzKi9Ho9GRkZtLa20tjYSEFBAQUFBZSUlKDT6di/fz8+n09ayBkZGfT29lJbW0tPTw/p6elkZ2ejqirbt28fzqEbFoixTyQSvPfeewQCAa6//nqi0Sgul4uenh6ys7Oly0QoNYQ6Q+iC09PT6e7uxu/309nZKcnUaDTKotXCYrVYLLIVi8lkks0CRfqqcEsI14Ro/ifanYfDYdlefOLEiTQ1Ncm24oM7AQyFkWC5jgBSfZJodiYKXYAHqtNgbRQdMZRgAuaIrCk4kQgoUZLs5kxW93MHWKr+DuUFNdl11Qk4lwN1+GzT+o6xmV+pdVx7xfKkxGpdcmk7ecnKg22wVG1npZ3k1N4dgGctSTKvexBu+y68vpKkD9VztAdkxOPKK69k+fLlvP/++2zbto2enh7Ky8uBJKGmpaXJvkaRSEQ+aHV1dej1eqZNm4bD4SAcDtPZ2UlLSwuxWIyioiKpoywrKyM9PV32I3K5XJSXl1NSUiKjzSJo1dXVJduDdHZ20tbWRmZmJuXl5SQSCd54443hHbDPGYOtVVEtv6Ojgx07dshgkSh0EgwGcbvddHd3s3//fmn5m81mysrKsNvttLe3S/+10WiktLRUFo52u92yr1RhYaGsYmYymWhqapKaZuEystvtALJVS2Njo7yvEyZM4LXXXpM1c0VyCDAia6cOhRFAqpCMnhvgrLTkGTkNWPwhqFNIEupZUD4n2dqkzSCj97jhRvURAlj6ljmRjlQA0/lJy3Pd+VyrBLhSfYTX+DJtyuvAMs6O/7NvPTwR/zYrProSV6GJrIuCcLmQSnng9f471dDd3c3atWulVElU+U9LSyMajfLhhx/y0UcfEY1GycvLY+rUqeTl5VFVVUVTU5OUYUWjUbKzs2Whk/3798vMqXA4zOTJkzGZTLJ5nZBCBYNBzGYzxcXFWK1Wenp6aGpqYv/+/ezevVtau1u3bmXnzp3DPVwjAvF4nN7eXtavX093dzd6vZ4JEybgcrnw+/20tbXR3t4umyHabDbGjx9PZmYmRqNRRvjT0tJkpSqRmSYCk6JVteheK4JQYgYiqloJCRckZVwNDQ2ybbjNZpPdXPs3kew/6zkURgrJjhBSBXgQVo+H5V+HZU18eNf4ZB3UC53JjKcZJLNAm2DpliJW9o1vO3kEMKO6Ffh5cplyayPUFPPG2GrO/eFacj5ooPPSUgqUG2l7/QbARbQrDVe2HW6GyCQFQ18x/8yOELf84W5+oVzGF0Uq9VkRi8V44oknyM/P55xzzpFdOUWPqNdff11aPKNGjaK0tJTKykoKCgpkHyKR1z1x4kSpGa2vr2f//v20tbXJLqmiW2cikaC3t5fOzk6CwaCsMSAi0cLq6enpOe4LTx8O+lurgmxcLhdr1qwBoKqqismTJ7Nnzx5aW1tpaWmht7dXZlXZ7XbKy8tlFTCRbioKmwgBvhDtC6UAIGviNjc3yzY6Op2OtLQ02dkWPtYe//vf/x4QUBQELPyyQ0X5BxPoSCFUGFGkCrAblv0UgOnKLkDtKwrdtzobuHktKy+/Ivm5Gl5UfEAnj6uXcd3W55JXdGsx14x9kC1Mhdeh01YKdf2PUwTjVCAGv9zORff/nkccN3A799FOLmuUifSlSWk4BHw+H7W1tbKZ3q5du2SO/Z49e2T2lPCHpqen4/F4pFUpiq2I8nBCJuPxeHC5XFJPKiRZkUiE2tpampubZQdXnU4nu2/6fD6ZdKDhYPRviRKPx2lpaeHpp59m4cKFNDQ0yCCR0H76fD527NhBS0sLLpdL6o6FAsDlchEKhUhNTcXhcJCamip96UajEY/HQ29vL93d3TL9WOT9+/1+TCaTbF3ev3+YqIDWXwUCh65CNZLIVGCEkSpAMi+bGcqA0n7JZcDD1cng1G0ko/dLvwNbnVz/wrNcv2w0EIR8OJ23WKRMJ1l1RYGtb/BH9f2k35Vq2KkABnBO588nTefPVUvgJQ9cmJbc78rP4VKPA6xYsYLMzExOPvlk6uvraWxslCXdRObTO++8Q01NDfX19fh8Purq6jCZTIwZMwZAZvFYLBZ0Oh0VFRVUVlZiNpulteX3+9m0aRPhcJjs7Gyys7NRFIUDBw7I8nQip19DEoN9q0KKJIJE7e3trF27luzsbIqLi+np6ZEBoFgsJmsmCEVHT08PtbW1JBIJOjs7ZflGUTSnf3BK+MaF+qN/SxtRJFuks4pUVVF4p38K6+DrORYwAkm1D5v+A23TD24LfVbfvy6SufhPARc6GX/JZnYv+yYim0pijkLdu7mUKxvZeXsF/1Dn8iXlnY/X3wjM8cCm3bB2VtIavu9oXdTxCZfLxdq1a5kzZw6dnZ2Ew2HZc0joIvfu3Yter6egoAC/309TU9MAnWlhYaGc4ufl5cm6qP17yAudqSBms9mMy+WS0euRmF0zktCfZIWcadu2bZx22mmceOKJeL1eOV0Xkrd4PC4riEWjUdra2uR6EXgS2VPCqnS73fLlJxIJRFqqINtgMCglWMJtMHiq/2la1JFKsiOXVPkLnDUa3kxLRugFXu/7tw7AmUxVXQq77dOAbng17eNOqwDrAvyD+dBUwFeKXmSufx195moS6SSt064+QvWhWan/BYLBIAaDgVNOOYVt27YRi8Vk6qKQ3pjNZhwOB36/XzYGLCkpkVX6RQEW8dAKQhVtPBwOh3x4W1tbKSsrIycnRwYyhI9Ow8cQxHOoF048HpedF6ZNm0ZLS4usQCXSTmOxGNnZ2bJrrdvtJjs7m/z8fFn/VgSqhDsGkPVtxX0RrqLRo0fT1dWFqqo4HA6pix3KD3wsYoT/Ch+EcxbBjAlJF6eeJOHtfBCIwkonLA3Aw5Zk19THs+hdYMSxNMKiqX9Jfn+ShSuV38BsA3+2LcHsWwI0ga84mR21sF+76UkAAeCFz/cyjwMkEgneeustli5dyumnn05tba2s7C8yqYTlKXrANzY2yuh+KBTCYrHgcDhoamqis7NTWkrxeBy73U5JSQlpaWlkZGTgcDjIysqSfeObmpq+EOmn/y36F3Ie7BLYv38/breblJQU5s2bR2lpKbW1tbJAuGgWKKqHAdJlkEgkpPUqCFokf3g8HpnpVlFRIYNkIn1Y1Le1WCwDsqSOdYxwUgV4GTYZ4PE7klP15UDsu/AqsDQKtmQkEROwKoBDv4Y31Grmht/FdlY8OZV3GpIVpTYAsz3AszDb3Lf/4zvD5vOE3+/nueeew2KxsHTpUpnDL6byov6l2WwmLy9P5qC3trZKP6kofi06aYqpo0hTzMzMxOfz8fLLLw+wakQARsOnoz/Bikr8zc3N6HQ6pkyZwqRJk2RaqWjWKOrX9vT04PF4yM7Oli1VXK6PVTIiEwqQ9VW9Xi9FRUXSLSCa+Yni2P2DUYci1mPJcj0GSBUgCs92w6t9rUyeoi9IZfh4Exuw0wIz5nDuT9dCFbCuPVl4ZSvJqf0C+LiFtEamRwOipumePXtYsmQJbrdbpjiKoISiKKSnp2M2m+nt7ZX1TlNSUnA4HLKrp3AHqKrKSy+9dNw26Pu8cKjAlahNKqbxIrXUYDDIVtUWi4WpU6ficrl4//33SSQSeDwe2QE3EAjQ2tqK3W4nFArh9XolCft8Phmg6u/7PpQv9ViHoh7mK0BRnEf5VD4LxnNQQEpiLwP1pVUciwWkVdX5f96HKEAxHBCZVfF4nHPPPZeZM2dKjanQloo2KYqiUFZWJnu6d3d3s2rVKjZu3CgfQFGlaCTjSKkPKioqpPV2pDGYVAWEtS/6hwmZkyioYjAYmDdvHoWFhTzxxBPSnSMqWwWDQUKhEGazWXZftdvtNDY2SjmVkMfBx838+p/LcASkbDYb27ZtO6L7PEYs1cHY/Rm2PfYI9XiA0I0CLF++nOXLlwPJh2fZsmXs3r2bDRs2fMIeNBxtDBXEam9vH9DGRmQ1CYu1qqoKr9eLx+OR64XwX8ihhE/V7/eTSCRkc0dRg3UokjzWIvyfhGOUVDUcq1BVleeff364T+MLi0P5LcXMQYjwBQRJArS0tLB//37Z/lt8R2wvpvBiOp9IJGSrlf7bHW6E/1gkVNBIVYOGLxwG93Qa/Lk/OQKyHGA0GpXE2983+klT9/8m8HSskqmARqoaNHyB0V8J0B+DlwlrU/h6P61alPj+ZyXIY51QQSNVDRq+8DgcIhs8dT8S+zwS3xmJ0EhVgwYNEp+nAP94IdHBGMZuqho0aBhp+LyI7nglVNBIVYMGDYNwPBPe5wFt+q9Bg4aD8N8Q6yepAL5I0CxVDRo0HBFohJqERqoaNGjQcAShkaoGDRq+MPg81A0aqWrQoOG4x1BpskcLGqlq0DDCcLQqVH0Rcaji10eTWLXovwYNIwzHQxT9UKmvAkfz+g6XMI9WtwGNVDVoOIbxeWVADS66cjj4pO2Gq3XK50HsGqlq0DDC8Fks1U9qQTJ4u/77P9x9H+7y/4YkP8mS7b/+SBHw4P0cLWLXSFWDhhEGUcj5sxDrZ8HRsNCOxD6PRqHqTyPOo0Gsmkdcg4YRhuOlq+hIQP+X0+AX1dFqaa5Zqho0jDCYzWZisRiJRGK4T+W4wuCeWCkpKUeFWA+78Z8GDRo0aPh0aNN/DRo0aDiC0EhVgwYNGo4gNFLVoEGDhiMIjVQ1aNCg4QhCI1UNGjRoOILQSFWDBg0ajiA0UtWgQYOGIwiNVDVo0KDhCEIjVQ0aNGg4gvj/lP9IQhLD3noAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|███████| 2/2 [00:00<00:00,  3.31it/s, kld=704, perceptual=0.241, generator=2.83, feature=0.145, discriminator=3.18]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 51/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.19it/s, kld=1.35e+3, perceptual=0.247, generator=1.95, feature=0.0697, discriminator=3.94\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.27it/s, kld=891, perceptual=0.269, generator=1.84, feature=0.0785, discriminator=4.04]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 52/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.25it/s, kld=373, perceptual=0.286, generator=1.98, feature=0.0785, discriminator=3.87]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.92it/s, kld=274, perceptual=0.285, generator=2.02, feature=0.0876, discriminator=3.8]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 53/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.16it/s, kld=637, perceptual=0.264, generator=2.5, feature=0.0888, discriminator=3.63]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.50it/s, kld=417, perceptual=0.268, generator=2.46, feature=0.0777, discriminator=3.49]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 54/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.23it/s, kld=584, perceptual=0.274, generator=2.46, feature=0.095, discriminator=3.23]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.24it/s, kld=420, perceptual=0.254, generator=2.53, feature=0.0873, discriminator=3.37]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 55/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.19it/s, kld=842, perceptual=0.272, generator=1.82, feature=0.0686, discriminator=3.99]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.11it/s, kld=521, perceptual=0.256, generator=1.91, feature=0.0724, discriminator=3.97]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 56/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.20it/s, kld=301, perceptual=0.292, generator=2.01, feature=0.0822, discriminator=3.88]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.03it/s, kld=169, perceptual=0.291, generator=2.27, feature=0.103, discriminator=3.59]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 57/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.15it/s, kld=835, perceptual=0.302, generator=2.35, feature=0.104, discriminator=3.89]\n",
+      "100%|█████████| 2/2 [00:00<00:00,  4.33it/s, kld=517, perceptual=0.341, generator=2.3, feature=0.119, discriminator=3.6]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 58/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.18it/s, kld=425, perceptual=0.322, generator=2.7, feature=0.174, discriminator=3.03]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.24it/s, kld=245, perceptual=0.326, generator=2.72, feature=0.162, discriminator=3.07]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 59/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=139, perceptual=0.302, generator=2.79, feature=0.149, discriminator=2.91]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.20it/s, kld=69.9, perceptual=0.284, generator=2.83, feature=0.137, discriminator=2.89]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 60/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.20it/s, kld=210, perceptual=0.278, generator=2.84, feature=0.133, discriminator=2.84]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=106, perceptual=0.257, generator=2.91, feature=0.125, discriminator=2.81]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████| 2/2 [00:00<00:00,  3.44it/s, kld=132, perceptual=0.257, generator=2.86, feature=0.12, discriminator=2.85]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 61/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=835, perceptual=0.266, generator=1.8, feature=0.0844, discriminator=3.96]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.26it/s, kld=767, perceptual=0.293, generator=1.72, feature=0.0979, discriminator=3.83]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 62/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.19it/s, kld=908, perceptual=0.306, generator=1.62, feature=0.102, discriminator=3.5]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.25it/s, kld=568, perceptual=0.324, generator=1.66, feature=0.107, discriminator=3.45]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 63/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=865, perceptual=0.304, generator=1.54, feature=0.0938, discriminator=3.68]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.77it/s, kld=668, perceptual=0.295, generator=1.62, feature=0.0881, discriminator=3.65]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 64/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=915, perceptual=0.272, generator=1.26, feature=0.074, discriminator=3.78]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.09it/s, kld=570, perceptual=0.299, generator=1.21, feature=0.0785, discriminator=3.76]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 65/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.20it/s, kld=343, perceptual=0.268, generator=1.28, feature=0.0697, discriminator=3.87]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.37it/s, kld=209, perceptual=0.278, generator=1.2, feature=0.0735, discriminator=3.81]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 66/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.25it/s, kld=495, perceptual=0.252, generator=1.18, feature=0.0635, discriminator=3.82]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.88it/s, kld=337, perceptual=0.267, generator=1.15, feature=0.0676, discriminator=3.88]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 67/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.21it/s, kld=677, perceptual=0.271, generator=1.25, feature=0.0701, discriminator=3.95]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.08it/s, kld=563, perceptual=0.279, generator=1.11, feature=0.0637, discriminator=3.93]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 68/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.29it/s, kld=373, perceptual=0.283, generator=1.24, feature=0.0668, discriminator=3.91]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.75it/s, kld=235, perceptual=0.266, generator=1.25, feature=0.0631, discriminator=3.89]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 69/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.20it/s, kld=455, perceptual=0.275, generator=1.23, feature=0.0644, discriminator=3.96]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.21it/s, kld=363, perceptual=0.263, generator=1.19, feature=0.0624, discriminator=3.91]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 70/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.23it/s, kld=519, perceptual=0.264, generator=1.29, feature=0.0628, discriminator=3.9]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=545, perceptual=0.26, generator=1.25, feature=0.0607, discriminator=3.91]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████| 2/2 [00:00<00:00,  3.35it/s, kld=375, perceptual=0.261, generator=1.29, feature=0.0589, discriminator=3.89]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 71/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=329, perceptual=0.242, generator=1.18, feature=0.0615, discriminator=4.02]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.73it/s, kld=205, perceptual=0.267, generator=1.16, feature=0.067, discriminator=3.97]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 72/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=629, perceptual=0.233, generator=1.37, feature=0.0524, discriminator=3.98]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.20it/s, kld=417, perceptual=0.233, generator=1.38, feature=0.0535, discriminator=3.95]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 73/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.16it/s, kld=198, perceptual=0.245, generator=1.45, feature=0.0611, discriminator=3.97]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.12it/s, kld=129, perceptual=0.263, generator=1.43, feature=0.071, discriminator=3.99]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 74/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.22it/s, kld=466, perceptual=0.279, generator=1.78, feature=0.0656, discriminator=3.92]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.96it/s, kld=308, perceptual=0.278, generator=1.79, feature=0.0681, discriminator=3.86]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 75/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.16it/s, kld=736, perceptual=0.245, generator=1.53, feature=0.0834, discriminator=4.15]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.08it/s, kld=668, perceptual=0.235, generator=1.41, feature=0.0861, discriminator=4.06]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 76/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=815, perceptual=0.277, generator=1.98, feature=0.129, discriminator=3.59]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.03it/s, kld=525, perceptual=0.268, generator=2.05, feature=0.133, discriminator=3.32]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 77/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.24it/s, kld=1e+3, perceptual=0.276, generator=2.28, feature=0.115, discriminator=3.72]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.66it/s, kld=660, perceptual=0.282, generator=2.32, feature=0.133, discriminator=3.53]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 78/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██| 15/15 [00:06<00:00,  2.21it/s, kld=1.36e+3, perceptual=0.279, generator=2.47, feature=0.14, discriminator=2.85]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.23it/s, kld=957, perceptual=0.297, generator=2.59, feature=0.138, discriminator=2.82]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 79/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.22it/s, kld=2.86e+3, perceptual=0.311, generator=1.84, feature=0.142, discriminator=3.38]\n",
+      "100%|████| 2/2 [00:00<00:00,  3.54it/s, kld=2.04e+3, perceptual=0.328, generator=1.89, feature=0.148, discriminator=3.5]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 80/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.17it/s, kld=699, perceptual=0.338, generator=2.35, feature=0.14, discriminator=2.54]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=557, perceptual=0.317, generator=2.58, feature=0.145, discriminator=2.36]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|████████| 2/2 [00:00<00:00,  3.51it/s, kld=409, perceptual=0.331, generator=2.58, feature=0.147, discriminator=2.5]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 81/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.25it/s, kld=491, perceptual=0.355, generator=2.74, feature=0.146, discriminator=2.93]\n",
+      "100%|███████| 2/2 [00:00<00:00,  2.61it/s, kld=359, perceptual=0.314, generator=2.85, feature=0.143, discriminator=2.95]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 82/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.24it/s, kld=517, perceptual=0.334, generator=2.67, feature=0.14, discriminator=3.12]\n",
+      "100%|████████| 2/2 [00:00<00:00,  3.93it/s, kld=384, perceptual=0.326, generator=2.72, feature=0.14, discriminator=3.09]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 83/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.22it/s, kld=1.27e+3, perceptual=0.302, generator=1.8, feature=0.0732, discriminator=4]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.94it/s, kld=815, perceptual=0.31, generator=1.76, feature=0.0643, discriminator=3.98]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 84/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.20it/s, kld=1.01e+3, perceptual=0.281, generator=1.79, feature=0.0657, discriminator=3.96\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.20it/s, kld=590, perceptual=0.263, generator=1.86, feature=0.071, discriminator=3.95]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 85/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=465, perceptual=0.253, generator=1.94, feature=0.0742, discriminator=3.63]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.08it/s, kld=329, perceptual=0.251, generator=1.95, feature=0.0817, discriminator=3.5]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 86/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=862, perceptual=0.243, generator=1.09, feature=0.0589, discriminator=3.92]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.89it/s, kld=591, perceptual=0.238, generator=1.14, feature=0.0605, discriminator=3.81]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 87/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.18it/s, kld=1.08e+3, perceptual=0.24, generator=1.74, feature=0.0678, discriminator=3.54]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.11it/s, kld=677, perceptual=0.231, generator=1.8, feature=0.0649, discriminator=3.91]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 88/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█████| 15/15 [00:06<00:00,  2.21it/s, kld=958, perceptual=0.316, generator=1.8, feature=0.0715, discriminator=3.97]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.26it/s, kld=618, perceptual=0.301, generator=1.81, feature=0.0668, discriminator=3.96]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 89/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|███| 15/15 [00:06<00:00,  2.16it/s, kld=1.17e+3, perceptual=0.311, generator=1.31, feature=0.0658, discriminator=4]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.89it/s, kld=989, perceptual=0.305, generator=1.23, feature=0.0674, discriminator=3.95]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 90/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██| 15/15 [00:06<00:00,  2.23it/s, kld=2.17e+3, perceptual=0.294, generator=1.94, feature=0.101, discriminator=3.3]\n",
+      "  0%|          | 0/2 [00:00<?, ?it/s, kld=2.66e+3, perceptual=0.308, generator=1.75, feature=0.0698, discriminator=3.44]"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 400x150 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|█████| 2/2 [00:00<00:00,  2.79it/s, kld=1.5e+3, perceptual=0.301, generator=1.96, feature=0.12, discriminator=3.16]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 91/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.24it/s, kld=1.88e+3, perceptual=0.29, generator=2.02, feature=0.0721, discriminator=3.34]\n",
+      "100%|██| 2/2 [00:00<00:00,  4.14it/s, kld=1.26e+3, perceptual=0.249, generator=1.96, feature=0.0852, discriminator=3.27]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 92/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.19it/s, kld=1.49e+3, perceptual=0.253, generator=1.96, feature=0.0624, discriminator=3.82\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.80it/s, kld=862, perceptual=0.256, generator=1.96, feature=0.0589, discriminator=3.98]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 93/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|██████| 15/15 [00:06<00:00,  2.23it/s, kld=592, perceptual=0.252, generator=1.11, feature=0.108, discriminator=4.4]\n",
+      "100%|█████████| 2/2 [00:00<00:00,  3.92it/s, kld=365, perceptual=0.278, generator=1.19, feature=0.13, discriminator=4.5]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 94/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.21it/s, kld=1.65e+3, perceptual=0.267, generator=1.77, feature=0.121, discriminator=3.45]\n",
+      "100%|███| 2/2 [00:00<00:00,  4.14it/s, kld=1.05e+3, perceptual=0.244, generator=1.85, feature=0.123, discriminator=3.18]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 95/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|█| 15/15 [00:06<00:00,  2.24it/s, kld=1.53e+3, perceptual=0.279, generator=1.74, feature=0.114, discriminator=3.33]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.29it/s, kld=826, perceptual=0.259, generator=1.69, feature=0.0888, discriminator=3.51]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 96/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.20it/s, kld=940, perceptual=0.264, generator=1.88, feature=0.0612, discriminator=3.97]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.26it/s, kld=580, perceptual=0.262, generator=1.55, feature=0.0873, discriminator=4.16]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 97/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=588, perceptual=0.275, generator=1.81, feature=0.0542, discriminator=3.85]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.94it/s, kld=549, perceptual=0.262, generator=1.94, feature=0.0645, discriminator=3.75]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 98/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=658, perceptual=0.284, generator=1.73, feature=0.0515, discriminator=3.94]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.15it/s, kld=362, perceptual=0.271, generator=1.79, feature=0.0583, discriminator=3.94]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 99/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=808, perceptual=0.281, generator=1.83, feature=0.0545, discriminator=3.86]\n",
+      "100%|██████| 2/2 [00:00<00:00,  2.92it/s, kld=598, perceptual=0.266, generator=1.79, feature=0.0619, discriminator=3.89]\n"
      ]
     }
    ],
@@ -929,9 +2392,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16"
+   "version": "3.10.6"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
\ No newline at end of file
+}

From 067998b90260cf86962459caa8217149456c43a1 Mon Sep 17 00:00:00 2001
From: virginiafdez <virginia.fernandez@kcl.ac.uk>
Date: Wed, 5 Jul 2023 09:40:38 +0100
Subject: [PATCH 5/7] Implemented changes as per PR correction: adding
 docstrings, removing blank lines, modifying the notebook to take losses more
 into account + conclusion.

---
 generative/losses/kld_loss.py                 |  11 +
 generative/networks/blocks/spade_norm.py      |  11 +
 generative/networks/nets/spade_network.py     |  70 ++-
 .../2d_spade_gan/2d_spade_vae.ipynb           | 586 ++++++++++--------
 .../generative/2d_spade_gan/2d_spade_vae.py   |  26 +-
 5 files changed, 421 insertions(+), 283 deletions(-)

diff --git a/generative/losses/kld_loss.py b/generative/losses/kld_loss.py
index 4b7e6f31..d3178b84 100644
--- a/generative/losses/kld_loss.py
+++ b/generative/losses/kld_loss.py
@@ -1,3 +1,14 @@
+# 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.
+
 import torch.nn as nn
 import torch
 
diff --git a/generative/networks/blocks/spade_norm.py b/generative/networks/blocks/spade_norm.py
index 68991f0c..419f740e 100644
--- a/generative/networks/blocks/spade_norm.py
+++ b/generative/networks/blocks/spade_norm.py
@@ -1,3 +1,14 @@
+# 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 torch
 import torch.nn as nn
diff --git a/generative/networks/nets/spade_network.py b/generative/networks/nets/spade_network.py
index ebf601e6..0be1d9c8 100644
--- a/generative/networks/nets/spade_network.py
+++ b/generative/networks/nets/spade_network.py
@@ -26,6 +26,17 @@ class UpsamplingModes(StrEnum):
     bilinear = "bilinear"
 
 class SPADE_ResNetBlock(nn.Module):
+    """
+    Creates a Residual Block with SPADE normalisation.
+    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 that will be taken into account in SPADE normalisation blocks
+        spade_intermediate_channels: number of intermediate channels in the middle conv. layers in SPADE normalisation blocks
+        norm: base normalisation type used on top of SPADE
+        kernel_size: convolutional kernel size
+    """
 
     def __init__(self,
                  spatial_dims: int,
@@ -74,7 +85,6 @@ def __init__(self,
                                 norm=norm)
 
     def forward(self, x, seg):
-
         x_s = self.shortcut(x, seg)
         dx = self.conv_0(self.activation(self.norm_0(x, seg)))
         dx = self.conv_1(self.activation(self.norm_1(dx, seg)))
@@ -89,7 +99,19 @@ def shortcut(self, x, seg):
         return x_s
 
 class SPADE_Encoder(nn.Module):
-
+    """
+    Encoding branch of a VAE compatible with a SPADE-like generator
+    Args:
+        spatial_dims: number of spatial dimensions
+        in_channels: number of input channels
+        z_dim: latent space dimension of the VAE containing the image sytle information
+        num_channels: number of output after each downsampling block
+        input_shape: spatial input shape of the tensor, necessary to do the reshaping after the linear layers
+        of the autoencoder (HxWx[D])
+        kernel_size: convolutional kernel size
+        norm: normalisation layer type
+        act: activation type
+    """
     def __init__(self,
                  spatial_dims: int,
                  in_channels: int,
@@ -139,7 +161,6 @@ def forward(self, x,):
         return mu, logvar
 
     def encode(self, x):
-
         for block in self.blocks:
             x = block(x)
         x = x.view(x.size(0), -1)
@@ -154,7 +175,25 @@ def reparameterize(self, mu, logvar):
         return eps.mul(std) + mu
 
 class SPADE_Decoder(nn.Module):
-
+    """
+    Decoder branch of a SPADE-like generator. It can be used independently, without an encoding branch,
+    behaving like a GAN, or coupled to a SPADE encoder.
+    Args:
+        label_nc: number of semantic labels
+        spatial_dims: number of spatial dimensions
+        out_channels: number of output channels
+        label_nc: number of semantic channels used for the SPADE normalisation blocks
+        input_shape: spatial input shape of the tensor, necessary to do the reshaping after the linear layers
+        num_channels: number of output after each downsampling block
+        z_dim: latent space dimension of the VAE containing the image sytle information (None if encoder is not used)
+        is_gan: whether the decoder is going to be coupled to an autoencoder or not (true: not, false: yes)
+        spade_intermediate_channels: number of channels in the intermediate layers of the SPADE normalisation blocks
+        norm: base normalisation type
+        act:  activation layer type
+        last_act: activation layer type for the last layer of the network (can differ from previous)
+        kernel_size: convolutional kernel size
+        upsampling_mode: upsampling mode (nearest, bilinear etc.)
+    """
     def __init__(self,
                  spatial_dims: int,
                  out_channels: int,
@@ -214,8 +253,6 @@ def __init__(self,
 
 
     def forward(self, seg, z: torch.Tensor = None):
-
-
         if self.is_gan:
             x = F.interpolate(seg, size=tuple(self.latent_spatial_shape))
             x = self.fc(x)
@@ -235,6 +272,26 @@ def forward(self, seg, z: torch.Tensor = None):
 
 class SPADE_Net(nn.Module):
 
+    """
+    SPADE Network, implemented based on the code by Park, T et al. in "Semantic Image Synthesis with Spatially-Adaptive Normalization"
+    (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 used for the SPADE normalisation blocks
+        input_shape:  spatial input shape of the tensor, necessary to do the reshaping after the linear layers
+        num_channels: number of output after each downsampling block
+        z_dim: latent space dimension of the VAE containing the image sytle information (None if encoder is not used)
+        is_vae: whether the decoder is going to be coupled to an autoencoder (true) or not (false)
+        spade_intermediate_channels: number of channels in the intermediate layers of the SPADE normalisation blocks
+        norm: base normalisation type
+        act: activation layer type
+        last_act: activation layer type for the last layer of the network (can differ from previous)
+        kernel_size: convolutional kernel size
+        upsampling_mode: upsampling mode (nearest, bilinear etc.)
+    """
+
     def __init__(
             self,
             spatial_dims: int,
@@ -297,7 +354,6 @@ def __init__(
         )
 
     def forward(self, seg: torch.Tensor, x: Union[torch.Tensor, None] = None):
-
         z = None
         if self.is_vae:
             z_mu, z_logvar = self.encoder(x)
diff --git a/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb b/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
index bf7271c3..e5c64a3d 100644
--- a/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
+++ b/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
@@ -37,23 +37,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "e059c423",
    "metadata": {
     "scrolled": true
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/media/walter/Storage/Projects/GenerativeModels/venv/lib/python3.10/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
-      "  from .autonotebook import tqdm as notebook_tqdm\n",
-      "A matching Triton is not available, some optimizations will not be enabled.\n",
-      "Error caught was: No module named 'triton'\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "import os\n",
     "import tempfile\n",
@@ -74,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "id": "e76296e7",
    "metadata": {
     "scrolled": false
@@ -84,7 +73,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Temporary directory used: /tmp/tmpo8gppqh6 \n"
+      "Temporary directory used: /tmp/tmpz0rbc_3s \n"
      ]
     }
    ],
@@ -97,7 +86,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 26,
    "id": "2483148a",
    "metadata": {},
    "outputs": [],
@@ -145,7 +134,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "id": "dc560f7e",
    "metadata": {
     "scrolled": true
@@ -157,17 +146,17 @@
      "text": [
       "Downloading...\n",
       "From: https://drive.google.com/uc?export=download&id=1SX_MCzQe-vyq09QYxECk32wZ2vxp9rx5\n",
-      "To: /tmp/tmpo8gppqh6/data.zip\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 384M/384M [00:05<00:00, 69.6MB/s]\n"
+      "To: /tmp/tmpz0rbc_3s/data.zip\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 384M/384M [00:05<00:00, 67.0MB/s]\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "'/tmp/tmpo8gppqh6/data.zip'"
+       "'/tmp/tmpz0rbc_3s/data.zip'"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -179,7 +168,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "cd7dd6ec",
    "metadata": {},
    "outputs": [],
@@ -193,7 +182,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "d48987b9",
    "metadata": {},
    "outputs": [],
@@ -219,21 +208,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 7,
    "id": "8ab79cdc",
    "metadata": {
     "lines_to_end_of_cell_marker": 2
    },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "monai.transforms.io.dictionary LoadImaged.__init__:image_only: Current default value of argument `image_only=False` has been deprecated since version 1.1. It will be changed to `image_only=True` in version 1.3.\n",
-      "monai.transforms.croppad.dictionary RandSpatialCropd.__init__:random_size: Current default value of argument `random_size=True` has been deprecated since version 1.1. It will be changed to `random_size=False` in version 1.3.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "preliminar_shape = input_shape + [50] # We take random slices fron the center of the brain\n",
     "crop_shape = input_shape + [1]\n",
@@ -277,7 +257,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 8,
    "id": "98d14e75",
    "metadata": {},
    "outputs": [
@@ -290,7 +270,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -320,7 +300,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "id": "fa17d864",
    "metadata": {},
    "outputs": [],
@@ -330,7 +310,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 10,
    "id": "8f126b17",
    "metadata": {},
    "outputs": [],
@@ -355,7 +335,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 11,
    "id": "255c90c7",
    "metadata": {},
    "outputs": [],
@@ -387,7 +367,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 12,
    "id": "c18dbad8",
    "metadata": {},
    "outputs": [],
@@ -407,7 +387,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 13,
    "id": "89989c34",
    "metadata": {},
    "outputs": [],
@@ -424,7 +404,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 14,
    "id": "5b8b676f",
    "metadata": {},
    "outputs": [],
@@ -445,7 +425,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 15,
    "id": "36ea4308",
    "metadata": {
     "scrolled": false
@@ -456,9 +436,7 @@
      "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=VGG16_Weights.IMAGENET1K_V1`. You can also use `weights=VGG16_Weights.DEFAULT` to get the most up-to-date weights.\n",
-      "Downloading: \"https://download.pytorch.org/models/vgg16-397923af.pth\" to /home/walter/.cache/torch/hub/checkpoints/vgg16-397923af.pth\n",
-      "100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 528M/528M [00:07<00:00, 77.9MB/s]\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=VGG16_Weights.IMAGENET1K_V1`. You can also use `weights=VGG16_Weights.DEFAULT` to get the most up-to-date weights.\n"
      ]
     }
    ],
@@ -472,7 +450,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 16,
    "id": "3b57abd3",
    "metadata": {},
    "outputs": [],
@@ -491,7 +469,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 27,
    "id": "918eac0a",
    "metadata": {
     "scrolled": false
@@ -508,13 +486,13 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|█████| 15/15 [00:16<00:00,  1.12s/it, kld=293, perceptual=0.339, generator=1.94, feature=0.125, discriminator=3.96]\n",
-      "  0%|               | 0/2 [00:00<?, ?it/s, kld=305, perceptual=0.351, generator=1.94, feature=0.124, discriminator=3.94]"
+      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=135, perceptual=0.221, generator=3.24, feature=0.113, discriminator=2.27]\n",
+      "  0%|                | 0/2 [00:00<?, ?it/s, kld=135, perceptual=0.246, generator=3.45, feature=0.126, discriminator=1.7]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -526,7 +504,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████| 2/2 [00:00<00:00,  3.21it/s, kld=197, perceptual=0.339, generator=1.93, feature=0.121, discriminator=3.94]"
+      "100%|██████| 2/2 [00:00<00:00,  3.22it/s, kld=63.6, perceptual=0.254, generator=3.38, feature=0.125, discriminator=1.77]"
      ]
     },
     {
@@ -541,8 +519,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.17it/s, kld=162, perceptual=0.361, generator=1.99, feature=0.127, discriminator=3.79]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.02it/s, kld=116, perceptual=0.324, generator=2.09, feature=0.131, discriminator=3.63]"
+      "100%|█████| 15/15 [00:06<00:00,  2.26it/s, kld=754, perceptual=0.354, generator=3.46, feature=0.168, discriminator=1.79]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.36it/s, kld=359, perceptual=0.36, generator=3.44, feature=0.173, discriminator=1.85]"
      ]
     },
     {
@@ -557,8 +535,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.15it/s, kld=155, perceptual=0.238, generator=2.41, feature=0.147, discriminator=3.03]\n",
-      "100%|████████| 2/2 [00:00<00:00,  3.92it/s, kld=179, perceptual=0.34, generator=2.41, feature=0.183, discriminator=2.95]"
+      "100%|█████| 15/15 [00:06<00:00,  2.17it/s, kld=298, perceptual=0.324, generator=3.57, feature=0.167, discriminator=1.58]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.07it/s, kld=346, perceptual=0.34, generator=3.57, feature=0.167, discriminator=1.63]"
      ]
     },
     {
@@ -573,8 +551,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=199, perceptual=0.286, generator=2.31, feature=0.164, discriminator=3.36]\n",
-      "100%|█████████| 2/2 [00:00<00:00,  4.28it/s, kld=144, perceptual=0.3, generator=2.53, feature=0.179, discriminator=2.68]"
+      "100%|███████| 15/15 [00:06<00:00,  2.27it/s, kld=313, perceptual=0.32, generator=3.57, feature=0.166, discriminator=1.6]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.36it/s, kld=262, perceptual=0.325, generator=3.49, feature=0.164, discriminator=1.63]"
      ]
     },
     {
@@ -589,8 +567,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.19it/s, kld=483, perceptual=0.47, generator=2.29, feature=0.238, discriminator=2.82]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.43it/s, kld=296, perceptual=0.449, generator=2.33, feature=0.237, discriminator=2.78]"
+      "100%|█████| 15/15 [00:06<00:00,  2.28it/s, kld=213, perceptual=0.305, generator=3.52, feature=0.168, discriminator=1.67]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.45it/s, kld=101, perceptual=0.307, generator=3.58, feature=0.164, discriminator=1.65]"
      ]
     },
     {
@@ -605,8 +583,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.25it/s, kld=258, perceptual=0.456, generator=2.84, feature=0.273, discriminator=2.15]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.31it/s, kld=150, perceptual=0.466, generator=2.83, feature=0.275, discriminator=2.15]"
+      "100%|██████| 15/15 [00:06<00:00,  2.23it/s, kld=119, perceptual=0.302, generator=3.6, feature=0.165, discriminator=1.51]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.79it/s, kld=68.9, perceptual=0.288, generator=3.58, feature=0.165, discriminator=1.61]"
      ]
     },
     {
@@ -621,8 +599,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.17it/s, kld=80.9, perceptual=0.406, generator=2.88, feature=0.245, discriminator=2.05]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.98it/s, kld=51.4, perceptual=0.422, generator=2.89, feature=0.249, discriminator=1.97]"
+      "100%|██████| 15/15 [00:06<00:00,  2.21it/s, kld=114, perceptual=0.286, generator=3.59, feature=0.163, discriminator=1.5]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.25it/s, kld=80, perceptual=0.278, generator=3.59, feature=0.161, discriminator=1.51]"
      ]
     },
     {
@@ -637,8 +615,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.19it/s, kld=101, perceptual=0.375, generator=2.75, feature=0.194, discriminator=2.1]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.16it/s, kld=73.3, perceptual=0.341, generator=2.81, feature=0.162, discriminator=2.65]"
+      "100%|████████| 15/15 [00:06<00:00,  2.28it/s, kld=116, perceptual=0.263, generator=3.6, feature=0.16, discriminator=1.5]\n",
+      "100%|█████████| 2/2 [00:00<00:00,  4.44it/s, kld=73.9, perceptual=0.269, generator=3.6, feature=0.16, discriminator=1.5]"
      ]
     },
     {
@@ -653,8 +631,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|███████| 15/15 [00:07<00:00,  2.14it/s, kld=130, perceptual=0.4, generator=2.91, feature=0.203, discriminator=1.89]\n",
-      "100%|███████| 2/2 [00:00<00:00,  3.42it/s, kld=101, perceptual=0.385, generator=2.94, feature=0.185, discriminator=2.08]"
+      "100%|███████| 15/15 [00:06<00:00,  2.22it/s, kld=100, perceptual=0.25, generator=3.6, feature=0.155, discriminator=1.53]\n",
+      "100%|█████████| 2/2 [00:00<00:00,  4.31it/s, kld=54.1, perceptual=0.26, generator=3.6, feature=0.154, discriminator=1.5]"
      ]
     },
     {
@@ -669,8 +647,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=156, perceptual=0.352, generator=2.68, feature=0.184, discriminator=2.03]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.28it/s, kld=97.8, perceptual=0.343, generator=2.63, feature=0.183, discriminator=2.08]"
+      "100%|████| 15/15 [00:06<00:00,  2.19it/s, kld=97.2, perceptual=0.243, generator=3.54, feature=0.149, discriminator=1.57]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.01it/s, kld=69.7, perceptual=0.252, generator=3.62, feature=0.141, discriminator=1.46]"
      ]
     },
     {
@@ -685,13 +663,13 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.25it/s, kld=159, perceptual=0.347, generator=2.92, feature=0.185, discriminator=1.76]\n",
-      "  0%|               | 0/2 [00:00<?, ?it/s, kld=166, perceptual=0.348, generator=2.94, feature=0.176, discriminator=1.93]"
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=106, perceptual=0.242, generator=3.52, feature=0.129, discriminator=1.72]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=176, perceptual=0.259, generator=3.51, feature=0.126, discriminator=1.64]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -703,7 +681,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████| 2/2 [00:00<00:00,  3.39it/s, kld=149, perceptual=0.372, generator=2.91, feature=0.186, discriminator=1.79]"
+      "100%|████████| 2/2 [00:00<00:00,  3.42it/s, kld=109, perceptual=0.258, generator=3.54, feature=0.128, discriminator=1.6]"
      ]
     },
     {
@@ -718,8 +696,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.20it/s, kld=155, perceptual=0.336, generator=2.94, feature=0.162, discriminator=2.13]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.88it/s, kld=98.6, perceptual=0.314, generator=2.96, feature=0.145, discriminator=2.31]"
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=413, perceptual=0.325, generator=3.21, feature=0.144, discriminator=2.18]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.80it/s, kld=252, perceptual=0.325, generator=3.39, feature=0.141, discriminator=1.88]"
      ]
     },
     {
@@ -734,8 +712,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.23it/s, kld=1.21e+3, perceptual=0.379, generator=2.97, feature=0.186, discriminator=1.68]\n",
-      "100%|██████████| 2/2 [00:00<00:00,  4.23it/s, kld=817, perceptual=0.401, generator=3, feature=0.189, discriminator=1.66]"
+      "100%|█████| 15/15 [00:06<00:00,  2.26it/s, kld=238, perceptual=0.311, generator=3.55, feature=0.169, discriminator=1.67]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.29it/s, kld=214, perceptual=0.317, generator=3.57, feature=0.17, discriminator=1.61]"
      ]
     },
     {
@@ -750,8 +728,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.21it/s, kld=118, perceptual=0.377, generator=3.04, feature=0.168, discriminator=2.01]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.45it/s, kld=72.6, perceptual=0.365, generator=3.06, feature=0.179, discriminator=1.59]"
+      "100%|█████| 15/15 [00:06<00:00,  2.25it/s, kld=110, perceptual=0.304, generator=3.57, feature=0.177, discriminator=1.55]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.01it/s, kld=53.1, perceptual=0.314, generator=3.58, feature=0.176, discriminator=1.5]"
      ]
     },
     {
@@ -766,8 +744,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.24it/s, kld=2.05e+3, perceptual=0.386, generator=2.48, feature=0.177, discriminator=2.18]\n",
-      "100%|███| 2/2 [00:00<00:00,  4.27it/s, kld=1.31e+3, perceptual=0.326, generator=2.54, feature=0.166, discriminator=2.24]"
+      "100%|████████| 15/15 [00:06<00:00,  2.16it/s, kld=129, perceptual=0.27, generator=3.6, feature=0.17, discriminator=1.52]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.45it/s, kld=83.5, perceptual=0.295, generator=3.6, feature=0.17, discriminator=1.47]"
      ]
     },
     {
@@ -782,8 +760,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.18it/s, kld=1.19e+3, perceptual=0.337, generator=2.82, feature=0.173, discriminator=1.79]\n",
-      "100%|████████| 2/2 [00:00<00:00,  4.00it/s, kld=730, perceptual=0.329, generator=2.82, feature=0.17, discriminator=1.78]"
+      "100%|████| 15/15 [00:06<00:00,  2.29it/s, kld=74.5, perceptual=0.254, generator=3.59, feature=0.166, discriminator=1.52]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.49it/s, kld=38.9, perceptual=0.285, generator=3.6, feature=0.166, discriminator=1.47]"
      ]
     },
     {
@@ -798,8 +776,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.18it/s, kld=383, perceptual=0.348, generator=2.8, feature=0.144, discriminator=1.78]\n",
-      "100%|████████| 2/2 [00:00<00:00,  3.79it/s, kld=204, perceptual=0.328, generator=2.87, feature=0.146, discriminator=1.8]"
+      "100%|██████| 15/15 [00:06<00:00,  2.29it/s, kld=103, perceptual=0.25, generator=3.63, feature=0.162, discriminator=1.45]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.36it/s, kld=80.4, perceptual=0.246, generator=3.6, feature=0.159, discriminator=1.47]"
      ]
     },
     {
@@ -814,8 +792,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.22it/s, kld=327, perceptual=0.349, generator=2.62, feature=0.0884, discriminator=3.06]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.21it/s, kld=198, perceptual=0.337, generator=2.67, feature=0.0891, discriminator=3.01]"
+      "100%|████| 15/15 [00:06<00:00,  2.28it/s, kld=95.8, perceptual=0.247, generator=3.62, feature=0.162, discriminator=1.44]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.44it/s, kld=60, perceptual=0.233, generator=3.51, feature=0.166, discriminator=1.59]"
      ]
     },
     {
@@ -830,8 +808,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.17it/s, kld=780, perceptual=0.363, generator=2.98, feature=0.0928, discriminator=2.89]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.25it/s, kld=522, perceptual=0.379, generator=2.94, feature=0.0919, discriminator=2.82]"
+      "100%|█████| 15/15 [00:06<00:00,  2.33it/s, kld=476, perceptual=0.248, generator=3.36, feature=0.152, discriminator=1.84]\n",
+      "100%|███████| 2/2 [00:00<00:00,  2.86it/s, kld=181, perceptual=0.251, generator=3.59, feature=0.172, discriminator=1.53]"
      ]
     },
     {
@@ -846,8 +824,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=711, perceptual=0.346, generator=1.89, feature=0.0815, discriminator=3.88]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.29it/s, kld=413, perceptual=0.327, generator=2.01, feature=0.0848, discriminator=3.68]"
+      "100%|██████| 15/15 [00:06<00:00,  2.23it/s, kld=478, perceptual=0.285, generator=3.52, feature=0.15, discriminator=1.87]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.42it/s, kld=483, perceptual=0.304, generator=2.73, feature=0.0971, discriminator=2.46]"
      ]
     },
     {
@@ -862,13 +840,13 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.17it/s, kld=329, perceptual=0.339, generator=2.13, feature=0.0703, discriminator=3.87]\n",
-      "  0%|              | 0/2 [00:00<?, ?it/s, kld=298, perceptual=0.338, generator=1.85, feature=0.0606, discriminator=3.84]"
+      "100%|█████| 15/15 [00:06<00:00,  2.20it/s, kld=725, perceptual=0.348, generator=3.31, feature=0.157, discriminator=1.78]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=805, perceptual=0.356, generator=3.32, feature=0.148, discriminator=1.71]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -880,7 +858,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████| 2/2 [00:00<00:00,  3.01it/s, kld=203, perceptual=0.336, generator=1.99, feature=0.078, discriminator=3.71]"
+      "100%|███████| 2/2 [00:00<00:00,  2.95it/s, kld=530, perceptual=0.346, generator=3.16, feature=0.143, discriminator=1.94]"
      ]
     },
     {
@@ -895,8 +873,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=174, perceptual=0.353, generator=2.58, feature=0.0856, discriminator=3.15]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.24it/s, kld=114, perceptual=0.274, generator=2.73, feature=0.0881, discriminator=3.83]"
+      "100%|██████| 15/15 [00:06<00:00,  2.24it/s, kld=143, perceptual=0.382, generator=3.6, feature=0.218, discriminator=1.46]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.35it/s, kld=80.1, perceptual=0.399, generator=3.61, feature=0.225, discriminator=1.44]"
      ]
     },
     {
@@ -911,8 +889,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.21it/s, kld=195, perceptual=0.36, generator=2.49, feature=0.106, discriminator=3.85]\n",
-      "100%|███████| 2/2 [00:00<00:00,  3.47it/s, kld=141, perceptual=0.343, generator=2.38, feature=0.0823, discriminator=3.8]"
+      "100%|█████| 15/15 [00:06<00:00,  2.25it/s, kld=179, perceptual=0.344, generator=3.59, feature=0.209, discriminator=1.51]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.43it/s, kld=91.7, perceptual=0.366, generator=3.62, feature=0.217, discriminator=1.38]"
      ]
     },
     {
@@ -927,8 +905,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=407, perceptual=0.355, generator=2.13, feature=0.0831, discriminator=3.37]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.19it/s, kld=190, perceptual=0.316, generator=2.47, feature=0.108, discriminator=3.25]"
+      "100%|██████| 15/15 [00:06<00:00,  2.21it/s, kld=336, perceptual=0.31, generator=3.59, feature=0.182, discriminator=1.49]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.46it/s, kld=216, perceptual=0.311, generator=3.6, feature=0.185, discriminator=1.48]"
      ]
     },
     {
@@ -943,8 +921,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.18it/s, kld=380, perceptual=0.375, generator=1.69, feature=0.108, discriminator=3.62]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.01it/s, kld=234, perceptual=0.348, generator=1.86, feature=0.103, discriminator=3.33]"
+      "100%|█████| 15/15 [00:06<00:00,  2.23it/s, kld=423, perceptual=0.271, generator=3.58, feature=0.157, discriminator=1.53]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.07it/s, kld=136, perceptual=0.269, generator=3.59, feature=0.168, discriminator=1.52]"
      ]
     },
     {
@@ -959,8 +937,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=207, perceptual=0.345, generator=1.8, feature=0.0924, discriminator=3.78]\n",
-      "100%|█████████| 2/2 [00:00<00:00,  4.41it/s, kld=129, perceptual=0.348, generator=1.97, feature=0.1, discriminator=3.72]"
+      "100%|██████| 15/15 [00:06<00:00,  2.26it/s, kld=349, perceptual=0.276, generator=3.6, feature=0.155, discriminator=1.45]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.41it/s, kld=220, perceptual=0.272, generator=3.61, feature=0.156, discriminator=1.45]"
      ]
     },
     {
@@ -975,8 +953,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.21it/s, kld=294, perceptual=0.334, generator=2.76, feature=0.119, discriminator=2.83]\n",
-      "100%|████████| 2/2 [00:00<00:00,  4.38it/s, kld=211, perceptual=0.355, generator=2.52, feature=0.123, discriminator=2.9]"
+      "100%|█████| 15/15 [00:06<00:00,  2.31it/s, kld=109, perceptual=0.265, generator=3.62, feature=0.156, discriminator=1.46]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.00it/s, kld=117, perceptual=0.246, generator=3.59, feature=0.157, discriminator=1.52]"
      ]
     },
     {
@@ -991,8 +969,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.20it/s, kld=384, perceptual=0.361, generator=2.86, feature=0.126, discriminator=2.7]\n",
-      "100%|███████| 2/2 [00:00<00:00,  3.77it/s, kld=164, perceptual=0.341, generator=3.05, feature=0.147, discriminator=2.77]"
+      "100%|█████| 15/15 [00:06<00:00,  2.27it/s, kld=209, perceptual=0.235, generator=3.61, feature=0.154, discriminator=1.47]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.47it/s, kld=120, perceptual=0.256, generator=3.61, feature=0.156, discriminator=1.43]"
      ]
     },
     {
@@ -1007,8 +985,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.22it/s, kld=257, perceptual=0.354, generator=1.4, feature=0.0816, discriminator=3.77]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.09it/s, kld=173, perceptual=0.356, generator=1.36, feature=0.0792, discriminator=3.7]"
+      "100%|██████| 15/15 [00:06<00:00,  2.33it/s, kld=146, perceptual=0.231, generator=3.61, feature=0.15, discriminator=1.44]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.35it/s, kld=76.3, perceptual=0.248, generator=3.61, feature=0.153, discriminator=1.41]"
      ]
     },
     {
@@ -1023,8 +1001,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.17it/s, kld=166, perceptual=0.366, generator=1.22, feature=0.0643, discriminator=3.9]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.98it/s, kld=92.5, perceptual=0.314, generator=1.46, feature=0.065, discriminator=3.55]"
+      "100%|█████| 15/15 [00:06<00:00,  2.28it/s, kld=180, perceptual=0.225, generator=3.59, feature=0.147, discriminator=1.45]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.18it/s, kld=98.1, perceptual=0.228, generator=3.6, feature=0.149, discriminator=1.43]"
      ]
     },
     {
@@ -1039,13 +1017,13 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=171, perceptual=0.331, generator=1.94, feature=0.0693, discriminator=3.74]\n",
-      "  0%|               | 0/2 [00:00<?, ?it/s, kld=196, perceptual=0.319, generator=1.9, feature=0.0694, discriminator=3.44]"
+      "100%|█████| 15/15 [00:06<00:00,  2.31it/s, kld=113, perceptual=0.233, generator=3.63, feature=0.145, discriminator=1.37]\n",
+      "  0%|                | 0/2 [00:00<?, ?it/s, kld=134, perceptual=0.217, generator=3.63, feature=0.143, discriminator=1.4]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -1057,7 +1035,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████| 2/2 [00:00<00:00,  3.36it/s, kld=143, perceptual=0.311, generator=1.89, feature=0.0648, discriminator=3.33]"
+      "100%|█████████| 2/2 [00:00<00:00,  3.31it/s, kld=90, perceptual=0.226, generator=3.6, feature=0.142, discriminator=1.43]"
      ]
     },
     {
@@ -1072,8 +1050,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.16it/s, kld=264, perceptual=0.363, generator=1.98, feature=0.0766, discriminator=3.99]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.75it/s, kld=178, perceptual=0.348, generator=1.96, feature=0.0681, discriminator=3.98]"
+      "100%|██████| 15/15 [00:06<00:00,  2.21it/s, kld=114, perceptual=0.227, generator=3.63, feature=0.145, discriminator=1.4]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.38it/s, kld=62.7, perceptual=0.212, generator=3.64, feature=0.144, discriminator=1.32]"
      ]
     },
     {
@@ -1088,8 +1066,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|███| 15/15 [00:06<00:00,  2.20it/s, kld=85.9, perceptual=0.308, generator=2.05, feature=0.0725, discriminator=3.94]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.43it/s, kld=55.1, perceptual=0.327, generator=2.17, feature=0.113, discriminator=3.84]"
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=102, perceptual=0.229, generator=3.62, feature=0.149, discriminator=1.36]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.42it/s, kld=89.2, perceptual=0.233, generator=3.63, feature=0.143, discriminator=1.36]"
      ]
     },
     {
@@ -1104,8 +1082,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.20it/s, kld=110, perceptual=0.293, generator=2.17, feature=0.0944, discriminator=3.92]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.94it/s, kld=110, perceptual=0.329, generator=2.01, feature=0.0707, discriminator=4.03]"
+      "100%|███████| 15/15 [00:06<00:00,  2.23it/s, kld=155, perceptual=0.2, generator=3.61, feature=0.144, discriminator=1.38]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.19it/s, kld=70.7, perceptual=0.226, generator=3.61, feature=0.144, discriminator=1.41]"
      ]
     },
     {
@@ -1120,8 +1098,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.26it/s, kld=203, perceptual=0.329, generator=2.42, feature=0.0917, discriminator=3.65]\n",
-      "100%|███████| 2/2 [00:00<00:00,  2.71it/s, kld=106, perceptual=0.29, generator=2.39, feature=0.0954, discriminator=3.58]"
+      "100%|██████| 15/15 [00:06<00:00,  2.24it/s, kld=118, perceptual=0.217, generator=3.6, feature=0.144, discriminator=1.38]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.08it/s, kld=77.5, perceptual=0.204, generator=3.62, feature=0.145, discriminator=1.37]"
      ]
     },
     {
@@ -1136,8 +1114,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=282, perceptual=0.28, generator=2.44, feature=0.0842, discriminator=3.62]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.21it/s, kld=206, perceptual=0.284, generator=2.42, feature=0.0789, discriminator=3.64]"
+      "100%|█████| 15/15 [00:06<00:00,  2.21it/s, kld=128, perceptual=0.199, generator=3.49, feature=0.138, discriminator=1.54]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.23it/s, kld=72.3, perceptual=0.219, generator=3.58, feature=0.146, discriminator=1.42]"
      ]
     },
     {
@@ -1152,8 +1130,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.20it/s, kld=313, perceptual=0.333, generator=2.3, feature=0.0794, discriminator=4.01]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.14it/s, kld=192, perceptual=0.285, generator=2.4, feature=0.0781, discriminator=4.01]"
+      "100%|█████| 15/15 [00:06<00:00,  2.29it/s, kld=137, perceptual=0.206, generator=3.62, feature=0.144, discriminator=1.37]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.47it/s, kld=98.9, perceptual=0.222, generator=3.63, feature=0.145, discriminator=1.42]"
      ]
     },
     {
@@ -1168,8 +1146,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=101, perceptual=0.297, generator=2.4, feature=0.0699, discriminator=3.96]\n",
-      "100%|█████| 2/2 [00:00<00:00,  3.69it/s, kld=56.2, perceptual=0.279, generator=2.44, feature=0.0671, discriminator=3.96]"
+      "100%|█████| 15/15 [00:06<00:00,  2.18it/s, kld=250, perceptual=0.227, generator=3.61, feature=0.148, discriminator=1.47]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.23it/s, kld=142, perceptual=0.217, generator=3.58, feature=0.148, discriminator=1.45]"
      ]
     },
     {
@@ -1184,8 +1162,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|███| 15/15 [00:06<00:00,  2.17it/s, kld=94.7, perceptual=0.296, generator=2.37, feature=0.0693, discriminator=3.91]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.23it/s, kld=64, perceptual=0.239, generator=2.42, feature=0.0572, discriminator=3.95]"
+      "100%|█████| 15/15 [00:06<00:00,  2.32it/s, kld=101, perceptual=0.208, generator=3.62, feature=0.145, discriminator=1.36]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.44it/s, kld=66.2, perceptual=0.211, generator=3.63, feature=0.145, discriminator=1.35]"
      ]
     },
     {
@@ -1200,8 +1178,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.22it/s, kld=154, perceptual=0.293, generator=2.28, feature=0.055, discriminator=3.9]\n",
-      "100%|███████| 2/2 [00:00<00:00,  3.99it/s, kld=93.5, perceptual=0.27, generator=2.25, feature=0.0545, discriminator=3.9]"
+      "100%|████| 15/15 [00:06<00:00,  2.25it/s, kld=99.7, perceptual=0.209, generator=3.61, feature=0.146, discriminator=1.37]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.83it/s, kld=74.2, perceptual=0.202, generator=3.62, feature=0.143, discriminator=1.38]"
      ]
     },
     {
@@ -1216,13 +1194,13 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.20it/s, kld=268, perceptual=0.227, generator=2.26, feature=0.052, discriminator=3.98]\n",
-      "  0%|              | 0/2 [00:00<?, ?it/s, kld=371, perceptual=0.264, generator=2.19, feature=0.0581, discriminator=3.92]"
+      "100%|██████| 15/15 [00:06<00:00,  2.25it/s, kld=132, perceptual=0.206, generator=3.6, feature=0.141, discriminator=1.37]\n",
+      "  0%|              | 0/2 [00:00<?, ?it/s, kld=93.6, perceptual=0.217, generator=3.63, feature=0.143, discriminator=1.33]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -1234,7 +1212,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████| 2/2 [00:00<00:00,  3.34it/s, kld=247, perceptual=0.269, generator=2.15, feature=0.056, discriminator=3.95]"
+      "100%|██████| 2/2 [00:00<00:00,  3.33it/s, kld=86.4, perceptual=0.205, generator=3.63, feature=0.142, discriminator=1.36]"
      ]
     },
     {
@@ -1249,8 +1227,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=195, perceptual=0.231, generator=2.14, feature=0.054, discriminator=4.01]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.25it/s, kld=128, perceptual=0.238, generator=2.14, feature=0.0585, discriminator=4.02]"
+      "100%|█████| 15/15 [00:06<00:00,  2.22it/s, kld=87.2, perceptual=0.208, generator=3.64, feature=0.138, discriminator=1.3]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.98it/s, kld=73.5, perceptual=0.197, generator=3.62, feature=0.141, discriminator=1.35]"
      ]
     },
     {
@@ -1265,8 +1243,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=312, perceptual=0.238, generator=2.29, feature=0.0563, discriminator=3.91]\n",
-      "100%|███████| 2/2 [00:00<00:00,  3.29it/s, kld=217, perceptual=0.24, generator=2.29, feature=0.0595, discriminator=3.89]"
+      "100%|█████| 15/15 [00:06<00:00,  2.25it/s, kld=120, perceptual=0.219, generator=3.62, feature=0.148, discriminator=1.34]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.48it/s, kld=55.8, perceptual=0.207, generator=3.63, feature=0.136, discriminator=1.33]"
      ]
     },
     {
@@ -1281,8 +1259,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=653, perceptual=0.225, generator=2.5, feature=0.0637, discriminator=3.79]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.31it/s, kld=390, perceptual=0.256, generator=2.43, feature=0.0642, discriminator=3.72]"
+      "100%|█████| 15/15 [00:06<00:00,  2.27it/s, kld=95.9, perceptual=0.198, generator=3.64, feature=0.135, discriminator=1.3]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.34it/s, kld=57.2, perceptual=0.209, generator=3.66, feature=0.135, discriminator=1.25]"
      ]
     },
     {
@@ -1297,8 +1275,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.21it/s, kld=860, perceptual=0.261, generator=2.38, feature=0.0658, discriminator=3.85]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.70it/s, kld=513, perceptual=0.241, generator=2.41, feature=0.0746, discriminator=3.82]"
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=128, perceptual=0.197, generator=3.62, feature=0.132, discriminator=1.34]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.98it/s, kld=82.2, perceptual=0.182, generator=3.62, feature=0.124, discriminator=1.35]"
      ]
     },
     {
@@ -1313,8 +1291,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.22it/s, kld=422, perceptual=0.282, generator=2.38, feature=0.0676, discriminator=3.99]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.23it/s, kld=325, perceptual=0.234, generator=2.5, feature=0.0701, discriminator=4.01]"
+      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=108, perceptual=0.184, generator=3.63, feature=0.126, discriminator=1.32]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.10it/s, kld=72.3, perceptual=0.195, generator=3.64, feature=0.132, discriminator=1.29]"
      ]
     },
     {
@@ -1329,8 +1307,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.19it/s, kld=2.07e+3, perceptual=0.257, generator=2.42, feature=0.0706, discriminator=3.89\n",
-      "100%|██| 2/2 [00:00<00:00,  3.85it/s, kld=1.21e+3, perceptual=0.247, generator=2.43, feature=0.0692, discriminator=3.88]"
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=115, perceptual=0.188, generator=3.62, feature=0.126, discriminator=1.32]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.20it/s, kld=60.3, perceptual=0.213, generator=3.65, feature=0.129, discriminator=1.27]"
      ]
     },
     {
@@ -1345,8 +1323,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=338, perceptual=0.263, generator=2.39, feature=0.0861, discriminator=4.03]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.18it/s, kld=248, perceptual=0.246, generator=2.5, feature=0.0764, discriminator=3.86]"
+      "100%|█████| 15/15 [00:06<00:00,  2.18it/s, kld=105, perceptual=0.206, generator=3.64, feature=0.127, discriminator=1.28]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.34it/s, kld=59.4, perceptual=0.202, generator=3.66, feature=0.125, discriminator=1.26]"
      ]
     },
     {
@@ -1361,8 +1339,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=331, perceptual=0.246, generator=2.47, feature=0.0839, discriminator=3.71]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.31it/s, kld=205, perceptual=0.243, generator=2.39, feature=0.088, discriminator=3.79]"
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=106, perceptual=0.176, generator=3.63, feature=0.128, discriminator=1.32]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.31it/s, kld=55.1, perceptual=0.21, generator=3.64, feature=0.134, discriminator=1.29]"
      ]
     },
     {
@@ -1377,8 +1355,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██| 15/15 [00:06<00:00,  2.19it/s, kld=3.41e+3, perceptual=0.248, generator=2.58, feature=0.12, discriminator=3.76]\n",
-      "100%|████| 2/2 [00:00<00:00,  3.71it/s, kld=2.19e+3, perceptual=0.26, generator=2.55, feature=0.125, discriminator=3.59]"
+      "100%|████| 15/15 [00:06<00:00,  2.26it/s, kld=88.5, perceptual=0.192, generator=3.62, feature=0.131, discriminator=1.33]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.29it/s, kld=63.5, perceptual=0.2, generator=3.61, feature=0.131, discriminator=1.35]"
      ]
     },
     {
@@ -1393,13 +1371,13 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.21it/s, kld=1.09e+3, perceptual=0.246, generator=2.76, feature=0.128, discriminator=3.32]\n",
-      "  0%|           | 0/2 [00:00<?, ?it/s, kld=1.13e+3, perceptual=0.237, generator=2.61, feature=0.107, discriminator=3.34]"
+      "100%|██████| 15/15 [00:06<00:00,  2.33it/s, kld=94.5, perceptual=0.2, generator=3.64, feature=0.129, discriminator=1.31]\n",
+      "  0%|              | 0/2 [00:00<?, ?it/s, kld=92.4, perceptual=0.198, generator=3.63, feature=0.134, discriminator=1.32]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -1411,7 +1389,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|███████| 2/2 [00:00<00:00,  3.31it/s, kld=704, perceptual=0.241, generator=2.83, feature=0.145, discriminator=3.18]"
+      "100%|██████| 2/2 [00:00<00:00,  3.45it/s, kld=52.4, perceptual=0.203, generator=3.65, feature=0.133, discriminator=1.27]"
      ]
     },
     {
@@ -1426,8 +1404,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.19it/s, kld=1.35e+3, perceptual=0.247, generator=1.95, feature=0.0697, discriminator=3.94\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.27it/s, kld=891, perceptual=0.269, generator=1.84, feature=0.0785, discriminator=4.04]"
+      "100%|████| 15/15 [00:06<00:00,  2.27it/s, kld=87.7, perceptual=0.192, generator=3.62, feature=0.131, discriminator=1.34]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.27it/s, kld=50.3, perceptual=0.207, generator=3.64, feature=0.133, discriminator=1.3]"
      ]
     },
     {
@@ -1442,8 +1420,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.25it/s, kld=373, perceptual=0.286, generator=1.98, feature=0.0785, discriminator=3.87]\n",
-      "100%|███████| 2/2 [00:00<00:00,  3.92it/s, kld=274, perceptual=0.285, generator=2.02, feature=0.0876, discriminator=3.8]"
+      "100%|████| 15/15 [00:06<00:00,  2.30it/s, kld=91.9, perceptual=0.184, generator=3.62, feature=0.127, discriminator=1.33]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.32it/s, kld=65.7, perceptual=0.182, generator=3.62, feature=0.128, discriminator=1.35]"
      ]
     },
     {
@@ -1458,8 +1436,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.16it/s, kld=637, perceptual=0.264, generator=2.5, feature=0.0888, discriminator=3.63]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.50it/s, kld=417, perceptual=0.268, generator=2.46, feature=0.0777, discriminator=3.49]"
+      "100%|████| 15/15 [00:06<00:00,  2.29it/s, kld=84.6, perceptual=0.193, generator=3.62, feature=0.136, discriminator=1.34]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.45it/s, kld=67.2, perceptual=0.176, generator=3.63, feature=0.129, discriminator=1.32]"
      ]
     },
     {
@@ -1474,8 +1452,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.23it/s, kld=584, perceptual=0.274, generator=2.46, feature=0.095, discriminator=3.23]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.24it/s, kld=420, perceptual=0.254, generator=2.53, feature=0.0873, discriminator=3.37]"
+      "100%|████████| 15/15 [00:06<00:00,  2.31it/s, kld=91.9, perceptual=0.2, generator=3.64, feature=0.14, discriminator=1.3]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.49it/s, kld=43.8, perceptual=0.204, generator=3.64, feature=0.133, discriminator=1.28]"
      ]
     },
     {
@@ -1490,8 +1468,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.19it/s, kld=842, perceptual=0.272, generator=1.82, feature=0.0686, discriminator=3.99]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.11it/s, kld=521, perceptual=0.256, generator=1.91, feature=0.0724, discriminator=3.97]"
+      "100%|█████| 15/15 [00:06<00:00,  2.29it/s, kld=118, perceptual=0.183, generator=3.64, feature=0.129, discriminator=1.28]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.44it/s, kld=71.7, perceptual=0.195, generator=3.6, feature=0.141, discriminator=1.37]"
      ]
     },
     {
@@ -1506,8 +1484,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.20it/s, kld=301, perceptual=0.292, generator=2.01, feature=0.0822, discriminator=3.88]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.03it/s, kld=169, perceptual=0.291, generator=2.27, feature=0.103, discriminator=3.59]"
+      "100%|██████| 15/15 [00:06<00:00,  2.35it/s, kld=102, perceptual=0.202, generator=3.63, feature=0.137, discriminator=1.3]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.18it/s, kld=64.4, perceptual=0.188, generator=3.62, feature=0.133, discriminator=1.33]"
      ]
     },
     {
@@ -1522,8 +1500,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.15it/s, kld=835, perceptual=0.302, generator=2.35, feature=0.104, discriminator=3.89]\n",
-      "100%|█████████| 2/2 [00:00<00:00,  4.33it/s, kld=517, perceptual=0.341, generator=2.3, feature=0.119, discriminator=3.6]"
+      "100%|████| 15/15 [00:06<00:00,  2.28it/s, kld=96.8, perceptual=0.181, generator=3.61, feature=0.125, discriminator=1.36]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.54it/s, kld=54.1, perceptual=0.201, generator=3.59, feature=0.136, discriminator=1.36]"
      ]
     },
     {
@@ -1538,8 +1516,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.18it/s, kld=425, perceptual=0.322, generator=2.7, feature=0.174, discriminator=3.03]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.24it/s, kld=245, perceptual=0.326, generator=2.72, feature=0.162, discriminator=3.07]"
+      "100%|█████| 15/15 [00:06<00:00,  2.33it/s, kld=137, perceptual=0.195, generator=3.62, feature=0.134, discriminator=1.35]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.09it/s, kld=64.9, perceptual=0.198, generator=3.63, feature=0.133, discriminator=1.32]"
      ]
     },
     {
@@ -1554,8 +1532,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=139, perceptual=0.302, generator=2.79, feature=0.149, discriminator=2.91]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.20it/s, kld=69.9, perceptual=0.284, generator=2.83, feature=0.137, discriminator=2.89]"
+      "100%|█████| 15/15 [00:06<00:00,  2.33it/s, kld=77.3, perceptual=0.189, generator=3.64, feature=0.13, discriminator=1.29]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.47it/s, kld=48.4, perceptual=0.187, generator=3.65, feature=0.132, discriminator=1.26]"
      ]
     },
     {
@@ -1570,13 +1548,13 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.20it/s, kld=210, perceptual=0.278, generator=2.84, feature=0.133, discriminator=2.84]\n",
-      "  0%|               | 0/2 [00:00<?, ?it/s, kld=106, perceptual=0.257, generator=2.91, feature=0.125, discriminator=2.81]"
+      "100%|████| 15/15 [00:07<00:00,  2.11it/s, kld=76.1, perceptual=0.179, generator=3.62, feature=0.132, discriminator=1.31]\n",
+      "  0%|                | 0/2 [00:00<?, ?it/s, kld=84, perceptual=0.175, generator=3.62, feature=0.127, discriminator=1.31]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -1588,7 +1566,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|████████| 2/2 [00:00<00:00,  3.44it/s, kld=132, perceptual=0.257, generator=2.86, feature=0.12, discriminator=2.85]"
+      "100%|██████| 2/2 [00:00<00:00,  3.59it/s, kld=45.9, perceptual=0.196, generator=3.65, feature=0.133, discriminator=1.26]"
      ]
     },
     {
@@ -1603,8 +1581,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=835, perceptual=0.266, generator=1.8, feature=0.0844, discriminator=3.96]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.26it/s, kld=767, perceptual=0.293, generator=1.72, feature=0.0979, discriminator=3.83]"
+      "100%|█████| 15/15 [00:06<00:00,  2.22it/s, kld=91.5, perceptual=0.192, generator=3.64, feature=0.134, discriminator=1.3]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.30it/s, kld=51.4, perceptual=0.175, generator=3.63, feature=0.127, discriminator=1.29]"
      ]
     },
     {
@@ -1619,8 +1597,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.19it/s, kld=908, perceptual=0.306, generator=1.62, feature=0.102, discriminator=3.5]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.25it/s, kld=568, perceptual=0.324, generator=1.66, feature=0.107, discriminator=3.45]"
+      "100%|████| 15/15 [00:06<00:00,  2.24it/s, kld=89.7, perceptual=0.199, generator=3.65, feature=0.132, discriminator=1.25]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.25it/s, kld=51.4, perceptual=0.179, generator=3.59, feature=0.133, discriminator=1.36]"
      ]
     },
     {
@@ -1635,8 +1613,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=865, perceptual=0.304, generator=1.54, feature=0.0938, discriminator=3.68]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.77it/s, kld=668, perceptual=0.295, generator=1.62, feature=0.0881, discriminator=3.65]"
+      "100%|██████| 15/15 [00:06<00:00,  2.22it/s, kld=85.4, perceptual=0.18, generator=3.61, feature=0.13, discriminator=1.34]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.02it/s, kld=69.2, perceptual=0.195, generator=3.62, feature=0.135, discriminator=1.33]"
      ]
     },
     {
@@ -1651,8 +1629,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=915, perceptual=0.272, generator=1.26, feature=0.074, discriminator=3.78]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.09it/s, kld=570, perceptual=0.299, generator=1.21, feature=0.0785, discriminator=3.76]"
+      "100%|██████| 15/15 [00:06<00:00,  2.30it/s, kld=113, perceptual=0.185, generator=3.64, feature=0.126, discriminator=1.3]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.46it/s, kld=67.6, perceptual=0.206, generator=3.65, feature=0.128, discriminator=1.27]"
      ]
     },
     {
@@ -1667,8 +1645,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.20it/s, kld=343, perceptual=0.268, generator=1.28, feature=0.0697, discriminator=3.87]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.37it/s, kld=209, perceptual=0.278, generator=1.2, feature=0.0735, discriminator=3.81]"
+      "100%|██████| 15/15 [00:06<00:00,  2.27it/s, kld=79, perceptual=0.163, generator=3.61, feature=0.124, discriminator=1.33]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.91it/s, kld=47.8, perceptual=0.198, generator=3.63, feature=0.133, discriminator=1.28]"
      ]
     },
     {
@@ -1683,8 +1661,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.25it/s, kld=495, perceptual=0.252, generator=1.18, feature=0.0635, discriminator=3.82]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.88it/s, kld=337, perceptual=0.267, generator=1.15, feature=0.0676, discriminator=3.88]"
+      "100%|██████| 15/15 [00:07<00:00,  2.13it/s, kld=80.8, perceptual=0.174, generator=3.63, feature=0.13, discriminator=1.3]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.20it/s, kld=62.5, perceptual=0.172, generator=3.63, feature=0.134, discriminator=1.3]"
      ]
     },
     {
@@ -1699,8 +1677,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.21it/s, kld=677, perceptual=0.271, generator=1.25, feature=0.0701, discriminator=3.95]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.08it/s, kld=563, perceptual=0.279, generator=1.11, feature=0.0637, discriminator=3.93]"
+      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=88.8, perceptual=0.208, generator=3.64, feature=0.135, discriminator=1.28]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.25it/s, kld=48.4, perceptual=0.196, generator=3.64, feature=0.135, discriminator=1.28]"
      ]
     },
     {
@@ -1715,8 +1693,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.29it/s, kld=373, perceptual=0.283, generator=1.24, feature=0.0668, discriminator=3.91]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.75it/s, kld=235, perceptual=0.266, generator=1.25, feature=0.0631, discriminator=3.89]"
+      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=100, perceptual=0.202, generator=3.63, feature=0.135, discriminator=1.29]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.05it/s, kld=61.3, perceptual=0.208, generator=3.65, feature=0.135, discriminator=1.27]"
      ]
     },
     {
@@ -1731,8 +1709,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.20it/s, kld=455, perceptual=0.275, generator=1.23, feature=0.0644, discriminator=3.96]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.21it/s, kld=363, perceptual=0.263, generator=1.19, feature=0.0624, discriminator=3.91]"
+      "100%|█████| 15/15 [00:06<00:00,  2.29it/s, kld=116, perceptual=0.201, generator=3.64, feature=0.134, discriminator=1.29]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.46it/s, kld=68, perceptual=0.188, generator=3.64, feature=0.132, discriminator=1.29]"
      ]
     },
     {
@@ -1747,13 +1725,13 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.23it/s, kld=519, perceptual=0.264, generator=1.29, feature=0.0628, discriminator=3.9]\n",
-      "  0%|               | 0/2 [00:00<?, ?it/s, kld=545, perceptual=0.26, generator=1.25, feature=0.0607, discriminator=3.91]"
+      "100%|█████| 15/15 [00:06<00:00,  2.21it/s, kld=74.7, perceptual=0.187, generator=3.63, feature=0.131, discriminator=1.3]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=94.5, perceptual=0.18, generator=3.62, feature=0.133, discriminator=1.32]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -1765,7 +1743,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████| 2/2 [00:00<00:00,  3.35it/s, kld=375, perceptual=0.261, generator=1.29, feature=0.0589, discriminator=3.89]"
+      "100%|███████| 2/2 [00:00<00:00,  3.44it/s, kld=54.3, perceptual=0.17, generator=3.64, feature=0.126, discriminator=1.29]"
      ]
     },
     {
@@ -1780,8 +1758,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=329, perceptual=0.242, generator=1.18, feature=0.0615, discriminator=4.02]\n",
-      "100%|███████| 2/2 [00:00<00:00,  3.73it/s, kld=205, perceptual=0.267, generator=1.16, feature=0.067, discriminator=3.97]"
+      "100%|█████| 15/15 [00:06<00:00,  2.21it/s, kld=102, perceptual=0.186, generator=3.65, feature=0.132, discriminator=1.27]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.29it/s, kld=63.4, perceptual=0.191, generator=3.66, feature=0.131, discriminator=1.25]"
      ]
     },
     {
@@ -1796,8 +1774,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=629, perceptual=0.233, generator=1.37, feature=0.0524, discriminator=3.98]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.20it/s, kld=417, perceptual=0.233, generator=1.38, feature=0.0535, discriminator=3.95]"
+      "100%|█████| 15/15 [00:06<00:00,  2.17it/s, kld=161, perceptual=0.191, generator=3.64, feature=0.132, discriminator=1.29]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.33it/s, kld=77.6, perceptual=0.165, generator=3.64, feature=0.13, discriminator=1.27]"
      ]
     },
     {
@@ -1812,8 +1790,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.16it/s, kld=198, perceptual=0.245, generator=1.45, feature=0.0611, discriminator=3.97]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.12it/s, kld=129, perceptual=0.263, generator=1.43, feature=0.071, discriminator=3.99]"
+      "100%|█████| 15/15 [00:06<00:00,  2.23it/s, kld=102, perceptual=0.185, generator=3.61, feature=0.132, discriminator=1.31]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.36it/s, kld=64.2, perceptual=0.204, generator=3.64, feature=0.137, discriminator=1.29]"
      ]
     },
     {
@@ -1828,8 +1806,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.22it/s, kld=466, perceptual=0.279, generator=1.78, feature=0.0656, discriminator=3.92]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.96it/s, kld=308, perceptual=0.278, generator=1.79, feature=0.0681, discriminator=3.86]"
+      "100%|█████| 15/15 [00:06<00:00,  2.18it/s, kld=71.9, perceptual=0.188, generator=3.63, feature=0.135, discriminator=1.3]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.13it/s, kld=50.9, perceptual=0.206, generator=3.65, feature=0.131, discriminator=1.26]"
      ]
     },
     {
@@ -1844,8 +1822,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.16it/s, kld=736, perceptual=0.245, generator=1.53, feature=0.0834, discriminator=4.15]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.08it/s, kld=668, perceptual=0.235, generator=1.41, feature=0.0861, discriminator=4.06]"
+      "100%|████| 15/15 [00:06<00:00,  2.25it/s, kld=72.6, perceptual=0.179, generator=3.65, feature=0.124, discriminator=1.26]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.15it/s, kld=44.3, perceptual=0.182, generator=3.58, feature=0.13, discriminator=1.34]"
      ]
     },
     {
@@ -1860,8 +1838,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=815, perceptual=0.277, generator=1.98, feature=0.129, discriminator=3.59]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.03it/s, kld=525, perceptual=0.268, generator=2.05, feature=0.133, discriminator=3.32]"
+      "100%|██████| 15/15 [00:06<00:00,  2.20it/s, kld=165, perceptual=0.177, generator=3.64, feature=0.131, discriminator=1.3]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.08it/s, kld=95, perceptual=0.205, generator=3.63, feature=0.138, discriminator=1.31]"
      ]
     },
     {
@@ -1876,8 +1854,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.24it/s, kld=1e+3, perceptual=0.276, generator=2.28, feature=0.115, discriminator=3.72]\n",
-      "100%|███████| 2/2 [00:00<00:00,  3.66it/s, kld=660, perceptual=0.282, generator=2.32, feature=0.133, discriminator=3.53]"
+      "100%|█████| 15/15 [00:06<00:00,  2.23it/s, kld=107, perceptual=0.179, generator=3.64, feature=0.126, discriminator=1.28]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.41it/s, kld=56.1, perceptual=0.203, generator=3.63, feature=0.138, discriminator=1.3]"
      ]
     },
     {
@@ -1892,8 +1870,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██| 15/15 [00:06<00:00,  2.21it/s, kld=1.36e+3, perceptual=0.279, generator=2.47, feature=0.14, discriminator=2.85]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.23it/s, kld=957, perceptual=0.297, generator=2.59, feature=0.138, discriminator=2.82]"
+      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=82.6, perceptual=0.174, generator=3.63, feature=0.126, discriminator=1.29]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.19it/s, kld=56.4, perceptual=0.19, generator=3.64, feature=0.136, discriminator=1.26]"
      ]
     },
     {
@@ -1908,8 +1886,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.22it/s, kld=2.86e+3, perceptual=0.311, generator=1.84, feature=0.142, discriminator=3.38]\n",
-      "100%|████| 2/2 [00:00<00:00,  3.54it/s, kld=2.04e+3, perceptual=0.328, generator=1.89, feature=0.148, discriminator=3.5]"
+      "100%|████| 15/15 [00:06<00:00,  2.29it/s, kld=88.3, perceptual=0.177, generator=3.65, feature=0.123, discriminator=1.26]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.33it/s, kld=55.7, perceptual=0.17, generator=3.65, feature=0.128, discriminator=1.24]"
      ]
     },
     {
@@ -1924,13 +1902,13 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.17it/s, kld=699, perceptual=0.338, generator=2.35, feature=0.14, discriminator=2.54]\n",
-      "  0%|               | 0/2 [00:00<?, ?it/s, kld=557, perceptual=0.317, generator=2.58, feature=0.145, discriminator=2.36]"
+      "100%|████| 15/15 [00:06<00:00,  2.26it/s, kld=92.4, perceptual=0.185, generator=3.62, feature=0.135, discriminator=1.31]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=122, perceptual=0.175, generator=3.64, feature=0.135, discriminator=1.28]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -1942,7 +1920,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|████████| 2/2 [00:00<00:00,  3.51it/s, kld=409, perceptual=0.331, generator=2.58, feature=0.147, discriminator=2.5]"
+      "100%|██████| 2/2 [00:00<00:00,  3.51it/s, kld=62.6, perceptual=0.191, generator=3.66, feature=0.132, discriminator=1.24]"
      ]
     },
     {
@@ -1957,8 +1935,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.25it/s, kld=491, perceptual=0.355, generator=2.74, feature=0.146, discriminator=2.93]\n",
-      "100%|███████| 2/2 [00:00<00:00,  2.61it/s, kld=359, perceptual=0.314, generator=2.85, feature=0.143, discriminator=2.95]"
+      "100%|████| 15/15 [00:06<00:00,  2.27it/s, kld=93.2, perceptual=0.183, generator=3.64, feature=0.132, discriminator=1.29]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.39it/s, kld=64.2, perceptual=0.197, generator=3.66, feature=0.13, discriminator=1.24]"
      ]
     },
     {
@@ -1973,8 +1951,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.24it/s, kld=517, perceptual=0.334, generator=2.67, feature=0.14, discriminator=3.12]\n",
-      "100%|████████| 2/2 [00:00<00:00,  3.93it/s, kld=384, perceptual=0.326, generator=2.72, feature=0.14, discriminator=3.09]"
+      "100%|████| 15/15 [00:06<00:00,  2.20it/s, kld=90.5, perceptual=0.176, generator=3.65, feature=0.131, discriminator=1.28]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.01it/s, kld=61.5, perceptual=0.199, generator=3.67, feature=0.131, discriminator=1.23]"
      ]
     },
     {
@@ -1989,8 +1967,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.22it/s, kld=1.27e+3, perceptual=0.302, generator=1.8, feature=0.0732, discriminator=4]\n",
-      "100%|███████| 2/2 [00:00<00:00,  3.94it/s, kld=815, perceptual=0.31, generator=1.76, feature=0.0643, discriminator=3.98]"
+      "100%|████| 15/15 [00:06<00:00,  2.26it/s, kld=89.7, perceptual=0.184, generator=3.66, feature=0.129, discriminator=1.24]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.12it/s, kld=61.7, perceptual=0.181, generator=3.66, feature=0.123, discriminator=1.25]"
      ]
     },
     {
@@ -2005,8 +1983,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.20it/s, kld=1.01e+3, perceptual=0.281, generator=1.79, feature=0.0657, discriminator=3.96\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.20it/s, kld=590, perceptual=0.263, generator=1.86, feature=0.071, discriminator=3.95]"
+      "100%|████| 15/15 [00:06<00:00,  2.22it/s, kld=89.6, perceptual=0.181, generator=3.65, feature=0.133, discriminator=1.25]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.47it/s, kld=46.8, perceptual=0.178, generator=3.65, feature=0.13, discriminator=1.26]"
      ]
     },
     {
@@ -2021,8 +1999,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=465, perceptual=0.253, generator=1.94, feature=0.0742, discriminator=3.63]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.08it/s, kld=329, perceptual=0.251, generator=1.95, feature=0.0817, discriminator=3.5]"
+      "100%|█████| 15/15 [00:06<00:00,  2.27it/s, kld=96.5, perceptual=0.192, generator=3.64, feature=0.13, discriminator=1.28]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.30it/s, kld=66.1, perceptual=0.19, generator=3.63, feature=0.133, discriminator=1.29]"
      ]
     },
     {
@@ -2037,8 +2015,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=862, perceptual=0.243, generator=1.09, feature=0.0589, discriminator=3.92]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.89it/s, kld=591, perceptual=0.238, generator=1.14, feature=0.0605, discriminator=3.81]"
+      "100%|█████| 15/15 [00:06<00:00,  2.23it/s, kld=150, perceptual=0.197, generator=3.65, feature=0.134, discriminator=1.27]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.41it/s, kld=72, perceptual=0.208, generator=3.62, feature=0.141, discriminator=1.32]"
      ]
     },
     {
@@ -2053,8 +2031,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.18it/s, kld=1.08e+3, perceptual=0.24, generator=1.74, feature=0.0678, discriminator=3.54]\n",
-      "100%|███████| 2/2 [00:00<00:00,  4.11it/s, kld=677, perceptual=0.231, generator=1.8, feature=0.0649, discriminator=3.91]"
+      "100%|██████| 15/15 [00:06<00:00,  2.26it/s, kld=119, perceptual=0.178, generator=3.63, feature=0.129, discriminator=1.3]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.19it/s, kld=81.4, perceptual=0.176, generator=3.63, feature=0.133, discriminator=1.28]"
      ]
     },
     {
@@ -2069,8 +2047,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█████| 15/15 [00:06<00:00,  2.21it/s, kld=958, perceptual=0.316, generator=1.8, feature=0.0715, discriminator=3.97]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.26it/s, kld=618, perceptual=0.301, generator=1.81, feature=0.0668, discriminator=3.96]"
+      "100%|██████| 15/15 [00:06<00:00,  2.23it/s, kld=102, perceptual=0.173, generator=3.64, feature=0.13, discriminator=1.26]\n",
+      "100%|███████| 2/2 [00:00<00:00,  4.28it/s, kld=54.9, perceptual=0.192, generator=3.63, feature=0.136, discriminator=1.3]"
      ]
     },
     {
@@ -2085,8 +2063,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|███| 15/15 [00:06<00:00,  2.16it/s, kld=1.17e+3, perceptual=0.311, generator=1.31, feature=0.0658, discriminator=4]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.89it/s, kld=989, perceptual=0.305, generator=1.23, feature=0.0674, discriminator=3.95]"
+      "100%|█████| 15/15 [00:06<00:00,  2.22it/s, kld=105, perceptual=0.178, generator=3.63, feature=0.137, discriminator=1.29]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.18it/s, kld=85.9, perceptual=0.173, generator=3.64, feature=0.129, discriminator=1.28]"
      ]
     },
     {
@@ -2101,13 +2079,13 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██| 15/15 [00:06<00:00,  2.23it/s, kld=2.17e+3, perceptual=0.294, generator=1.94, feature=0.101, discriminator=3.3]\n",
-      "  0%|          | 0/2 [00:00<?, ?it/s, kld=2.66e+3, perceptual=0.308, generator=1.75, feature=0.0698, discriminator=3.44]"
+      "100%|█████| 15/15 [00:06<00:00,  2.16it/s, kld=78.7, perceptual=0.17, generator=3.65, feature=0.132, discriminator=1.28]\n",
+      "  0%|               | 0/2 [00:00<?, ?it/s, kld=99.1, perceptual=0.18, generator=3.64, feature=0.134, discriminator=1.28]"
      ]
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 400x150 with 3 Axes>"
       ]
@@ -2119,7 +2097,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|█████| 2/2 [00:00<00:00,  2.79it/s, kld=1.5e+3, perceptual=0.301, generator=1.96, feature=0.12, discriminator=3.16]"
+      "100%|██████| 2/2 [00:00<00:00,  3.52it/s, kld=50.1, perceptual=0.159, generator=3.65, feature=0.126, discriminator=1.28]"
      ]
     },
     {
@@ -2134,8 +2112,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.24it/s, kld=1.88e+3, perceptual=0.29, generator=2.02, feature=0.0721, discriminator=3.34]\n",
-      "100%|██| 2/2 [00:00<00:00,  4.14it/s, kld=1.26e+3, perceptual=0.249, generator=1.96, feature=0.0852, discriminator=3.27]"
+      "100%|██████| 15/15 [00:06<00:00,  2.22it/s, kld=120, perceptual=0.175, generator=3.65, feature=0.13, discriminator=1.26]\n",
+      "100%|██████| 2/2 [00:00<00:00,  3.88it/s, kld=54.5, perceptual=0.193, generator=3.64, feature=0.136, discriminator=1.27]"
      ]
     },
     {
@@ -2150,8 +2128,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.19it/s, kld=1.49e+3, perceptual=0.253, generator=1.96, feature=0.0624, discriminator=3.82\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.80it/s, kld=862, perceptual=0.256, generator=1.96, feature=0.0589, discriminator=3.98]"
+      "100%|████| 15/15 [00:06<00:00,  2.16it/s, kld=85.1, perceptual=0.178, generator=3.67, feature=0.133, discriminator=1.22]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.22it/s, kld=56.2, perceptual=0.163, generator=3.66, feature=0.129, discriminator=1.24]"
      ]
     },
     {
@@ -2166,8 +2144,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|██████| 15/15 [00:06<00:00,  2.23it/s, kld=592, perceptual=0.252, generator=1.11, feature=0.108, discriminator=4.4]\n",
-      "100%|█████████| 2/2 [00:00<00:00,  3.92it/s, kld=365, perceptual=0.278, generator=1.19, feature=0.13, discriminator=4.5]"
+      "100%|██████| 15/15 [00:06<00:00,  2.19it/s, kld=98, perceptual=0.177, generator=3.64, feature=0.136, discriminator=1.27]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.38it/s, kld=63.8, perceptual=0.192, generator=3.66, feature=0.131, discriminator=1.24]"
      ]
     },
     {
@@ -2182,8 +2160,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.21it/s, kld=1.65e+3, perceptual=0.267, generator=1.77, feature=0.121, discriminator=3.45]\n",
-      "100%|███| 2/2 [00:00<00:00,  4.14it/s, kld=1.05e+3, perceptual=0.244, generator=1.85, feature=0.123, discriminator=3.18]"
+      "100%|█████| 15/15 [00:06<00:00,  2.22it/s, kld=117, perceptual=0.189, generator=3.64, feature=0.134, discriminator=1.29]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.20it/s, kld=62.4, perceptual=0.158, generator=3.63, feature=0.124, discriminator=1.29]"
      ]
     },
     {
@@ -2198,8 +2176,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|█| 15/15 [00:06<00:00,  2.24it/s, kld=1.53e+3, perceptual=0.279, generator=1.74, feature=0.114, discriminator=3.33]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.29it/s, kld=826, perceptual=0.259, generator=1.69, feature=0.0888, discriminator=3.51]"
+      "100%|█████| 15/15 [00:06<00:00,  2.24it/s, kld=115, perceptual=0.186, generator=3.67, feature=0.131, discriminator=1.22]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.25it/s, kld=72.7, perceptual=0.161, generator=3.64, feature=0.126, discriminator=1.28]"
      ]
     },
     {
@@ -2214,8 +2192,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.20it/s, kld=940, perceptual=0.264, generator=1.88, feature=0.0612, discriminator=3.97]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.26it/s, kld=580, perceptual=0.262, generator=1.55, feature=0.0873, discriminator=4.16]"
+      "100%|████| 15/15 [00:06<00:00,  2.16it/s, kld=83.2, perceptual=0.161, generator=3.66, feature=0.127, discriminator=1.24]\n",
+      "100%|████████| 2/2 [00:00<00:00,  4.27it/s, kld=76, perceptual=0.166, generator=3.65, feature=0.128, discriminator=1.27]"
      ]
     },
     {
@@ -2230,8 +2208,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=588, perceptual=0.275, generator=1.81, feature=0.0542, discriminator=3.85]\n",
-      "100%|██████| 2/2 [00:00<00:00,  3.94it/s, kld=549, perceptual=0.262, generator=1.94, feature=0.0645, discriminator=3.75]"
+      "100%|█████| 15/15 [00:06<00:00,  2.21it/s, kld=100, perceptual=0.173, generator=3.64, feature=0.128, discriminator=1.27]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.91it/s, kld=52.8, perceptual=0.16, generator=3.64, feature=0.122, discriminator=1.27]"
      ]
     },
     {
@@ -2246,8 +2224,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.18it/s, kld=658, perceptual=0.284, generator=1.73, feature=0.0515, discriminator=3.94]\n",
-      "100%|██████| 2/2 [00:00<00:00,  4.15it/s, kld=362, perceptual=0.271, generator=1.79, feature=0.0583, discriminator=3.94]"
+      "100%|█████| 15/15 [00:06<00:00,  2.19it/s, kld=105, perceptual=0.188, generator=3.63, feature=0.133, discriminator=1.29]\n",
+      "100%|██████| 2/2 [00:00<00:00,  4.30it/s, kld=66.9, perceptual=0.182, generator=3.66, feature=0.131, discriminator=1.22]"
      ]
     },
     {
@@ -2262,8 +2240,8 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "100%|████| 15/15 [00:06<00:00,  2.23it/s, kld=808, perceptual=0.281, generator=1.83, feature=0.0545, discriminator=3.86]\n",
-      "100%|██████| 2/2 [00:00<00:00,  2.92it/s, kld=598, perceptual=0.266, generator=1.79, feature=0.0619, discriminator=3.89]\n"
+      "100%|██████| 15/15 [00:06<00:00,  2.24it/s, kld=107, perceptual=0.164, generator=3.64, feature=0.126, discriminator=1.3]\n",
+      "100%|███████| 2/2 [00:00<00:00,  3.99it/s, kld=63.3, perceptual=0.16, generator=3.66, feature=0.129, discriminator=1.25]\n"
      ]
     }
    ],
@@ -2271,6 +2249,8 @@
     "net = net.to(device)\n",
     "discriminator = discriminator.to(device)\n",
     "torch.autograd.set_detect_anomaly(True)\n",
+    "losses = {'kld': [], 'perceptual': [], 'feature': [], 'generator': [], 'discriminator': []}\n",
+    "losses_val = {'kld': [], 'perceptual': [], 'feature': [], 'generator': [], 'discriminator': []}\n",
     "for epoch in range(num_epochs):\n",
     "    print(\"Epoch %d/%d\" %(epoch, num_epochs))\n",
     "    train_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=120)\n",
@@ -2355,22 +2335,78 @@
     "                             \"discriminator\": loss_d_r.item() + loss_g_f.item(),\n",
     "                            })\n",
     "            if step == 0 and epoch%10==0:\n",
-    "                picture_results(label, image, out)"
+    "                picture_results(label, image, out)\n",
+    "    for key, val in losses_epoch.items():\n",
+    "        losses[key].append(val / len(train_loader))\n",
+    "    for key, val in losses_epoch_val.items():\n",
+    "        losses_val[key].append(val / len(val_loader))\n",
+    "    "
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
-   "id": "f579376b",
+   "execution_count": 28,
+   "id": "d79c8ced",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 500x1000 with 5 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot losses\n",
+    "colors = ['orangered', 'royalblue', 'hotpink', 'lime', 'goldenrod']\n",
+    "plt.figure(figsize=(5,10))\n",
+    "ind = 0\n",
+    "for key, val in losses.items():\n",
+    "    plt.subplot(len(losses.keys()),1,ind+1)\n",
+    "    plt.plot(val, color = colors[ind], linestyle = '-')\n",
+    "    plt.plot(losses_val[key], color = colors[ind], linestyle = '--')\n",
+    "    plt.title(key)\n",
+    "    plt.xlabel(\"Epochs\")\n",
+    "    ind+=1;\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c3cf096f",
    "metadata": {
     "pycharm": {
      "name": "#%%"
     }
    },
-   "outputs": [],
    "source": [
-    "\n"
+    "**Conclusion**: from early on, the network shows the capability of discern between the different semantic layers. To achieve good image quality, more images and training time are needed (to avoid overfitting, seen in some loss plots of previous example), as well as thorough optimisation, such as establishing an adversarial schedule that makes sure that the discriminator and generator and the discriminator are trained only when their performance does not exceed a certain limit.\n"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false,
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8cf9ab5f",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
@@ -2392,9 +2428,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.9.16"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}
\ No newline at end of file
diff --git a/tutorials/generative/2d_spade_gan/2d_spade_vae.py b/tutorials/generative/2d_spade_gan/2d_spade_vae.py
index 1f2a93ac..3bb1f04f 100644
--- a/tutorials/generative/2d_spade_gan/2d_spade_vae.py
+++ b/tutorials/generative/2d_spade_gan/2d_spade_vae.py
@@ -239,6 +239,8 @@ def feature_loss(input_features_disc_fake, input_features_disc_real, lambda_feat
 net = net.to(device)
 discriminator = discriminator.to(device)
 torch.autograd.set_detect_anomaly(True)
+losses = {'kld': [], 'perceptual': [], 'feature': [], 'generator': [], 'discriminator': []}
+losses_val = {'kld': [], 'perceptual': [], 'feature': [], 'generator': [], 'discriminator': []}
 for epoch in range(num_epochs):
     print("Epoch %d/%d" %(epoch, num_epochs))
     train_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=120)
@@ -324,7 +326,29 @@ def feature_loss(input_features_disc_fake, input_features_disc_real, lambda_feat
                             })
             if step == 0 and epoch%10==0:
                 picture_results(label, image, out)
+    for key, val in losses_epoch.items():
+        losses[key].append(val / len(train_loader))
+    for key, val in losses_epoch_val.items():
+        losses_val[key].append(val / len(val_loader))
+
+
+# Plot losses
+colors = ['orangered', 'royalblue', 'hotpink', 'lime', 'goldenrod']
+plt.figure(figsize=(5,10))
+ind = 0
+for key, val in losses.items():
+    plt.subplot(len(losses.keys()),1,ind+1)
+    plt.plot(val, color = colors[ind], linestyle = '-')
+    plt.plot(losses_val[key], color = colors[ind], linestyle = '--')
+    plt.title(key)
+    plt.xlabel("Epochs")
+    ind+=1;
+plt.tight_layout()
+plt.show()
 
-# + pycharm={"name": "#%%"}
+# + [markdown] pycharm={"name": "#%%"}
+# **Conclusion**: from early on, the network shows the capability of discern between the different semantic layers. To achieve good image quality, more images and training time are needed (to avoid overfitting, seen in some loss plots of previous example), as well as thorough optimisation, such as establishing an adversarial schedule that makes sure that the discriminator and generator and the discriminator are trained only when their performance does not exceed a certain limit.
+#
+# -
 
 

From 39ed0f161b31c722c1f99f972a77231415a02b80 Mon Sep 17 00:00:00 2001
From: Mark Graham <markgraham539@gmail.com>
Date: Wed, 5 Jul 2023 10:22:11 -0600
Subject: [PATCH 6/7] Addresses hidden comments and runtests with autofix

---
 generative/losses/kld_loss.py                 |   5 +-
 generative/networks/blocks/spade_norm.py      |  90 ++---
 generative/networks/nets/spade_network.py     | 314 ++++++++++--------
 tests/test_spade_vaegan.py                    |  94 +++---
 .../2d_spade_gan/2d_spade_vae.ipynb           |  46 +--
 .../generative/2d_spade_gan/2d_spade_vae.py   | 274 +++++++--------
 6 files changed, 434 insertions(+), 389 deletions(-)

diff --git a/generative/losses/kld_loss.py b/generative/losses/kld_loss.py
index d3178b84..ebcaf52b 100644
--- a/generative/losses/kld_loss.py
+++ b/generative/losses/kld_loss.py
@@ -9,8 +9,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import torch.nn as nn
+from __future__ import annotations
+
 import torch
+import torch.nn as nn
+
 
 class KLDLoss(nn.Module):
     def forward(self, mu, logvar):
diff --git a/generative/networks/blocks/spade_norm.py b/generative/networks/blocks/spade_norm.py
index 419f740e..0fe735e8 100644
--- a/generative/networks/blocks/spade_norm.py
+++ b/generative/networks/blocks/spade_norm.py
@@ -10,80 +10,84 @@
 # limitations under the License.
 
 from __future__ import annotations
+
 import torch
 import torch.nn as nn
-from monai.networks.blocks import Convolution, ADN
 import torch.nn.functional as F
+from monai.networks.blocks import ADN, Convolution
+
 
 class SPADE(nn.Module):
     """
     SPADE normalisation block based on the 2019 paper by Park et al. (doi: https://doi.org/10.48550/arXiv.1903.07291)
+
     Args:
         label_nc: number of semantic labels
         norm_nc: number of output channels
         kernel_size: kernel size
         spatial_dims: number of spatial dimensions
         hidden_channels: number of channels in the intermediate gamma and beta layers
-        normalisation: type of base normalisation used before applying the SPADE normalisation
+        norm: type of base normalisation used before applying the SPADE normalisation
+        norm_params: parameters for the base normalisation
     """
-    def __init__(self,
-                 label_nc: int,
-                 norm_nc: int,
-                 kernel_size: int = 3,
-                 spatial_dims: int = 2,
-                 hidden_channels: int = 64,
-                 norm: str | tuple= "INSTANCE",
-                 norm_params: dict = {}
-                 )-> None:
+
+    def __init__(
+        self,
+        label_nc: int,
+        norm_nc: int,
+        kernel_size: int = 3,
+        spatial_dims: int = 2,
+        hidden_channels: int = 64,
+        norm: str | tuple = "INSTANCE",
+        norm_params: dict = {},
+    ) -> None:
 
         super().__init__()
 
         if len(norm_params) != 0:
             norm = (norm, norm_params)
-        self.param_free_norm = ADN(act=None, dropout=0.0, norm = norm,
-                                   norm_dim=spatial_dims,
-                                   ordering="N",
-                                   in_channels=norm_nc)
-        self.mlp_shared = Convolution(spatial_dims=spatial_dims,
-                                      in_channels = label_nc,
-                                      out_channels = hidden_channels,
-                                      kernel_size= kernel_size,
-                                      norm = None,
-                                      padding=kernel_size//2,
-                                      act="LEAKYRELU")
-        self.mlp_gamma = Convolution(spatial_dims=spatial_dims,
-                                     in_channels=hidden_channels,
-                                     out_channels=norm_nc,
-                                     kernel_size=kernel_size,
-                                     padding = kernel_size//2,
-                                     act = None
-                                     )
-        self.mlp_beta = Convolution(spatial_dims=spatial_dims,
-                                     in_channels=hidden_channels,
-                                     out_channels=norm_nc,
-                                     kernel_size=kernel_size,
-                                     padding = kernel_size//2,
-                                     act = None
-                                     )
-
+        self.param_free_norm = ADN(
+            act=None, dropout=0.0, norm=norm, norm_dim=spatial_dims, ordering="N", in_channels=norm_nc
+        )
+        self.mlp_shared = Convolution(
+            spatial_dims=spatial_dims,
+            in_channels=label_nc,
+            out_channels=hidden_channels,
+            kernel_size=kernel_size,
+            norm=None,
+            padding=kernel_size // 2,
+            act="LEAKYRELU",
+        )
+        self.mlp_gamma = Convolution(
+            spatial_dims=spatial_dims,
+            in_channels=hidden_channels,
+            out_channels=norm_nc,
+            kernel_size=kernel_size,
+            padding=kernel_size // 2,
+            act=None,
+        )
+        self.mlp_beta = Convolution(
+            spatial_dims=spatial_dims,
+            in_channels=hidden_channels,
+            out_channels=norm_nc,
+            kernel_size=kernel_size,
+            padding=kernel_size // 2,
+            act=None,
+        )
 
-    def forward(self,
-                x: torch.Tensor,
-                segmap: torch.Tensor) -> torch.Tensor:
+    def forward(self, x: torch.Tensor, segmap: torch.Tensor) -> torch.Tensor:
         """
         Args:
             x: input tensor
             segmap: input segmentation map (bxcx[spatial-dimensions]) where c is the number of semantic channels.
             The map will be interpolated to the dimension of x internally.
-        Returns:
-
         """
 
         # Part 1. generate parameter-free normalized activations
         normalized = self.param_free_norm(x)
 
         # Part 2. produce scaling and bias conditioned on semantic map
-        segmap = F.interpolate(segmap, size=x.size()[2:], mode='nearest')
+        segmap = F.interpolate(segmap, size=x.size()[2:], mode="nearest")
         actv = self.mlp_shared(segmap)
         gamma = self.mlp_gamma(actv)
         beta = self.mlp_beta(actv)
diff --git a/generative/networks/nets/spade_network.py b/generative/networks/nets/spade_network.py
index 0be1d9c8..b2ff2833 100644
--- a/generative/networks/nets/spade_network.py
+++ b/generative/networks/nets/spade_network.py
@@ -9,25 +9,32 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
+from typing import Sequence, Union
+
+import numpy as np
 import torch
 import torch.nn as nn
-from typing import Union, Sequence
-import numpy as np
+import torch.nn.functional as F
 from monai.networks.blocks import Convolution
 from monai.networks.layers import Act
-from generative.networks.blocks.spade_norm import SPADE
 from monai.utils.enums import StrEnum
-import torch.nn.functional as F
+
 from generative.losses.kld_loss import KLDLoss
+from generative.networks.blocks.spade_norm import SPADE
+
 
 class UpsamplingModes(StrEnum):
     bicubic = "bicubic"
     nearest = "nearest"
     bilinear = "bilinear"
 
+
 class SPADE_ResNetBlock(nn.Module):
     """
     Creates a Residual Block with SPADE normalisation.
+
     Args:
         spatial_dims: number of spatial dimensions
         in_channels: number of input channels
@@ -38,51 +45,67 @@ class SPADE_ResNetBlock(nn.Module):
         kernel_size: convolutional kernel size
     """
 
-    def __init__(self,
-                 spatial_dims: int,
-                 in_channels: int,
-                 out_channels: int,
-                 label_nc: int,
-                 spade_intermediate_channels: int = 128,
-                 norm: Union[str, tuple] = "INSTANCE",
-                 kernel_size: int = 3,):
+    def __init__(
+        self,
+        spatial_dims: int,
+        in_channels: int,
+        out_channels: int,
+        label_nc: int,
+        spade_intermediate_channels: int = 128,
+        norm: Union[str, tuple] = "INSTANCE",
+        kernel_size: int = 3,
+    ):
 
         super().__init__()
         self.in_channels = in_channels
         self.out_channels = out_channels
         self.int_channels = min(self.in_channels, self.out_channels)
         self.learned_shortcut = self.in_channels != self.out_channels
-        self.conv_0 = Convolution(spatial_dims = spatial_dims,
-                                  in_channels = self.in_channels,
-                                  out_channels = self.int_channels,
-                                  act = None,
-                                  norm = None,
-                                  )
-        self.conv_1 = Convolution(spatial_dims = spatial_dims,
-                                  in_channels = self.int_channels,
-                                  out_channels = self.out_channels,
-                                  act = None,
-                                  norm = None,
-                                  )
+        self.conv_0 = Convolution(
+            spatial_dims=spatial_dims, in_channels=self.in_channels, out_channels=self.int_channels, act=None, norm=None
+        )
+        self.conv_1 = Convolution(
+            spatial_dims=spatial_dims,
+            in_channels=self.int_channels,
+            out_channels=self.out_channels,
+            act=None,
+            norm=None,
+        )
         self.activation = nn.LeakyReLU(0.2, False)
-        self.norm_0 = SPADE(label_nc=label_nc, norm_nc=self.in_channels, kernel_size=kernel_size,
-                            spatial_dims=spatial_dims, hidden_channels=spade_intermediate_channels,
-                            norm=norm)
-        self.norm_1 = SPADE(label_nc=label_nc, norm_nc=self.int_channels, kernel_size=kernel_size,
-                            spatial_dims=spatial_dims, hidden_channels=spade_intermediate_channels,
-                            norm=norm)
+        self.norm_0 = SPADE(
+            label_nc=label_nc,
+            norm_nc=self.in_channels,
+            kernel_size=kernel_size,
+            spatial_dims=spatial_dims,
+            hidden_channels=spade_intermediate_channels,
+            norm=norm,
+        )
+        self.norm_1 = SPADE(
+            label_nc=label_nc,
+            norm_nc=self.int_channels,
+            kernel_size=kernel_size,
+            spatial_dims=spatial_dims,
+            hidden_channels=spade_intermediate_channels,
+            norm=norm,
+        )
 
         if self.learned_shortcut:
-            self.conv_s = Convolution(spatial_dims = spatial_dims,
-                                      in_channels = self.in_channels,
-                                      out_channels = self.out_channels,
-                                      act = None,
-                                      norm = None,
-                                      kernel_size=1,
-                                      )
-            self.norm_s = SPADE(label_nc=label_nc, norm_nc=self.in_channels, kernel_size=kernel_size,
-                                spatial_dims=spatial_dims, hidden_channels=spade_intermediate_channels,
-                                norm=norm)
+            self.conv_s = Convolution(
+                spatial_dims=spatial_dims,
+                in_channels=self.in_channels,
+                out_channels=self.out_channels,
+                act=None,
+                norm=None,
+                kernel_size=1,
+            )
+            self.norm_s = SPADE(
+                label_nc=label_nc,
+                norm_nc=self.in_channels,
+                kernel_size=kernel_size,
+                spatial_dims=spatial_dims,
+                hidden_channels=spade_intermediate_channels,
+                norm=norm,
+            )
 
     def forward(self, x, seg):
         x_s = self.shortcut(x, seg)
@@ -98,9 +121,11 @@ def shortcut(self, x, seg):
             x_s = x
         return x_s
 
+
 class SPADE_Encoder(nn.Module):
     """
     Encoding branch of a VAE compatible with a SPADE-like generator
+
     Args:
         spatial_dims: number of spatial dimensions
         in_channels: number of input channels
@@ -112,47 +137,58 @@ class SPADE_Encoder(nn.Module):
         norm: normalisation layer type
         act: activation type
     """
-    def __init__(self,
-                 spatial_dims: int,
-                 in_channels: int,
-                 z_dim: int,
-                 num_channels: Sequence[int],
-                 input_shape: Sequence[int],
-                 kernel_size: int = 3,
-                 norm: Union[str, tuple] = "INSTANCE",
-                 act: Union[str, tuple] = (Act.LEAKYRELU, {"negative_slope": 0.2})):
+
+    def __init__(
+        self,
+        spatial_dims: int,
+        in_channels: int,
+        z_dim: int,
+        num_channels: Sequence[int],
+        input_shape: Sequence[int],
+        kernel_size: int = 3,
+        norm: Union[str, tuple] = "INSTANCE",
+        act: Union[str, tuple] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
+    ):
 
         super().__init__()
         self.in_channels = in_channels
         self.z_dim = z_dim
         self.num_channels = num_channels
         if len(input_shape) != spatial_dims:
-            raise ValueError("Length of parameter input shape must match spatial_dims; got %s" %(input_shape))
+            raise ValueError("Length of parameter input shape must match spatial_dims; got %s" % (input_shape))
         for s_ind, s_ in enumerate(input_shape):
             if s_ / (2 ** len(num_channels)) != s_ // (2 ** len(num_channels)):
-                raise ValueError("Each dimension of your input must be divisible by 2 ** (autoencoder depth)."
-                                 "The shape in position %d, %d is not divisible by %d. " %(s_ind, s_, len(num_channels)))
+                raise ValueError(
+                    "Each dimension of your input must be divisible by 2 ** (autoencoder depth)."
+                    "The shape in position %d, %d is not divisible by %d. " % (s_ind, s_, len(num_channels))
+                )
         self.input_shape = input_shape
         self.latent_spatial_shape = [s_ // (2 ** len(self.num_channels)) for s_ in self.input_shape]
         blocks = []
         ch_init = self.in_channels
         for ch_ind, ch_value in enumerate(num_channels):
-            blocks.append(Convolution(spatial_dims = spatial_dims,
-                                      in_channels = ch_init,
-                                      out_channels= ch_value,
-                                      strides=2,
-                                      kernel_size=kernel_size,
-                                      norm = norm,
-                                      act = act))
+            blocks.append(
+                Convolution(
+                    spatial_dims=spatial_dims,
+                    in_channels=ch_init,
+                    out_channels=ch_value,
+                    strides=2,
+                    kernel_size=kernel_size,
+                    norm=norm,
+                    act=act,
+                )
+            )
             ch_init = ch_value
 
         self.blocks = nn.ModuleList(blocks)
-        self.fc_mu = nn.Linear(in_features=np.prod(self.latent_spatial_shape) * self.num_channels[-1],
-                                out_features=self.z_dim)
-        self.fc_var = nn.Linear(in_features=np.prod(self.latent_spatial_shape) * self.num_channels[-1],
-                                out_features=self.z_dim)
+        self.fc_mu = nn.Linear(
+            in_features=np.prod(self.latent_spatial_shape) * self.num_channels[-1], out_features=self.z_dim
+        )
+        self.fc_var = nn.Linear(
+            in_features=np.prod(self.latent_spatial_shape) * self.num_channels[-1], out_features=self.z_dim
+        )
 
-    def forward(self, x,):
+    def forward(self, x):
         for block in self.blocks:
             x = block(x)
         x = x.view(x.size(0), -1)
@@ -174,10 +210,12 @@ def reparameterize(self, mu, logvar):
         eps = torch.randn_like(std)
         return eps.mul(std) + mu
 
+
 class SPADE_Decoder(nn.Module):
     """
     Decoder branch of a SPADE-like generator. It can be used independently, without an encoding branch,
     behaving like a GAN, or coupled to a SPADE encoder.
+
     Args:
         label_nc: number of semantic labels
         spatial_dims: number of spatial dimensions
@@ -194,21 +232,23 @@ class SPADE_Decoder(nn.Module):
         kernel_size: convolutional kernel size
         upsampling_mode: upsampling mode (nearest, bilinear etc.)
     """
-    def __init__(self,
-                 spatial_dims: int,
-                 out_channels: int,
-                 label_nc: int,
-                 input_shape: Sequence[int],
-                 num_channels: Sequence[int],
-                 z_dim: Union[int, None] = None,
-                 is_gan: bool = False,
-                 spade_intermediate_channels: int = 128,
-                 norm: Union[str, tuple] = "INSTANCE",
-                 act:  Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
-                 last_act: Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
-                 kernel_size: int = 3,
-                 upsampling_mode: str = UpsamplingModes.nearest.value,
-                 ):
+
+    def __init__(
+        self,
+        spatial_dims: int,
+        out_channels: int,
+        label_nc: int,
+        input_shape: Sequence[int],
+        num_channels: Sequence[int],
+        z_dim: Union[int, None] = None,
+        is_gan: bool = False,
+        spade_intermediate_channels: int = 128,
+        norm: Union[str, tuple] = "INSTANCE",
+        act: Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
+        last_act: Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
+        kernel_size: int = 3,
+        upsampling_mode: str = UpsamplingModes.nearest.value,
+    ):
 
         super().__init__()
         self.is_gan = is_gan
@@ -219,9 +259,10 @@ def __init__(self,
             raise ValueError("Length of parameter input shape must match spatial_dims; got %s" % (input_shape))
         for s_ind, s_ in enumerate(input_shape):
             if s_ / (2 ** len(num_channels)) != s_ // (2 ** len(num_channels)):
-                raise ValueError("Each dimension of your input must be divisible by 2 ** (autoencoder depth)."
-                                 "The shape in position %d, %d is not divisible by %d. " % (
-                                 s_ind, s_, len(num_channels)))
+                raise ValueError(
+                    "Each dimension of your input must be divisible by 2 ** (autoencoder depth)."
+                    "The shape in position %d, %d is not divisible by %d. " % (s_ind, s_, len(num_channels))
+                )
         self.latent_spatial_shape = [s_ // (2 ** len(self.num_channels)) for s_ in input_shape]
 
         if self.is_gan:
@@ -233,24 +274,28 @@ def __init__(self,
         num_channels.append(self.out_channels)
         self.upsampling = torch.nn.Upsample(scale_factor=2, mode=upsampling_mode)
         for ch_ind, ch_value in enumerate(num_channels[:-1]):
-            blocks.append(SPADE_ResNetBlock(spatial_dims=spatial_dims,
-                                            in_channels=ch_value,
-                                            out_channels=num_channels[ch_ind+1],
-                                            label_nc=label_nc,
-                                            spade_intermediate_channels=spade_intermediate_channels,
-                                            norm=norm,
-                                            kernel_size=kernel_size),)
+            blocks.append(
+                SPADE_ResNetBlock(
+                    spatial_dims=spatial_dims,
+                    in_channels=ch_value,
+                    out_channels=num_channels[ch_ind + 1],
+                    label_nc=label_nc,
+                    spade_intermediate_channels=spade_intermediate_channels,
+                    norm=norm,
+                    kernel_size=kernel_size,
+                )
+            )
 
         self.blocks = torch.nn.ModuleList(blocks)
-        self.last_conv = Convolution(spatial_dims=spatial_dims,
-                                     in_channels=num_channels[-1],
-                                     out_channels=out_channels,
-                                     padding=(kernel_size-1)//2,
-                                     kernel_size=kernel_size,
-                                     norm = None,
-                                     act=last_act
-                                     )
-
+        self.last_conv = Convolution(
+            spatial_dims=spatial_dims,
+            in_channels=num_channels[-1],
+            out_channels=out_channels,
+            padding=(kernel_size - 1) // 2,
+            kernel_size=kernel_size,
+            norm=None,
+            act=last_act,
+        )
 
     def forward(self, seg, z: torch.Tensor = None):
         if self.is_gan:
@@ -258,10 +303,9 @@ def forward(self, seg, z: torch.Tensor = None):
             x = self.fc(x)
         else:
             if z is None:
-                z = torch.randn(seg.size(0), self.opt.z_dim,
-                                dtype=torch.float32, device=seg.get_device())
+                z = torch.randn(seg.size(0), self.opt.z_dim, dtype=torch.float32, device=seg.get_device())
             x = self.fc(z)
-            x = x.view(*[-1, self.num_channels[0]]+self.latent_spatial_shape)
+            x = x.view(*[-1, self.num_channels[0]] + self.latent_spatial_shape)
 
         for res_block in self.blocks:
             x = res_block(x, seg)
@@ -270,11 +314,13 @@ def forward(self, seg, z: torch.Tensor = None):
         x = self.last_conv(x)
         return x
 
+
 class SPADE_Net(nn.Module):
 
     """
     SPADE Network, implemented based on the code by Park, T et al. in "Semantic Image Synthesis with Spatially-Adaptive Normalization"
     (https://github.com/NVlabs/SPADE)
+
     Args:
         spatial_dims: number of spatial dimensions
         in_channels: number of input channels
@@ -293,22 +339,21 @@ class SPADE_Net(nn.Module):
     """
 
     def __init__(
-            self,
-            spatial_dims: int,
-            in_channels: int,
-            out_channels: int,
-            label_nc: int,
-            input_shape: Sequence[int],
-            num_channels: Sequence[int],
-            z_dim: Union[int, None] = None,
-            is_vae: bool = True,
-            spade_intermediate_channels: int = 128,
-            norm:Union[str, tuple]  = "INSTANCE",
-            act: Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
-            last_act: Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
-            kernel_size: int = 3,
-            upsampling_mode: str = UpsamplingModes.nearest.value
-
+        self,
+        spatial_dims: int,
+        in_channels: int,
+        out_channels: int,
+        label_nc: int,
+        input_shape: Sequence[int],
+        num_channels: Sequence[int],
+        z_dim: Union[int, None] = None,
+        is_vae: bool = True,
+        spade_intermediate_channels: int = 128,
+        norm: Union[str, tuple] = "INSTANCE",
+        act: Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
+        last_act: Union[str, tuple, None] = (Act.LEAKYRELU, {"negative_slope": 0.2}),
+        kernel_size: int = 3,
+        upsampling_mode: str = UpsamplingModes.nearest.value,
     ):
 
         super().__init__()
@@ -325,14 +370,15 @@ def __init__(
 
         if self.is_vae:
             self.encoder = SPADE_Encoder(
-                spatial_dims = spatial_dims,
-                in_channels = in_channels,
-                z_dim = z_dim,
-                num_channels = num_channels,
-                input_shape = input_shape,
-                kernel_size = kernel_size,
-                norm = norm,
-                act = act)
+                spatial_dims=spatial_dims,
+                in_channels=in_channels,
+                z_dim=z_dim,
+                num_channels=num_channels,
+                input_shape=input_shape,
+                kernel_size=kernel_size,
+                norm=norm,
+                act=act,
+            )
 
         decoder_channels = num_channels
         decoder_channels.reverse()
@@ -342,15 +388,15 @@ def __init__(
             out_channels=out_channels,
             label_nc=label_nc,
             input_shape=input_shape,
-            num_channels= decoder_channels,
-            z_dim = z_dim,
-            is_gan = not is_vae,
-            spade_intermediate_channels = spade_intermediate_channels,
-            norm = norm,
-            act = act,
-            last_act = last_act,
+            num_channels=decoder_channels,
+            z_dim=z_dim,
+            is_gan=not is_vae,
+            spade_intermediate_channels=spade_intermediate_channels,
+            norm=norm,
+            act=act,
+            last_act=last_act,
             kernel_size=kernel_size,
-            upsampling_mode=upsampling_mode
+            upsampling_mode=upsampling_mode,
         )
 
     def forward(self, seg: torch.Tensor, x: Union[torch.Tensor, None] = None):
@@ -361,7 +407,7 @@ def forward(self, seg: torch.Tensor, x: Union[torch.Tensor, None] = None):
             kld_loss = self.kld_loss(z_mu, z_logvar)
             return self.decoder(seg, z), kld_loss
         else:
-            return self.decoder(seg, z),
+            return (self.decoder(seg, z),)
 
     def encode(self, x: torch.Tensor):
 
diff --git a/tests/test_spade_vaegan.py b/tests/test_spade_vaegan.py
index 3354d4d6..e030b81e 100644
--- a/tests/test_spade_vaegan.py
+++ b/tests/test_spade_vaegan.py
@@ -10,79 +10,91 @@
 # limitations under the License.
 
 from __future__ import annotations
+
 import unittest
+
+import numpy as np
 import torch
 from monai.networks import eval_mode
 from parameterized import parameterized
-from networks.nets.spade_network import SPADE_Net
-import numpy as np
+
+from generative.networks.nets.spade_network import SPADE_Net
 
 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]]]
 CASE_3D = [[[3, 1, 1, 3, [64, 64, 64], [16, 32, 64, 128], 16, True]]]
 
-def create_Semantic_Data(shape:list, semantic_regions:int):
-    '''
+
+def create_semantic_data(shape: list, semantic_regions: int):
+    """
     To create semantic and image mock inputs for the network.
     Args:
         shape: input shape
         semantic_regions: number of semantic regions
     Returns:
-    '''
+    """
     out_label = torch.zeros(shape)
-    out_image = torch.zeros(shape) + torch.randn(shape)*0.01
+    out_image = torch.zeros(shape) + torch.randn(shape) * 0.01
     for i in range(1, semantic_regions):
-        shape_square = [i//np.random.choice(list(range(2, i//2))) for i in shape]
-        start_point = [np.random.choice(list(range(shape[ind]-shape_square[ind])))
-                       for ind, i in enumerate(shape)]
+        shape_square = [i // np.random.choice(list(range(2, i // 2))) for i in shape]
+        start_point = [np.random.choice(list(range(shape[ind] - shape_square[ind]))) for ind, i in enumerate(shape)]
         if len(shape) == 2:
-            out_label[start_point[0]:(start_point[0]+shape_square[0]),
-                      start_point[1]:(start_point[1]+shape_square[1])] = i
+            out_label[
+                start_point[0] : (start_point[0] + shape_square[0]), start_point[1] : (start_point[1] + shape_square[1])
+            ] = i
             base_intensity = torch.ones(shape_square) * np.random.randn()
-            out_image[start_point[0]:(start_point[0] + shape_square[0]),
-            start_point[1]:(start_point[1] + shape_square[1])] = base_intensity + \
-                                                           torch.randn(shape_square)*0.1
+            out_image[
+                start_point[0] : (start_point[0] + shape_square[0]), start_point[1] : (start_point[1] + shape_square[1])
+            ] = (base_intensity + torch.randn(shape_square) * 0.1)
         elif len(shape) == 3:
-            out_label[start_point[0]:(start_point[0]+shape_square[0]),
-                      start_point[1]:(start_point[1]+shape_square[1]),
-                      start_point[2]:(start_point[2] + shape_square[2])] = i
+            out_label[
+                start_point[0] : (start_point[0] + shape_square[0]),
+                start_point[1] : (start_point[1] + shape_square[1]),
+                start_point[2] : (start_point[2] + shape_square[2]),
+            ] = i
             base_intensity = torch.ones(shape_square) * np.random.randn()
-            out_image[start_point[0]:(start_point[0]+shape_square[0]),
-                      start_point[1]:(start_point[1]+shape_square[1]),
-                      start_point[2]:(start_point[2] + shape_square[2])] = base_intensity + \
-                                                           torch.randn(shape_square)*0.1
+            out_image[
+                start_point[0] : (start_point[0] + shape_square[0]),
+                start_point[1] : (start_point[1] + shape_square[1]),
+                start_point[2] : (start_point[2] + shape_square[2]),
+            ] = (base_intensity + torch.randn(shape_square) * 0.1)
         else:
             ValueError("Supports only 2D and 3D tensors")
 
     # One hot encode label
-    out_label_ = torch.zeros([semantic_regions,] + list(out_label.shape))
+    out_label_ = torch.zeros([semantic_regions] + list(out_label.shape))
     for ch in range(semantic_regions):
         out_label_[ch, ...] = out_label == ch
 
     return out_label_.unsqueeze(0), out_image.unsqueeze(0).unsqueeze(0)
 
-class TestDiffusionModelUNet2D(unittest.TestCase):
 
+class TestDiffusionModelUNet2D(unittest.TestCase):
     @parameterized.expand(CASE_2D)
     def test_forward_2d(self, input_param):
-        '''
+        """
         Check that forward method is called correctly and output shape matches.
-        '''
+        """
         net = SPADE_Net(*input_param)
-        in_label, in_image = create_Semantic_Data(input_param[4], input_param[3])
+        in_label, in_image = create_semantic_data(input_param[4], input_param[3])
         with eval_mode(net):
             out, kld = net(in_label, in_image)
-            self.assertEqual(False, True in torch.isnan(out) or True in torch.isinf(out)
-                             or True in torch.isinf(kld) or True in torch.isinf(kld))
+            self.assertEqual(
+                False,
+                True in torch.isnan(out)
+                or True in torch.isinf(out)
+                or True in torch.isinf(kld)
+                or True in torch.isinf(kld),
+            )
             self.assertEqual(list(out.shape), [1, 1, 64, 64])
 
     @parameterized.expand(CASE_2D_BIS)
     def test_encoder_decoder(self, input_param):
-        '''
+        """
         Check that forward method is called correctly and output shape matches.
-        '''
+        """
         net = SPADE_Net(*input_param)
-        in_label, in_image = create_Semantic_Data(input_param[4], input_param[3])
+        in_label, in_image = create_semantic_data(input_param[4], input_param[3])
         with eval_mode(net):
             out_z = net.encode(in_image)
             self.assertEqual(list(out_z.shape), [1, 16])
@@ -91,23 +103,29 @@ def test_encoder_decoder(self, input_param):
 
     @parameterized.expand(CASE_3D)
     def test_forward_3d(self, input_param):
-        '''
+        """
         Check that forward method is called correctly and output shape matches.
-        '''
+        """
         net = SPADE_Net(*input_param)
-        in_label, in_image = create_Semantic_Data(input_param[4], input_param[3])
+        in_label, in_image = create_semantic_data(input_param[4], input_param[3])
         with eval_mode(net):
             out, kld = net(in_label, in_image)
-            self.assertEqual(False, True in torch.isnan(out) or True in torch.isinf(out)
-                             or True in torch.isinf(kld) or True in torch.isinf(kld))
+            self.assertEqual(
+                False,
+                True in torch.isnan(out)
+                or True in torch.isinf(out)
+                or True in torch.isinf(kld)
+                or True in torch.isinf(kld),
+            )
             self.assertEqual(list(out.shape), [1, 1, 64, 64, 64])
 
     def test_shape_wrong(self):
-        '''
+        """
         We input an input shape that isn't divisible by 2**(n downstream steps)
-        '''
+        """
         with self.assertRaises(ValueError):
             net = SPADE_Net(1, 1, 8, [16, 16], [16, 32, 64, 128], 16, True)
 
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb b/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
index e5c64a3d..9f5333b6 100644
--- a/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
+++ b/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
@@ -65,9 +65,7 @@
    "cell_type": "code",
    "execution_count": 2,
    "id": "e76296e7",
-   "metadata": {
-    "scrolled": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stdout",
@@ -357,14 +355,6 @@
     "    plt.show()"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "eaa62145",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "code",
    "execution_count": 12,
@@ -427,9 +417,7 @@
    "cell_type": "code",
    "execution_count": 15,
    "id": "36ea4308",
-   "metadata": {
-    "scrolled": false
-   },
+   "metadata": {},
    "outputs": [
     {
      "name": "stderr",
@@ -472,7 +460,7 @@
    "execution_count": 27,
    "id": "918eac0a",
    "metadata": {
-    "scrolled": false
+    "lines_to_next_cell": 2
    },
    "outputs": [
     {
@@ -2339,8 +2327,7 @@
     "    for key, val in losses_epoch.items():\n",
     "        losses[key].append(val / len(train_loader))\n",
     "    for key, val in losses_epoch_val.items():\n",
-    "        losses_val[key].append(val / len(val_loader))\n",
-    "    "
+    "        losses_val[key].append(val / len(val_loader))"
    ]
   },
   {
@@ -2380,6 +2367,7 @@
    "cell_type": "markdown",
    "id": "c3cf096f",
    "metadata": {
+    "lines_to_next_cell": 0,
     "pycharm": {
      "name": "#%%"
     }
@@ -2387,26 +2375,6 @@
    "source": [
     "**Conclusion**: from early on, the network shows the capability of discern between the different semantic layers. To achieve good image quality, more images and training time are needed (to avoid overfitting, seen in some loss plots of previous example), as well as thorough optimisation, such as establishing an adversarial schedule that makes sure that the discriminator and generator and the discriminator are trained only when their performance does not exceed a certain limit.\n"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "outputs": [],
-   "source": [],
-   "metadata": {
-    "collapsed": false,
-    "pycharm": {
-     "name": "#%%\n"
-    }
-   }
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "8cf9ab5f",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -2428,9 +2396,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.16"
+   "version": "3.8.13"
   }
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
\ No newline at end of file
+}
diff --git a/tutorials/generative/2d_spade_gan/2d_spade_vae.py b/tutorials/generative/2d_spade_gan/2d_spade_vae.py
index 3bb1f04f..ec286f29 100644
--- a/tutorials/generative/2d_spade_gan/2d_spade_vae.py
+++ b/tutorials/generative/2d_spade_gan/2d_spade_vae.py
@@ -49,7 +49,7 @@
 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)
+print("Temporary directory used: %s " % root_dir)
 
 # INPUT PARAMETERS
 input_shape = [128, 128]
@@ -80,58 +80,63 @@
 # [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.
 #
 
-gdown.download("https://drive.google.com/uc?export=download&id=1SX_MCzQe-vyq09QYxECk32wZ2vxp9rx5",
-               str(root_dir / 'data.zip'))
+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 = 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)] + \
-             [os.path.join(images_FLAIR, i) for i in os.listdir(images_FLAIR)]
+all_images = [os.path.join(images_T1, i) for i in os.listdir(images_T1)] + [
+    os.path.join(images_FLAIR, i) for i in os.listdir(images_FLAIR)
+]
 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):]
+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
+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),
+    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'])
-    ]
+    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'])
-    ]
+    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)
@@ -146,11 +151,13 @@
 
 # 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')
+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()
 
 # ### Network creation and losses
@@ -168,25 +175,23 @@ def one_hot(input_label, label_nc):
     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')
+    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.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.subplot(1, 3, 3)
+    plt.imshow(output_image[0, 0, ...].detach().cpu(), cmap="gist_gray")
+    plt.axis("off")
     plt.title("Output image")
     plt.show()
 
 
-
 def feature_loss(input_features_disc_fake, input_features_disc_real, lambda_feat, device):
     criterion = torch.nn.L1Loss()
     num_D = len(input_features_disc_fake)
@@ -194,44 +199,43 @@ def feature_loss(input_features_disc_fake, input_features_disc_real, lambda_feat
     for i in range(num_D):  # for each discriminator
         num_intermediate_outputs = len(input_features_disc_fake[i])
         for j in range(num_intermediate_outputs):  # for each layer output
-            unweighted_loss = criterion(input_features_disc_fake[i][j],
-                                        input_features_disc_real[i][j].detach())
+            unweighted_loss = criterion(input_features_disc_fake[i][j], input_features_disc_real[i][j].detach())
             GAN_Feat_loss += unweighted_loss * lambda_feat / num_D
     return GAN_Feat_loss
 
 
-net = SPADE_Net(spatial_dims = 2,
-                in_channels = 1,
-                out_channels = 1,
-                label_nc = 6,
-                input_shape = input_shape,
-                num_channels = [16, 32, 64, 128],
-                z_dim = 16,
-                is_vae = True)
+net = SPADE_Net(
+    spatial_dims=2,
+    in_channels=1,
+    out_channels=1,
+    label_nc=6,
+    input_shape=input_shape,
+    num_channels=[16, 32, 64, 128],
+    z_dim=16,
+    is_vae=True,
+)
 
 # +
-discriminator = MultiScalePatchDiscriminator(num_d = 2,
-                                             num_layers_d = 3,
-                                             spatial_dims = 2,
-                                             num_channels = 8,
-                                             in_channels = 7,
-                                             out_channels = 7,
-                                             minimum_size_im = 128,
-                                             norm = "INSTANCE",
-                                             kernel_size = 3
-                                             )
-
-adversarial_loss = PatchAdversarialLoss(reduction = "sum", criterion = "hinge")
+discriminator = MultiScalePatchDiscriminator(
+    num_d=2,
+    num_layers_d=3,
+    spatial_dims=2,
+    num_channels=8,
+    in_channels=7,
+    out_channels=7,
+    minimum_size_im=128,
+    norm="INSTANCE",
+    kernel_size=3,
+)
+
+adversarial_loss = PatchAdversarialLoss(reduction="sum", criterion="hinge")
 # -
 
-perceptual_loss = PerceptualLoss(spatial_dims = 2,
-                                 network_type = "vgg",
-                                 is_fake_3d = False,
-                                 pretrained = True)
-perceptual_loss=perceptual_loss.to(device)
+perceptual_loss = PerceptualLoss(spatial_dims=2, network_type="vgg", is_fake_3d=False, pretrained=True)
+perceptual_loss = perceptual_loss.to(device)
 
-optimizer_G = torch.optim.Adam(net.parameters(), lr = 0.0002)
-optimizer_D = torch.optim.Adam(discriminator.parameters(), lr = 0.0004)
+optimizer_G = torch.optim.Adam(net.parameters(), lr=0.0002)
+optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=0.0004)
 
 # ### Training loop
 #
@@ -239,92 +243,96 @@ def feature_loss(input_features_disc_fake, input_features_disc_real, lambda_feat
 net = net.to(device)
 discriminator = discriminator.to(device)
 torch.autograd.set_detect_anomaly(True)
-losses = {'kld': [], 'perceptual': [], 'feature': [], 'generator': [], 'discriminator': []}
-losses_val = {'kld': [], 'perceptual': [], 'feature': [], 'generator': [], 'discriminator': []}
+losses = {"kld": [], "perceptual": [], "feature": [], "generator": [], "discriminator": []}
+losses_val = {"kld": [], "perceptual": [], "feature": [], "generator": [], "discriminator": []}
 for epoch in range(num_epochs):
-    print("Epoch %d/%d" %(epoch, num_epochs))
+    print("Epoch %d/%d" % (epoch, num_epochs))
     train_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=120)
-    losses_epoch = {'kld': 0, 'perceptual': 0, 'feature': 0, 'generator': 0, 'discriminator': 0}
+    losses_epoch = {"kld": 0, "perceptual": 0, "feature": 0, "generator": 0, "discriminator": 0}
     for step, d in train_bar:
-        image = d['image'].to(device)
+        image = d["image"].to(device)
         with torch.no_grad():
-            label = one_hot(d['label'], 6).to(device)
+            label = one_hot(d["label"], 6).to(device)
         optimizer_G.zero_grad()
 
         # Losses gen
         out, kld_loss = net(label, image)
         disc_fakes, features_fakes = discriminator(torch.cat([out, label], 1))
-        loss_g = adversarial_loss(disc_fakes, target_is_real = True, for_discriminator = False)
+        loss_g = adversarial_loss(disc_fakes, target_is_real=True, for_discriminator=False)
         disc_reals, features_reals = discriminator(torch.cat([image, label], 1))
         loss_feat = feature_loss(features_fakes, features_reals, lambda_feat, device)
-        loss_perc = perceptual_loss(out, target = image)
-        total_loss = loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat  * lambda_feat
-        total_loss.backward(retain_graph = True)
+        loss_perc = perceptual_loss(out, target=image)
+        total_loss = loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat * lambda_feat
+        total_loss.backward(retain_graph=True)
         optimizer_G.step()
 
         # Store
-        losses_epoch['kld'] += kld_loss.item()
-        losses_epoch['perceptual'] += loss_perc.item()
-        losses_epoch['generator'] += loss_g.item()
-        #Train disc
+        losses_epoch["kld"] += kld_loss.item()
+        losses_epoch["perceptual"] += loss_perc.item()
+        losses_epoch["generator"] += loss_g.item()
+        # Train disc
         out, _ = net(label, image)
         disc_fakes, _ = discriminator(torch.cat([out, label], 1))
-        loss_d_r = adversarial_loss(disc_reals, target_is_real = True, for_discriminator = True)
-        loss_g_f = adversarial_loss(disc_fakes, target_is_real = False, for_discriminator = True)
+        loss_d_r = adversarial_loss(disc_reals, target_is_real=True, for_discriminator=True)
+        loss_g_f = adversarial_loss(disc_fakes, target_is_real=False, for_discriminator=True)
         optimizer_D.zero_grad()
         loss_d = loss_d_r + loss_g_f
         loss_d.backward()
         optimizer_D.step()
 
         # Store
-        losses_epoch['feature'] = loss_feat.item()
-        losses_epoch['discriminator'] = loss_d_r.item() + loss_g_f.item()
+        losses_epoch["feature"] = loss_feat.item()
+        losses_epoch["discriminator"] = loss_d_r.item() + loss_g_f.item()
 
         train_bar.set_postfix(
-                        {"kld": kld_loss.item(),
-                         "perceptual": loss_perc.item(),
-                         "generator": loss_g.item(),
-                         "feature": loss_feat.item(),
-                         "discriminator": loss_d_r.item() + loss_g_f.item(),
-                        })
+            {
+                "kld": kld_loss.item(),
+                "perceptual": loss_perc.item(),
+                "generator": loss_g.item(),
+                "feature": loss_feat.item(),
+                "discriminator": loss_d_r.item() + loss_g_f.item(),
+            }
+        )
 
     val_bar = tqdm(enumerate(val_loader), total=len(val_loader), ncols=120)
-    losses_epoch_val = {'kld': 0, 'perceptual': 0, 'feature': 0, 'generator': 0, 'discriminator': 0}
+    losses_epoch_val = {"kld": 0, "perceptual": 0, "feature": 0, "generator": 0, "discriminator": 0}
     for step, d in val_bar:
-        image = d['image'].to(device)
+        image = d["image"].to(device)
         with torch.no_grad():
-            label = one_hot(d['label'], 6).to(device)
+            label = one_hot(d["label"], 6).to(device)
             # Losses gen
             out, kld_loss = net(label, image)
             disc_fakes, features_fakes = discriminator(torch.cat([out, label], 1))
-            loss_g = adversarial_loss(disc_fakes, target_is_real = True, for_discriminator = False)
+            loss_g = adversarial_loss(disc_fakes, target_is_real=True, for_discriminator=False)
             disc_reals, features_reals = discriminator(torch.cat([image, label], 1))
             loss_feat = feature_loss(features_fakes, features_reals, lambda_feat, device)
-            loss_perc = perceptual_loss(out, target = image)
-            total_loss = loss_adv * loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat  * lambda_feat
+            loss_perc = perceptual_loss(out, target=image)
+            total_loss = loss_adv * loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat * lambda_feat
             # Store
-            losses_epoch_val['kld'] += kld_loss.item()
-            losses_epoch_val['perceptual'] += loss_perc.item()
-            losses_epoch_val['generator'] += loss_g.item()
-            #Train disc
+            losses_epoch_val["kld"] += kld_loss.item()
+            losses_epoch_val["perceptual"] += loss_perc.item()
+            losses_epoch_val["generator"] += loss_g.item()
+            # Train disc
             out, _ = net(label, image)
             disc_fakes, _ = discriminator(torch.cat([out, label], 1))
-            loss_d_r = adversarial_loss(disc_reals, target_is_real = True, for_discriminator = True)
-            loss_g_f = adversarial_loss(disc_fakes, target_is_real = False, for_discriminator = True)
+            loss_d_r = adversarial_loss(disc_reals, target_is_real=True, for_discriminator=True)
+            loss_g_f = adversarial_loss(disc_fakes, target_is_real=False, for_discriminator=True)
             loss_d = loss_adv * (loss_d_r + loss_g_f)
 
             # Store
-            losses_epoch_val['feature'] = loss_feat.item()
-            losses_epoch_val['discriminator'] = loss_d_r.item() + loss_g_f.item()
+            losses_epoch_val["feature"] = loss_feat.item()
+            losses_epoch_val["discriminator"] = loss_d_r.item() + loss_g_f.item()
 
             val_bar.set_postfix(
-                            {"kld": kld_loss.item(),
-                             "perceptual": loss_perc.item(),
-                             "generator": loss_g.item(),
-                             "feature": loss_feat.item(),
-                             "discriminator": loss_d_r.item() + loss_g_f.item(),
-                            })
-            if step == 0 and epoch%10==0:
+                {
+                    "kld": kld_loss.item(),
+                    "perceptual": loss_perc.item(),
+                    "generator": loss_g.item(),
+                    "feature": loss_feat.item(),
+                    "discriminator": loss_d_r.item() + loss_g_f.item(),
+                }
+            )
+            if step == 0 and epoch % 10 == 0:
                 picture_results(label, image, out)
     for key, val in losses_epoch.items():
         losses[key].append(val / len(train_loader))
@@ -333,16 +341,16 @@ def feature_loss(input_features_disc_fake, input_features_disc_real, lambda_feat
 
 
 # Plot losses
-colors = ['orangered', 'royalblue', 'hotpink', 'lime', 'goldenrod']
-plt.figure(figsize=(5,10))
+colors = ["orangered", "royalblue", "hotpink", "lime", "goldenrod"]
+plt.figure(figsize=(5, 10))
 ind = 0
 for key, val in losses.items():
-    plt.subplot(len(losses.keys()),1,ind+1)
-    plt.plot(val, color = colors[ind], linestyle = '-')
-    plt.plot(losses_val[key], color = colors[ind], linestyle = '--')
+    plt.subplot(len(losses.keys()), 1, ind + 1)
+    plt.plot(val, color=colors[ind], linestyle="-")
+    plt.plot(losses_val[key], color=colors[ind], linestyle="--")
     plt.title(key)
     plt.xlabel("Epochs")
-    ind+=1;
+    ind += 1
 plt.tight_layout()
 plt.show()
 
@@ -350,5 +358,3 @@ def feature_loss(input_features_disc_fake, input_features_disc_real, lambda_feat
 # **Conclusion**: from early on, the network shows the capability of discern between the different semantic layers. To achieve good image quality, more images and training time are needed (to avoid overfitting, seen in some loss plots of previous example), as well as thorough optimisation, such as establishing an adversarial schedule that makes sure that the discriminator and generator and the discriminator are trained only when their performance does not exceed a certain limit.
 #
 # -
-
-

From 1b421954a9f08070c5d1aa3231abf85092ca8627 Mon Sep 17 00:00:00 2001
From: Mark Graham <markgraham539@gmail.com>
Date: Wed, 5 Jul 2023 10:25:08 -0600
Subject: [PATCH 7/7] Fix tutorial formatting

---
 .../2d_spade_gan/2d_spade_vae.ipynb           | 277 +++++++++---------
 1 file changed, 139 insertions(+), 138 deletions(-)

diff --git a/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb b/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
index 9f5333b6..125ecd8b 100644
--- a/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
+++ b/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
@@ -79,7 +79,7 @@
     "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)"
+    "print(\"Temporary directory used: %s \" % root_dir)"
    ]
   },
   {
@@ -160,8 +160,9 @@
     }
    ],
    "source": [
-    "gdown.download(\"https://drive.google.com/uc?export=download&id=1SX_MCzQe-vyq09QYxECk32wZ2vxp9rx5\",\n",
-    "               str(root_dir / 'data.zip'))"
+    "gdown.download(\n",
+    "    \"https://drive.google.com/uc?export=download&id=1SX_MCzQe-vyq09QYxECk32wZ2vxp9rx5\", str(root_dir / \"data.zip\")\n",
+    ")"
    ]
   },
   {
@@ -171,7 +172,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "zip_obj = zipfile.ZipFile(os.path.join(root_dir, 'data.zip'), 'r')\n",
+    "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",
@@ -186,14 +187,16 @@
    "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",
-    "             [os.path.join(images_FLAIR, i) for i in os.listdir(images_FLAIR)]\n",
+    "all_images = [os.path.join(images_T1, i) for i in os.listdir(images_T1)] + [\n",
+    "    os.path.join(images_FLAIR, i) for i in os.listdir(images_FLAIR)\n",
+    "]\n",
     "np.random.shuffle(all_images)\n",
-    "corresponding_labels = [os.path.join(labels, i.split(\"/\")[-1].replace(i.split(\"/\")[-1].split(\"_\")[0], \"Parcellation\"))\n",
-    "                        for i in all_images]\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):]"
+    "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) :]"
    ]
   },
   {
@@ -213,36 +216,38 @@
    },
    "outputs": [],
    "source": [
-    "preliminar_shape = input_shape + [50] # We take random slices fron the center of the brain\n",
+    "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'],\n",
-    "                                                     roi_size=preliminar_shape),\n",
-    "    monai.transforms.RandSpatialCropd(keys = ['label', 'image'],\n",
-    "                                             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",
+    "    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'],\n",
-    "                             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",
+    "    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),\n",
-    "                                        keys=['image']),\n",
-    "        monai.transforms.RandAffined(rotate_range=[-0.05, 0.05], shear_range=[0.001, 0.05],\n",
-    "                                     scale_range=[0, 0.05], padding_mode='zeros',\n",
-    "                                     mode='nearest', prob=0.33, keys=['label', 'image'])\n",
-    "    ]\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",
@@ -280,11 +285,13 @@
    "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'); plt.axis('off')\n",
-    "plt.subplot(1,2,2)\n",
-    "plt.imshow(batch['label'][0,0,...], cmap = \"jet\"); plt.axis('off')\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()"
    ]
   },
@@ -323,14 +330,6 @@
     "    return label_out"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "6af2779b",
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
   {
    "cell_type": "code",
    "execution_count": 11,
@@ -339,18 +338,18 @@
    "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",
+    "    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.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.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()"
    ]
@@ -369,8 +368,7 @@
     "    for i in range(num_D):  # for each discriminator\n",
     "        num_intermediate_outputs = len(input_features_disc_fake[i])\n",
     "        for j in range(num_intermediate_outputs):  # for each layer output\n",
-    "            unweighted_loss = criterion(input_features_disc_fake[i][j],\n",
-    "                                        input_features_disc_real[i][j].detach())\n",
+    "            unweighted_loss = criterion(input_features_disc_fake[i][j], input_features_disc_real[i][j].detach())\n",
     "            GAN_Feat_loss += unweighted_loss * lambda_feat / num_D\n",
     "    return GAN_Feat_loss"
    ]
@@ -382,14 +380,16 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "net = SPADE_Net(spatial_dims = 2,\n",
-    "                in_channels = 1,\n",
-    "                out_channels = 1,\n",
-    "                label_nc = 6,\n",
-    "                input_shape = input_shape,\n",
-    "                num_channels = [16, 32, 64, 128],\n",
-    "                z_dim = 16,\n",
-    "                is_vae = True)"
+    "net = SPADE_Net(\n",
+    "    spatial_dims=2,\n",
+    "    in_channels=1,\n",
+    "    out_channels=1,\n",
+    "    label_nc=6,\n",
+    "    input_shape=input_shape,\n",
+    "    num_channels=[16, 32, 64, 128],\n",
+    "    z_dim=16,\n",
+    "    is_vae=True,\n",
+    ")"
    ]
   },
   {
@@ -399,18 +399,19 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "discriminator = MultiScalePatchDiscriminator(num_d = 2,\n",
-    "                                             num_layers_d = 3,\n",
-    "                                             spatial_dims = 2,\n",
-    "                                             num_channels = 8,\n",
-    "                                             in_channels = 7,\n",
-    "                                             out_channels = 7,\n",
-    "                                             minimum_size_im = 128,\n",
-    "                                             norm = \"INSTANCE\",\n",
-    "                                             kernel_size = 3\n",
-    "                                             )\n",
+    "discriminator = MultiScalePatchDiscriminator(\n",
+    "    num_d=2,\n",
+    "    num_layers_d=3,\n",
+    "    spatial_dims=2,\n",
+    "    num_channels=8,\n",
+    "    in_channels=7,\n",
+    "    out_channels=7,\n",
+    "    minimum_size_im=128,\n",
+    "    norm=\"INSTANCE\",\n",
+    "    kernel_size=3,\n",
+    ")\n",
     "\n",
-    "adversarial_loss = PatchAdversarialLoss(reduction = \"sum\", criterion = \"hinge\")"
+    "adversarial_loss = PatchAdversarialLoss(reduction=\"sum\", criterion=\"hinge\")"
    ]
   },
   {
@@ -429,11 +430,8 @@
     }
    ],
    "source": [
-    "perceptual_loss = PerceptualLoss(spatial_dims = 2,\n",
-    "                                 network_type = \"vgg\",\n",
-    "                                 is_fake_3d = False,\n",
-    "                                 pretrained = True)\n",
-    "perceptual_loss=perceptual_loss.to(device)"
+    "perceptual_loss = PerceptualLoss(spatial_dims=2, network_type=\"vgg\", is_fake_3d=False, pretrained=True)\n",
+    "perceptual_loss = perceptual_loss.to(device)"
    ]
   },
   {
@@ -443,8 +441,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "optimizer_G = torch.optim.Adam(net.parameters(), lr = 0.0002)\n",
-    "optimizer_D = torch.optim.Adam(discriminator.parameters(), lr = 0.0004)"
+    "optimizer_G = torch.optim.Adam(net.parameters(), lr=0.0002)\n",
+    "optimizer_D = torch.optim.Adam(discriminator.parameters(), lr=0.0004)"
    ]
   },
   {
@@ -2237,92 +2235,96 @@
     "net = net.to(device)\n",
     "discriminator = discriminator.to(device)\n",
     "torch.autograd.set_detect_anomaly(True)\n",
-    "losses = {'kld': [], 'perceptual': [], 'feature': [], 'generator': [], 'discriminator': []}\n",
-    "losses_val = {'kld': [], 'perceptual': [], 'feature': [], 'generator': [], 'discriminator': []}\n",
+    "losses = {\"kld\": [], \"perceptual\": [], \"feature\": [], \"generator\": [], \"discriminator\": []}\n",
+    "losses_val = {\"kld\": [], \"perceptual\": [], \"feature\": [], \"generator\": [], \"discriminator\": []}\n",
     "for epoch in range(num_epochs):\n",
-    "    print(\"Epoch %d/%d\" %(epoch, num_epochs))\n",
+    "    print(\"Epoch %d/%d\" % (epoch, num_epochs))\n",
     "    train_bar = tqdm(enumerate(train_loader), total=len(train_loader), ncols=120)\n",
-    "    losses_epoch = {'kld': 0, 'perceptual': 0, 'feature': 0, 'generator': 0, 'discriminator': 0}\n",
+    "    losses_epoch = {\"kld\": 0, \"perceptual\": 0, \"feature\": 0, \"generator\": 0, \"discriminator\": 0}\n",
     "    for step, d in train_bar:\n",
-    "        image = d['image'].to(device)\n",
+    "        image = d[\"image\"].to(device)\n",
     "        with torch.no_grad():\n",
-    "            label = one_hot(d['label'], 6).to(device)\n",
+    "            label = one_hot(d[\"label\"], 6).to(device)\n",
     "        optimizer_G.zero_grad()\n",
     "\n",
     "        # Losses gen\n",
     "        out, kld_loss = net(label, image)\n",
     "        disc_fakes, features_fakes = discriminator(torch.cat([out, label], 1))\n",
-    "        loss_g = adversarial_loss(disc_fakes, target_is_real = True, for_discriminator = False)\n",
+    "        loss_g = adversarial_loss(disc_fakes, target_is_real=True, for_discriminator=False)\n",
     "        disc_reals, features_reals = discriminator(torch.cat([image, label], 1))\n",
     "        loss_feat = feature_loss(features_fakes, features_reals, lambda_feat, device)\n",
-    "        loss_perc = perceptual_loss(out, target = image)\n",
-    "        total_loss = loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat  * lambda_feat\n",
-    "        total_loss.backward(retain_graph = True)\n",
+    "        loss_perc = perceptual_loss(out, target=image)\n",
+    "        total_loss = loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat * lambda_feat\n",
+    "        total_loss.backward(retain_graph=True)\n",
     "        optimizer_G.step()\n",
     "\n",
     "        # Store\n",
-    "        losses_epoch['kld'] += kld_loss.item()\n",
-    "        losses_epoch['perceptual'] += loss_perc.item()\n",
-    "        losses_epoch['generator'] += loss_g.item()\n",
-    "        #Train disc\n",
+    "        losses_epoch[\"kld\"] += kld_loss.item()\n",
+    "        losses_epoch[\"perceptual\"] += loss_perc.item()\n",
+    "        losses_epoch[\"generator\"] += loss_g.item()\n",
+    "        # Train disc\n",
     "        out, _ = net(label, image)\n",
     "        disc_fakes, _ = discriminator(torch.cat([out, label], 1))\n",
-    "        loss_d_r = adversarial_loss(disc_reals, target_is_real = True, for_discriminator = True)\n",
-    "        loss_g_f = adversarial_loss(disc_fakes, target_is_real = False, for_discriminator = True)\n",
+    "        loss_d_r = adversarial_loss(disc_reals, target_is_real=True, for_discriminator=True)\n",
+    "        loss_g_f = adversarial_loss(disc_fakes, target_is_real=False, for_discriminator=True)\n",
     "        optimizer_D.zero_grad()\n",
     "        loss_d = loss_d_r + loss_g_f\n",
     "        loss_d.backward()\n",
     "        optimizer_D.step()\n",
     "\n",
     "        # Store\n",
-    "        losses_epoch['feature'] = loss_feat.item()\n",
-    "        losses_epoch['discriminator'] = loss_d_r.item() + loss_g_f.item()\n",
+    "        losses_epoch[\"feature\"] = loss_feat.item()\n",
+    "        losses_epoch[\"discriminator\"] = loss_d_r.item() + loss_g_f.item()\n",
     "\n",
     "        train_bar.set_postfix(\n",
-    "                        {\"kld\": kld_loss.item(),\n",
-    "                         \"perceptual\": loss_perc.item(),\n",
-    "                         \"generator\": loss_g.item(),\n",
-    "                         \"feature\": loss_feat.item(),\n",
-    "                         \"discriminator\": loss_d_r.item() + loss_g_f.item(),\n",
-    "                        })\n",
+    "            {\n",
+    "                \"kld\": kld_loss.item(),\n",
+    "                \"perceptual\": loss_perc.item(),\n",
+    "                \"generator\": loss_g.item(),\n",
+    "                \"feature\": loss_feat.item(),\n",
+    "                \"discriminator\": loss_d_r.item() + loss_g_f.item(),\n",
+    "            }\n",
+    "        )\n",
     "\n",
     "    val_bar = tqdm(enumerate(val_loader), total=len(val_loader), ncols=120)\n",
-    "    losses_epoch_val = {'kld': 0, 'perceptual': 0, 'feature': 0, 'generator': 0, 'discriminator': 0}\n",
+    "    losses_epoch_val = {\"kld\": 0, \"perceptual\": 0, \"feature\": 0, \"generator\": 0, \"discriminator\": 0}\n",
     "    for step, d in val_bar:\n",
-    "        image = d['image'].to(device)\n",
+    "        image = d[\"image\"].to(device)\n",
     "        with torch.no_grad():\n",
-    "            label = one_hot(d['label'], 6).to(device)\n",
+    "            label = one_hot(d[\"label\"], 6).to(device)\n",
     "            # Losses gen\n",
     "            out, kld_loss = net(label, image)\n",
     "            disc_fakes, features_fakes = discriminator(torch.cat([out, label], 1))\n",
-    "            loss_g = adversarial_loss(disc_fakes, target_is_real = True, for_discriminator = False)\n",
+    "            loss_g = adversarial_loss(disc_fakes, target_is_real=True, for_discriminator=False)\n",
     "            disc_reals, features_reals = discriminator(torch.cat([image, label], 1))\n",
     "            loss_feat = feature_loss(features_fakes, features_reals, lambda_feat, device)\n",
-    "            loss_perc = perceptual_loss(out, target = image)\n",
-    "            total_loss = loss_adv * loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat  * lambda_feat\n",
+    "            loss_perc = perceptual_loss(out, target=image)\n",
+    "            total_loss = loss_adv * loss_g + loss_perc * lambda_perc + kld_loss * lambda_kld + loss_feat * lambda_feat\n",
     "            # Store\n",
-    "            losses_epoch_val['kld'] += kld_loss.item()\n",
-    "            losses_epoch_val['perceptual'] += loss_perc.item()\n",
-    "            losses_epoch_val['generator'] += loss_g.item()\n",
-    "            #Train disc\n",
+    "            losses_epoch_val[\"kld\"] += kld_loss.item()\n",
+    "            losses_epoch_val[\"perceptual\"] += loss_perc.item()\n",
+    "            losses_epoch_val[\"generator\"] += loss_g.item()\n",
+    "            # Train disc\n",
     "            out, _ = net(label, image)\n",
     "            disc_fakes, _ = discriminator(torch.cat([out, label], 1))\n",
-    "            loss_d_r = adversarial_loss(disc_reals, target_is_real = True, for_discriminator = True)\n",
-    "            loss_g_f = adversarial_loss(disc_fakes, target_is_real = False, for_discriminator = True)\n",
+    "            loss_d_r = adversarial_loss(disc_reals, target_is_real=True, for_discriminator=True)\n",
+    "            loss_g_f = adversarial_loss(disc_fakes, target_is_real=False, for_discriminator=True)\n",
     "            loss_d = loss_adv * (loss_d_r + loss_g_f)\n",
     "\n",
     "            # Store\n",
-    "            losses_epoch_val['feature'] = loss_feat.item()\n",
-    "            losses_epoch_val['discriminator'] = loss_d_r.item() + loss_g_f.item()\n",
+    "            losses_epoch_val[\"feature\"] = loss_feat.item()\n",
+    "            losses_epoch_val[\"discriminator\"] = loss_d_r.item() + loss_g_f.item()\n",
     "\n",
     "            val_bar.set_postfix(\n",
-    "                            {\"kld\": kld_loss.item(),\n",
-    "                             \"perceptual\": loss_perc.item(),\n",
-    "                             \"generator\": loss_g.item(),\n",
-    "                             \"feature\": loss_feat.item(),\n",
-    "                             \"discriminator\": loss_d_r.item() + loss_g_f.item(),\n",
-    "                            })\n",
-    "            if step == 0 and epoch%10==0:\n",
+    "                {\n",
+    "                    \"kld\": kld_loss.item(),\n",
+    "                    \"perceptual\": loss_perc.item(),\n",
+    "                    \"generator\": loss_g.item(),\n",
+    "                    \"feature\": loss_feat.item(),\n",
+    "                    \"discriminator\": loss_d_r.item() + loss_g_f.item(),\n",
+    "                }\n",
+    "            )\n",
+    "            if step == 0 and epoch % 10 == 0:\n",
     "                picture_results(label, image, out)\n",
     "    for key, val in losses_epoch.items():\n",
     "        losses[key].append(val / len(train_loader))\n",
@@ -2349,16 +2351,16 @@
    ],
    "source": [
     "# Plot losses\n",
-    "colors = ['orangered', 'royalblue', 'hotpink', 'lime', 'goldenrod']\n",
-    "plt.figure(figsize=(5,10))\n",
+    "colors = [\"orangered\", \"royalblue\", \"hotpink\", \"lime\", \"goldenrod\"]\n",
+    "plt.figure(figsize=(5, 10))\n",
     "ind = 0\n",
     "for key, val in losses.items():\n",
-    "    plt.subplot(len(losses.keys()),1,ind+1)\n",
-    "    plt.plot(val, color = colors[ind], linestyle = '-')\n",
-    "    plt.plot(losses_val[key], color = colors[ind], linestyle = '--')\n",
+    "    plt.subplot(len(losses.keys()), 1, ind + 1)\n",
+    "    plt.plot(val, color=colors[ind], linestyle=\"-\")\n",
+    "    plt.plot(losses_val[key], color=colors[ind], linestyle=\"--\")\n",
     "    plt.title(key)\n",
     "    plt.xlabel(\"Epochs\")\n",
-    "    ind+=1;\n",
+    "    ind += 1\n",
     "plt.tight_layout()\n",
     "plt.show()"
    ]
@@ -2367,7 +2369,6 @@
    "cell_type": "markdown",
    "id": "c3cf096f",
    "metadata": {
-    "lines_to_next_cell": 0,
     "pycharm": {
      "name": "#%%"
     }