diff --git a/generative/losses/kld_loss.py b/generative/losses/kld_loss.py
new file mode 100644
index 00000000..ebcaf52b
--- /dev/null
+++ b/generative/losses/kld_loss.py
@@ -0,0 +1,20 @@
+# 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
+
+
+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..0fe735e8
--- /dev/null
+++ b/generative/networks/blocks/spade_norm.py
@@ -0,0 +1,95 @@
+# 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
+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
+        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:
+
+        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.
+        """
+
+        # 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..b2ff2833
--- /dev/null
+++ b/generative/networks/nets/spade_network.py
@@ -0,0 +1,418 @@
+# 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
+
+from typing import Sequence, Union
+
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from monai.networks.blocks import Convolution
+from monai.networks.layers import Act
+from monai.utils.enums import StrEnum
+
+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
+        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,
+        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):
+    """
+    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,
+        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):
+    """
+    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,
+        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):
+
+    """
+    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,
+        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..e030b81e
--- /dev/null
+++ b/tests/test_spade_vaegan.py
@@ -0,0 +1,131 @@
+# 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 numpy as np
+import torch
+from monai.networks import eval_mode
+from parameterized import parameterized
+
+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):
+    """
+    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_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])
+        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()
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
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..125ecd8b
--- /dev/null
+++ b/tutorials/generative/2d_spade_gan/2d_spade_vae.ipynb
@@ -0,0 +1,2405 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "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": 1,
+   "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": 2,
+   "id": "e76296e7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Temporary directory used: /tmp/tmpz0rbc_3s \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": 26,
+   "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": 4,
+   "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/tmpz0rbc_3s/data.zip\n",
+      "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 384M/384M [00:05<00:00, 67.0MB/s]\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'/tmp/tmpz0rbc_3s/data.zip'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "gdown.download(\n",
+    "    \"https://drive.google.com/uc?export=download&id=1SX_MCzQe-vyq09QYxECk32wZ2vxp9rx5\", str(root_dir / \"data.zip\")\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "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": 6,
+   "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",
+    "]\n",
+    "np.random.shuffle(all_images)\n",
+    "corresponding_labels = [\n",
+    "    os.path.join(labels, i.split(\"/\")[-1].replace(i.split(\"/\")[-1].split(\"_\")[0], \"Parcellation\")) for i in all_images\n",
+    "]\n",
+    "input_dict = [{\"image\": i, \"label\": corresponding_labels[ind]} for ind, i in enumerate(all_images)]\n",
+    "input_dict_train = input_dict[: int(len(input_dict) * 0.9)]\n",
+    "input_dict_val = input_dict[int(len(input_dict) * 0.9) :]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9916ca5a",
+   "metadata": {},
+   "source": [
+    "### Dataloaders"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "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\"], roi_size=preliminar_shape),\n",
+    "    monai.transforms.RandSpatialCropd(keys=[\"label\", \"image\"], roi_size=crop_shape, max_roi_size=crop_shape),\n",
+    "    monai.transforms.SqueezeDimd(keys=[\"label\", \"image\"], dim=-1),\n",
+    "    monai.transforms.Resized(keys=[\"image\", \"label\"], spatial_size=input_shape),\n",
+    "]\n",
+    "last_transforms = [\n",
+    "    monai.transforms.CopyItemsd(keys=[\"label\"], names=[\"label_channel\"]),\n",
+    "    monai.transforms.Lambdad(keys=[\"label_channel\"], func=lambda l: l != 0),\n",
+    "    monai.transforms.MaskIntensityd(keys=[\"image\"], mask_key=\"label_channel\"),\n",
+    "    monai.transforms.NormalizeIntensityd(keys=[\"image\"]),\n",
+    "    monai.transforms.ToTensord(keys=[\"image\", \"label\"]),\n",
+    "]\n",
+    "\n",
+    "aug_transforms = [\n",
+    "    monai.transforms.RandBiasFieldd(coeff_range=(0, 0.005), prob=0.33, keys=[\"image\"]),\n",
+    "    monai.transforms.RandAdjustContrastd(gamma=(0.9, 1.15), prob=0.33, keys=[\"image\"]),\n",
+    "    monai.transforms.RandGaussianNoised(prob=0.33, mean=0.0, std=np.random.uniform(0.005, 0.015), keys=[\"image\"]),\n",
+    "    monai.transforms.RandAffined(\n",
+    "        rotate_range=[-0.05, 0.05],\n",
+    "        shear_range=[0.001, 0.05],\n",
+    "        scale_range=[0, 0.05],\n",
+    "        padding_mode=\"zeros\",\n",
+    "        mode=\"nearest\",\n",
+    "        prob=0.33,\n",
+    "        keys=[\"label\", \"image\"],\n",
+    "    ),\n",
+    "]\n",
+    "\n",
+    "train_transforms = monai.transforms.Compose(base_transforms + aug_transforms + last_transforms)\n",
+    "val_transforms = monai.transforms.Compose(base_transforms + last_transforms)\n",
+    "\n",
+    "train_dataset = monai.data.dataset.Dataset(input_dict_train, train_transforms)\n",
+    "val_dataset = monai.data.dataset.Dataset(input_dict_val, val_transforms)\n",
+    "train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size, num_workers=num_workers)\n",
+    "val_loader = DataLoader(val_dataset, shuffle=False, drop_last=False, batch_size=batch_size, num_workers=num_workers)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "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\")\n",
+    "plt.axis(\"off\")\n",
+    "plt.subplot(1, 2, 2)\n",
+    "plt.imshow(batch[\"label\"][0, 0, ...], cmap=\"jet\")\n",
+    "plt.axis(\"off\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "63de4490",
+   "metadata": {},
+   "source": [
+    "### Network creation and losses"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "fa17d864",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "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": 11,
+   "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": 12,
+   "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], 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": 13,
+   "id": "89989c34",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "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",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "5b8b676f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "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\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "36ea4308",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
+      "Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=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, network_type=\"vgg\", is_fake_3d=False, pretrained=True)\n",
+    "perceptual_loss = perceptual_loss.to(device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "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": 27,
+   "id": "918eac0a",
+   "metadata": {
+    "lines_to_next_cell": 2
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 0/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "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",
+      "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.22it/s, kld=63.6, perceptual=0.254, generator=3.38, feature=0.125, discriminator=1.77]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 4/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 9/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 10/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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",
+      "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.42it/s, kld=109, perceptual=0.258, generator=3.54, feature=0.128, discriminator=1.6]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 11/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 12/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 13/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 14/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 15/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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=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]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 20/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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",
+      "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.95it/s, kld=530, perceptual=0.346, generator=3.16, feature=0.143, discriminator=1.94]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 21/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 24/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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",
+      "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=90, perceptual=0.226, generator=3.6, feature=0.142, discriminator=1.43]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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",
+      "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.33it/s, kld=86.4, perceptual=0.205, generator=3.63, feature=0.142, discriminator=1.36]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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=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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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",
+      "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.45it/s, kld=52.4, perceptual=0.203, generator=3.65, feature=0.133, discriminator=1.27]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 60/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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",
+      "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.59it/s, kld=45.9, perceptual=0.196, generator=3.65, feature=0.133, discriminator=1.26]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 66/100\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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",
+      "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=54.3, perceptual=0.17, generator=3.64, feature=0.126, discriminator=1.29]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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",
+      "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=62.6, perceptual=0.191, generator=3.66, feature=0.132, discriminator=1.24]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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=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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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",
+      "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.52it/s, kld=50.1, perceptual=0.159, generator=3.65, feature=0.126, discriminator=1.28]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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=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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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]"
+     ]
+    },
+    {
+     "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.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"
+     ]
+    }
+   ],
+   "source": [
+    "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",
+    "    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",
+    "            {\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",
+    "    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",
+    "                {\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",
+    "    for key, val in losses_epoch_val.items():\n",
+    "        losses_val[key].append(val / len(val_loader))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "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": "#%%"
+    }
+   },
+   "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"
+   ]
+  }
+ ],
+ "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.8.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
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..ec286f29
--- /dev/null
+++ b/tutorials/generative/2d_spade_gan/2d_spade_vae.py
@@ -0,0 +1,360 @@
+# ---
+# 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)
+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)
+    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)
+    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()
+
+# + [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.
+#
+# -