          padding_bot = padding_height - padding_top
          padding_left = padding_width // 2
          padding_right = padding_width - padding_left
  
          return pad(var_x,
                     [[0, 0],
                      [padding_top, padding_bot],
                      [padding_left, padding_right],
                      [0, 0]],
                     'REFLECT')
  
      def get_config(self):
          """Returns the config of the layer.
  
          A layer config is a Python dictionary (serializable) containing the configuration of a
 
</s> remove         if get_backend() == "amd":
            return inputs * K.sigmoid(inputs * self.beta)
        # Native TF Implementation has more memory-efficient gradients
 </s> add  </s> remove     output_size=dict(
        default=128,
        info="Resolution (in pixels) of the output image to generate.\n"
             "BE AWARE Larger resolution will dramatically increase VRAM requirements.",
        datatype=int,
        rounding=64,
        min_max=(64, 2048),
        group="general",
        fixed=True),
    shared_fc=dict(
        default="none",
        info="Whether to create a shared fully connected layer. This layer will have the same "
             "structure as the fully connected layers used for each side of the model. A shared "
             "fully connected layer looks for patterns that are common to both sides. NB: "
             "Enabling this option only makes sense if 'split fc' is selected."
             "\n\tnone - Do not create a Fully Connected layer for shared data. (Original method)"
             "\n\tfull - Create an exclusive Fully Connected layer for shared data. (IAE method)"
             "\n\thalf - Use the 'fc_a' layer for shared data. This saves VRAM by re-using the "
             "'A' side's fully connected model for the shared data. However, this will lead to "
             "an 'unbalanced' model and can lead to more identity bleed (DFL method)",
        datatype=str,
        choices=["none", "full", "half"],
        gui_radio=True,
        group="general",
        fixed=True),
    enable_gblock=dict(
        default=True,
        info="Whether to enable the G-Block. If enabled, this will create a shared fully "
             "connected layer (configurable in the 'G-Block hidden layers' section) to look for "
             "patterns in the combined data, before feeding a block prior to the decoder for "
             "merging this shared and combined data."
             "\n\tTrue - Use the G-Block in the Decoder. A combined fully connected layer will be "
             "created to feed this block which can be configured below."
             "\n\tFalse - Don't use the G-Block in the decoder. No combined fully connected layer "
             "will be created.",
        datatype=bool,
        group="general",
        fixed=True),
    split_fc=dict(
        default=True,
        info="Whether to use a single shared Fully Connected layer or separate Fully Connected "
             "layers for each side."
             "\n\tTrue - Use separate Fully Connected layers for Face A and Face B. This is more "
             "similar to the 'IAE' style of model."
             "\n\tFalse - Use combined Fully Connected layers for both sides. This is more "
             "similar to the original Faceswap architecture.",
        datatype=bool,
        group="general",
        fixed=True),
    split_gblock=dict(
        default=False,
        info="If the G-Block is enabled, Whether to use a single G-Block shared between both "
             "sides, or whether to have a separate G-Block (one for each side). NB: The Fully "
             "Connected layer that feeds the G-Block will always be shared."
             "\n\tTrue - Use separate G-Blocks for Face A and Face B."
             "\n\tFalse - Use a combined G-Block layers for both sides.",
        datatype=bool,
        group="general",
        fixed=True),
    split_decoders=dict(
        default=False,
        info="Whether to use a single decoder or split decoders."
             "\n\tTrue - Use a separate decoder for Face A and Face B. This is more similar to "
             "the original Faceswap architecture."
             "\n\tFalse - Use a combined Decoder. This is more similar to 'IAE' style "
             "architecture.",
        datatype=bool,
        group="general",
        fixed=True),
 </s> add     "output_size": {
        "default": 128,
        "info": (
            "Resolution (in pixels) of the output image to generate.\n"
            "BE AWARE Larger resolution will dramatically increase VRAM requirements."),
        "datatype": int,
        "rounding": 64,
        "min_max": (64, 2048),
        "group": "general",
        "fixed": True},
    "shared_fc": {
        "default": "none",
        "info": (
            "Whether to create a shared fully connected layer. This layer will have the same "
            "structure as the fully connected layers used for each side of the model. A shared "
            "fully connected layer looks for patterns that are common to both sides. NB: "
            "Enabling this option only makes sense if 'split fc' is selected."
            "\n\tnone - Do not create a Fully Connected layer for shared data. (Original method)"
            "\n\tfull - Create an exclusive Fully Connected layer for shared data. (IAE method)"
            "\n\thalf - Use the 'fc_a' layer for shared data. This saves VRAM by re-using the "
            "'A' side's fully connected model for the shared data. However, this will lead to "
            "an 'unbalanced' model and can lead to more identity bleed (DFL method)"),
        "datatype": str,
        "choices": ["none", "full", "half"],
        "gui_radio": True,
        "group": "general",
        "fixed": True},
    "enable_gblock": {
        "default": True,
        "info": (
            "Whether to enable the G-Block. If enabled, this will create a shared fully "
            "connected layer (configurable in the 'G-Block hidden layers' section) to look for "
            "patterns in the combined data, before feeding a block prior to the decoder for "
            "merging this shared and combined data."
            "\n\tTrue - Use the G-Block in the Decoder. A combined fully connected layer will be "
            "created to feed this block which can be configured below."
            "\n\tFalse - Don't use the G-Block in the decoder. No combined fully connected layer "
            "will be created."),
        "datatype": bool,
        "group": "general",
        "fixed": True},
    "split_fc": {
        "default": True,
        "info": (
            "Whether to use a single shared Fully Connected layer or separate Fully Connected "
            "layers for each side."
            "\n\tTrue - Use separate Fully Connected layers for Face A and Face B. This is more "
            "similar to the 'IAE' style of model."
            "\n\tFalse - Use combined Fully Connected layers for both sides. This is more "
            "similar to the original Faceswap architecture."),
        "datatype": bool,
        "group": "general",
        "fixed": True},
    "split_gblock": {
        "default": False,
        "info": (
            "If the G-Block is enabled, Whether to use a single G-Block shared between both "
            "sides, or whether to have a separate G-Block (one for each side). NB: The Fully "
            "Connected layer that feeds the G-Block will always be shared."
            "\n\tTrue - Use separate G-Blocks for Face A and Face B."
            "\n\tFalse - Use a combined G-Block layers for both sides."),
        "datatype": bool,
        "group": "general",
        "fixed": True},
    "split_decoders": {
        "default": False,
        "info": (
            "Whether to use a single decoder or split decoders."
            "\n\tTrue - Use a separate decoder for Face A and Face B. This is more similar to "
            "the original Faceswap architecture."
            "\n\tFalse - Use a combined Decoder. This is more similar to 'IAE' style "
            "architecture."),
        "datatype": bool,
        "group": "general",
        "fixed": True}, </s> remove         policy = dict(class_name="Policy", config=dict(name=dtype))
 </s> add         policy = {"class_name": "Policy", "config": {"name": dtype}} </s> remove     bottleneck_type=dict(
        default="dense",
        info="The type of layer to use for the bottleneck."
             "\n\taverage_pooling: Use a Global Average Pooling 2D layer for the bottleneck."
             "\n\tdense: Use a Dense layer for the bottleneck (the traditional Faceswap method). "
             "You can set the size of the Dense layer with the 'bottleneck_size' parameter."
             "\n\tmax_pooling: Use a Global Max Pooling 2D layer for the bottleneck.",
        datatype=str,
        group="bottleneck",
        gui_radio=True,
        choices=["average_pooling", "dense", "max_pooling"],
        fixed=True),
    bottleneck_norm=dict(
        default="none",
        info="Apply a normalization layer after encoder output and prior to the bottleneck."
             "\n\tnone - Do not apply a normalization layer"
             "\n\tinstance - Apply Instance Normalization"
             "\n\tlayer - Apply Layer Normalization (Ba et al., 2016)"
             "\n\trms - Apply Root Mean Squared Layer Normalization (Zhang et al., 2019). A "
             "simplified version of Layer Normalization with reduced overhead.",
        datatype=str,
        gui_radio=True,
        choices=["none", "instance", "layer", "rms"],
        group="bottleneck",
        fixed=True),
    bottleneck_size=dict(
        default=1024,
        info="If using a Dense layer for the bottleneck, then this is the number of nodes to use.",
        datatype=int,
        rounding=128,
        min_max=(128, 4096),
        group="bottleneck",
        fixed=True),
    bottleneck_in_encoder=dict(
        default=True,
        info="Whether to place the bottleneck in the Encoder or to place it with the other hidden "
             "layers. Placing the bottleneck in the encoder means that both sides will share the "
             "same bottleneck. Placing it with the other fully connected layers means that each "
             "fully connected layer will each get their own bottleneck. This may be combined or "
             "split depending on your overall architecture configuration settings.",
        datatype=bool,
        group="bottleneck",
        fixed=True),
 </s> add     "bottleneck_type": {
        "default": "dense",
        "info": (
            "The type of layer to use for the bottleneck."
            "\n\taverage_pooling: Use a Global Average Pooling 2D layer for the bottleneck."
            "\n\tdense: Use a Dense layer for the bottleneck (the traditional Faceswap method). "
            "You can set the size of the Dense layer with the 'bottleneck_size' parameter."
            "\n\tmax_pooling: Use a Global Max Pooling 2D layer for the bottleneck."),
        "datatype": str,
        "group": "bottleneck",
        "gui_radio": True,
        "choices": ["average_pooling", "dense", "max_pooling"],
        "fixed": True},
    "bottleneck_norm": {
        "default": "none",
        "info": (
            "Apply a normalization layer after encoder output and prior to the bottleneck."
            "\n\tnone - Do not apply a normalization layer"
            "\n\tinstance - Apply Instance Normalization"
            "\n\tlayer - Apply Layer Normalization (Ba et al., 2016)"
            "\n\trms - Apply Root Mean Squared Layer Normalization (Zhang et al., 2019). A "
            "simplified version of Layer Normalization with reduced overhead."),
        "datatype": str,
        "gui_radio": True,
        "choices": ["none", "instance", "layer", "rms"],
        "group": "bottleneck",
        "fixed": True},
    "bottleneck_size": {
        "default": 1024,
        "info": (
            "If using a Dense layer for the bottleneck, then this is the number of nodes to "
            "use."),
        "datatype": int,
        "rounding": 128,
        "min_max": (128, 4096),
        "group": "bottleneck",
        "fixed": True},
    "bottleneck_in_encoder": {
        "default": True,
        "info": (
            "Whether to place the bottleneck in the Encoder or to place it with the other "
            "hidden layers. Placing the bottleneck in the encoder means that both sides will "
            "share the same bottleneck. Placing it with the other fully connected layers means "
            "that each fully connected layer will each get their own bottleneck. This may be "
            "combined or split depending on your overall architecture configuration settings."),
        "datatype": bool,
        "group": "bottleneck",
        "fixed": True}, </s> remove         _HELPTEXT: A string describing what this plugin does
        _DEFAULTS: A dictionary containing the options, defaults and meta information. The
                   dictionary should be defined as:
                       {<option_name>: {<metadata>}}
 </s> add         "_HELPTEXT: A string describing what this plugin does
        "_DEFAULTS: A dictionary containing the options, defaults and meta information. The
               "   dictionary should be defined as:
               "       {<option_name>: {<metadata>}}
        return tf.pad(inputs,
                      [[0, 0],
                       [padding_top, padding_bot],
                       [padding_left, padding_right],
                       [0, 0]],
                      'REFLECT')
          padding_bot = padding_height - padding_top
          padding_left = padding_width // 2
          padding_right = padding_width - padding_left
  
        return tf.pad(inputs,
                      [[0, 0],
                       [padding_top, padding_bot],
                       [padding_left, padding_right],
                       [0, 0]],
                      'REFLECT')
        return tf.pad(inputs,
                      [[0, 0],
                       [padding_top, padding_bot],
                       [padding_left, padding_right],
                       [0, 0]],
                      'REFLECT')
        return tf.pad(inputs,
                      [[0, 0],
                       [padding_top, padding_bot],
                       [padding_left, padding_right],
                       [0, 0]],
                      'REFLECT')
        return tf.pad(inputs,
                      [[0, 0],
                       [padding_top, padding_bot],
                       [padding_left, padding_right],
                       [0, 0]],
                      'REFLECT')
        return tf.pad(inputs,
                      [[0, 0],
                       [padding_top, padding_bot],
                       [padding_left, padding_right],
                       [0, 0]],
                      'REFLECT')
        return tf.pad(inputs,
                      [[0, 0],
                       [padding_top, padding_bot],
                       [padding_left, padding_right],
                       [0, 0]],
                      'REFLECT')
  
      def get_config(self):
          """Returns the config of the layer.
  
          A layer config is a Python dictionary (serializable) containing the configuration of a
keep keep keep keep replace replace replace replace replace replace keep keep keep keep keep
 Remove plaidML support (#1325)

* Remove PlaidML reference from readme files

* Remove AMD option from installers

* remove amd requirements and update setup.py

* remove plaidml test from CI workflow

* gpustats: remove plaidml backend

* plaid removals:
  - faceswap.py - python version check
  - setup.cfg - plaidml typing ignore
  - lib.keras_utils - All plaid code
  - lib.launcher.py - All plaidml checks and configuration

* remove tf2.2 specific code from GUI event reader

* lib.model - remove all plaidml implementations

* plugins.extract - remove plaidml code

* plugins.train remove plaidml code

* lib.convert - remove plaidml code

* tools.model: remove plaidml code

* Remove plaidML tests from unit tests

* remove plaidml_utils and docsting cleanups

* Remove plaidML refs from configs

* fix keras imports 
lib/model/layers.py