          upscales = int(np.log2(self._config["output_size"] / K.int_shape(var_x)[1]))
          filters = _get_curve(self._config["dec_max_filters"],
                               self._config["dec_min_filters"],
                               upscales,
                               self._config["dec_filter_slope"])
  
          for idx, filts in enumerate(filters):
              skip_res = idx == len(filters) - 1 and self._config["dec_skip_last_residual"]
              var_x = self._upscale_block(var_x, filts, skip_residual=skip_res)
              if self._config["learn_mask"]:
 
</s> remove     logger.debug("Obtaining curve: (start_y: %s, end_y: %s, num_points: %s, scale: %s)",
                 start_y, end_y, num_points, scale)
    x_axis = np.linspace(0., 1., num=num_points)
    y_axis = (x_axis - x_axis * scale) / (scale - abs(x_axis) * 2 * scale + 1)
    y_axis = y_axis * (end_y - start_y) + start_y
    retval = [int((y // 8) * 8) for y in y_axis]
 </s> add     logger.debug("Obtaining curve: (start_y: %s, end_y: %s, num_points: %s, scale: %s, mode: %s)",
                 start_y, end_y, num_points, scale, mode)
    if mode == "full":
        x_axis = np.linspace(0., 1., num=num_points)
        y_axis = (x_axis - x_axis * scale) / (scale - abs(x_axis) * 2 * scale + 1)
        y_axis = y_axis * (end_y - start_y) + start_y
        retval = [int((y // 8) * 8) for y in y_axis]
    else:
        y_axis = [start_y]
        scale = 1. - abs(scale)
        for _ in range(num_points):
            current_value = max(end_y, int(((y_axis[-1] * scale) // 8) * 8))
            y_axis.append(current_value)
            if current_value == end_y:
                break
        pad = [start_y if mode == "cap_max" else end_y for _ in range(num_points - len(y_axis))]
        retval = pad + y_axis if mode == "cap_max" else y_axis + pad </s> remove             for _ in range(self._config["fc_upsamples"]):
                upscaler = _get_upscale_layer(self._config["fc_upsampler"].lower(),
                                              upsample_filts,
                                              activation="leakyrelu")
                var_x = upscaler(var_x)
                if self._config["fc_upsampler"].lower() == "upsample2d":
                    var_x = LeakyReLU(alpha=0.1)(var_x)
 </s> add             var_x = self._do_upsampling(var_x) </s> remove             upsample_filts = self._scale_filters(self._config["fc_upsample_filters"])

 </s> add  </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         if get_backend() == "amd" and model.get("no_amd"):
            valid = [k for k, v in _MODEL_MAPPING.items() if not v.get('no_amd')]
 </s> add         if get_backend() == "amd" and model.no_amd:
            valid = [k for k, v in _MODEL_MAPPING.items() if not v.no_amd]
                             self._config["dec_filter_slope"],
                             mode=self._config["dec_slope_mode"])
          upscales = int(np.log2(self._config["output_size"] / K.int_shape(var_x)[1]))
          filters = _get_curve(self._config["dec_max_filters"],
                               self._config["dec_min_filters"],
                               upscales,
                             self._config["dec_filter_slope"],
                             mode=self._config["dec_slope_mode"])
  
          for idx, filts in enumerate(filters):
              skip_res = idx == len(filters) - 1 and self._config["dec_skip_last_residual"]
              var_x = self._upscale_block(var_x, filts, skip_residual=skip_res)
              if self._config["learn_mask"]:
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