                           K.int_shape(inputs)[1:], new_shape, self._config["output_size"])
              var_x = Reshape(new_shape)(var_x)
          return var_x
  
      def _upscale_block(self, inputs, filters, skip_residual=False, is_mask=False):
          """ Upscale block for Phaze-A Decoder.
  
          Uses requested upscale method, adds requested regularization and activation function.
  
          Parameters
 
</s> remove def _get_upscale_layer(method, filters, activation=None):
 </s> add def _get_upscale_layer(method: str,
                       filters: int,
                       activation: Optional[str] = None,
                       upsamples: Optional[int] = None,
                       interpolation: Optional[str] = None) -> keras.layers.Layer: </s> remove     def _normalization(self, inputs):
 </s> add     def _normalization(self, inputs: Tensor) -> Tensor: </s> remove     def _g_block(cls, inputs, style, filters, recursions=2):
 </s> add     def _g_block(cls, inputs: Tensor, style: Tensor, filters: int, recursions: int = 2) -> Tensor: </s> remove     def __call__(self):
 </s> add     def _do_upsampling(self, inputs: Tensor) -> Tensor:
        """ Perform the upsampling at the end of the fully connected layers.

        Parameters
        ----------
        inputs: Tensor
            The input to the upsample layers

        Returns
        -------
        Tensor
            The output from the upsample layers
        """
        upsample_filts = self._scale_filters(self._config["fc_upsample_filters"])
        upsampler = self._config["fc_upsampler"].lower()
        num_upsamples = self._config["fc_upsamples"]
        var_x = inputs
        if upsampler == "upsample2d" and num_upsamples > 1:
            upscaler = _get_upscale_layer(upsampler,
                                          upsample_filts,  # Not used but required
                                          upsamples=2 ** num_upsamples,
                                          interpolation="bilinear")
            var_x = upscaler(var_x)
        else:
            for _ in range(num_upsamples):
                upscaler = _get_upscale_layer(upsampler,
                                              upsample_filts,
                                              activation="leakyrelu")
                var_x = upscaler(var_x)
        if upsampler == "upsample2d":
            var_x = LeakyReLU(alpha=0.1)(var_x)
        return var_x

    def __call__(self) -> keras.models.Model: </s> remove     def __call__(self):
 </s> add     def __call__(self) -> keras.models.Model:
    def _upscale_block(self,
                       inputs: Tensor,
                       filters: int,
                       skip_residual: bool = False,
                       is_mask: bool = False) -> Tensor:
                           K.int_shape(inputs)[1:], new_shape, self._config["output_size"])
              var_x = Reshape(new_shape)(var_x)
          return var_x
  
    def _upscale_block(self,
                       inputs: Tensor,
                       filters: int,
                       skip_residual: bool = False,
                       is_mask: bool = False) -> Tensor:
          """ Upscale block for Phaze-A Decoder.
  
          Uses requested upscale method, adds requested regularization and activation function.
  
          Parameters
keep keep keep keep replace keep keep keep keep keep
 Model updates
- Increase model summary width
- Phaze A updates
  - Update some min/max values
  - Add Decoder Filter Slope Mode
  - Add additional arguments for Upsampling2D
  - Adjust upsampling method for multiple upsamples in FC layers
  - Typing 
plugins/train/model/phaze_a.py