          base_config = super().get_config()
          return dict(list(base_config.items()) + list(config.items()))
  
  
  class ReflectionPadding2D(Layer):
      """Reflection-padding layer for 2D input (e.g. picture).
  
      This layer can add rows and columns at the top, bottom, left and right side of an image tensor.
  
      Parameters
 
</s> remove     This is an early implementation of this class, and should be expanded out over time
    with relevant `AMD`, `CPU` and `NVIDIA` backend methods.
 </s> add     This is an early implementation of this class, and should be expanded out over time. </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     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     def _compile_masked(self, faces: List[np.ndarray], masks: np.ndarray) -> List[np.ndarray]:
 </s> add     def _compile_masked(self, faces: T.List[np.ndarray], masks: np.ndarray) -> T.List[np.ndarray]: </s> remove     def _get_nodes(self, nodes: np.ndarray) -> List[Tuple[str, int]]:
 </s> add     def _get_nodes(self, nodes: np.ndarray) -> T.List[T.Tuple[str, int]]:
class ReflectionPadding2D(keras.layers.Layer):  # type:ignore[name-defined]
          base_config = super().get_config()
          return dict(list(base_config.items()) + list(config.items()))
  
  
class ReflectionPadding2D(keras.layers.Layer):  # type:ignore[name-defined]
      """Reflection-padding layer for 2D input (e.g. picture).
  
      This layer can add rows and columns at the top, bottom, left and right side of an image tensor.
  
      Parameters
keep keep keep keep 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