          gui_radio=False,
          fixed=True),
      "cpu": dict(
          default=False,
          info="[Not PlaidML] BiseNet mask still runs fairly quickly on CPU on some setups. Enable "
               "CPU mode here to use the CPU for this masker to save some VRAM at a speed cost.",
          datatype=bool,
          group="settings"),
      "weights": dict(
          default="faceswap",
 
</s> remove         info="[Not PlaidML] MTCNN detector still runs fairly quickly on CPU on some setups. "
 </s> add         info="MTCNN detector still runs fairly quickly on CPU on some setups. " </s> remove     dec_upscale_method=dict(
        default="subpixel",
        info="The method to use for the upscales within the decoder. Images are upscaled multiple "
             "times within the decoder as the network learns to reconstruct the face."
             "\n\tsubpixel - Sub-pixel upscaler using depth-to-space which requires more "
             "VRAM."
             "\n\tresize_images - Uses the Keras resize_image function to save about half as much "
             "vram as the heaviest methods."
             "\n\tupscale_fast - Developed by Andenixa. Focusses on speed to upscale, but "
             "requires more VRAM."
             "\n\tupscale_hybrid - Developed by Andenixa. Uses a combination of PixelShuffler and "
             "Upsampling2D to upscale, saving about 1/3rd of VRAM of the heaviest methods."
             "\n\tupscale_dny - An alternative upscale implementation using Upsampling2D to "
             "upsale.",
        datatype=str,
        choices=["subpixel", "resize_images", "upscale_fast", "upscale_hybrid", "upscale_dny"],
        gui_radio=True,
        group="decoder",
        fixed=True),
    dec_upscales_in_fc=dict(
        default=0,
        min_max=(0, 6),
        rounding=1,
        info="It is possible to place some of the upscales at the end of the fully connected "
        "model. For models with split decoders, but a shared fully connected layer, this would "
        "have the effect of saving some VRAM but possibly at the cost of introducing artefacts. "
        "For models with a shared decoder but split fully connected layers, this would have the "
        "effect of increasing VRAM usage by processing some of the upscales for each side rather "
        "than together.",
        datatype=int,
        group="decoder",
        fixed=True),
    dec_norm=dict(
        default="none",
        info="Normalization to apply to apply after each upscale."
             "\n\tnone - Do not apply a normalization layer"
             "\n\tbatch - Apply Batch Normalization"
             "\n\tgroup - Apply Group Normalization"
             "\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", "batch", "group", "instance", "layer", "rms"],
        group="decoder",
        fixed=True),
    dec_min_filters=dict(
        default=64,
        info="The minimum number of filters to use in decoder upscalers (i.e. the number of "
             "filters to use for the final upscale layer).",
        datatype=int,
        min_max=(16, 512),
        rounding=16,
        group="decoder",
        fixed=True),
    dec_max_filters=dict(
        default=512,
        info="The maximum number of filters to use in decoder upscalers (i.e. the number of "
             "filters to use for the first upscale layer).",
        datatype=int,
        min_max=(256, 5120),
        rounding=64,
        group="decoder",
        fixed=True),
    dec_slope_mode=dict(
        default="full",
        info="Alters the action of the filter slope.\n"
             "\n\tfull: The number of filters at each upscale layer will reduce from the chosen "
             "max_filters at the first layer to the chosen min_filters at the last layer as "
             "dictated by the dec_filter_slope."
             "\n\tcap_max: The filters will decline at a fixed rate from each upscale to the next "
             "based on the filter_slope setting. If there are more upscales than filters, "
             "then the earliest upscales will be capped at the max_filter value until the filters "
             "can reduce to the min_filters value at the final upscale. (EG: 512 -> 512 -> 512 -> "
             "256 -> 128 -> 64)."
             "\n\tcap_min: The filters will decline at a fixed rate from each upscale to the next "
             "based on the filter_slope setting. If there are more upscales than filters, then "
             "the earliest upscales will drop their filters until the min_filter value is met and "
             "repeat the min_filter value for the remaining upscales. (EG: 512 -> 256 -> 128 -> "
             "64 -> 64 -> 64).",
        choices=["full", "cap_max", "cap_min"],
        group="decoder",
        fixed=True,
        gui_radio=True),
    dec_filter_slope=dict(
        default=-0.45,
        info="The rate that the filters reduce at each upscale layer.\n"
             "\n\tFull Slope Mode: Negative numbers will drop the number of filters quicker at "
             "first and slow down each upscale. Positive numbers will drop the number of filters "
             "slower at first but then speed up each upscale. A value of 0.0 will reduce at a "
             "linear rate (i.e. the same number of filters will be reduced at each upscale).\n"
             "\n\tCap Min/Max Slope Mode: Only positive values will work here. Negative values "
             "will automatically be converted to their positive counterpart. A value of 0.5 will "
             "halve the number of filters at each upscale until the minimum value is reached. A "
             "value of 0.33 will be reduce the number of filters by a third until the minimum "
             "value is reached etc.",
        datatype=float,
        min_max=(-.99, .99),
        rounding=2,
        group="decoder",
        fixed=True),
    dec_res_blocks=dict(
        default=1,
        info="The number of Residual Blocks to apply to each upscale layer. Set to 0 to disable "
             "residual blocks entirely.",
        datatype=int,
        rounding=1,
        min_max=(0, 8),
        group="decoder",
        fixed=True),
    dec_output_kernel=dict(
        default=5,
        info="The kernel size to apply to the final Convolution layer.",
        datatype=int,
        rounding=2,
        min_max=(1, 9),
        group="decoder",
        fixed=True),
    dec_gaussian=dict(
        default=True,
        info="Gaussian Noise acts as a regularization technique for preventing overfitting of "
             "data."
             "\n\tTrue - Apply a Gaussian Noise layer to each upscale."
             "\n\tFalse - Don't apply a Gaussian Noise layer to each upscale.",
        datatype=bool,
        group="decoder",
        fixed=True),
    dec_skip_last_residual=dict(
        default=True,
        info="If Residual blocks have been enabled, enabling this option will not apply a "
             "Residual block to the final upscaler."
             "\n\tTrue - Don't apply a Residual block to the final upscale."
             "\n\tFalse - Apply a Residual block to all upscale layers.",
        datatype=bool,
        group="decoder",
        fixed=True),
 </s> add     "dec_upscale_method": {
        "default": "subpixel",
        "info": (
            "The method to use for the upscales within the decoder. Images are upscaled "
            "multiple times within the decoder as the network learns to reconstruct the face."
            "\n\tsubpixel - Sub-pixel upscaler using depth-to-space which requires more "
            "VRAM."
            "\n\tresize_images - Uses the Keras resize_image function to save about half as much "
            "vram as the heaviest methods."
            "\n\tupscale_fast - Developed by Andenixa. Focusses on speed to upscale, but "
            "requires more VRAM."
            "\n\tupscale_hybrid - Developed by Andenixa. Uses a combination of PixelShuffler and "
            "Upsampling2D to upscale, saving about 1/3rd of VRAM of the heaviest methods."
            "\n\tupscale_dny - An alternative upscale implementation using Upsampling2D to "
            "upsale."),
        "datatype": str,
        "choices": ["subpixel", "resize_images", "upscale_fast", "upscale_hybrid", "upscale_dny"],
        "gui_radio": True,
        "group": "decoder",
        "fixed": True},
    "dec_upscales_in_fc": {
        "default": 0,
        "min_max": (0, 6),
        "rounding": 1,
        "info": (
            "It is possible to place some of the upscales at the end of the fully connected "
            "model. For models with split decoders, but a shared fully connected layer, this "
            "would have the effect of saving some VRAM but possibly at the cost of introducing "
            "artefacts. For models with a shared decoder but split fully connected layers, this "
            "would have the effect of increasing VRAM usage by processing some of the upscales "
            "for each side rather than together."),
        "datatype": int,
        "group": "decoder",
        "fixed": True},
    "dec_norm": {
        "default": "none",
        "info": (
            "Normalization to apply to apply after each upscale."
            "\n\tnone - Do not apply a normalization layer"
            "\n\tbatch - Apply Batch Normalization"
            "\n\tgroup - Apply Group Normalization"
            "\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", "batch", "group", "instance", "layer", "rms"],
        "group": "decoder",
        "fixed": True},
    "dec_min_filters": {
        "default": 64,
        "info": (
            "The minimum number of filters to use in decoder upscalers (i.e. the number of "
            "filters to use for the final upscale layer)."),
        "datatype": int,
        "min_max": (16, 512),
        "rounding": 16,
        "group": "decoder",
        "fixed": True},
    "dec_max_filters": {
        "default": 512,
        "info": (
            "The maximum number of filters to use in decoder upscalers (i.e. the number of "
            "filters to use for the first upscale layer)."),
        "datatype": int,
        "min_max": (256, 5120),
        "rounding": 64,
        "group": "decoder",
        "fixed": True},
    "dec_slope_mode": {
        "default": "full",
        "info": (
            "Alters the action of the filter slope.\n"
            "\n\tfull: The number of filters at each upscale layer will reduce from the chosen "
            "max_filters at the first layer to the chosen min_filters at the last layer as "
            "dictated by the dec_filter_slope."
            "\n\tcap_max: The filters will decline at a fixed rate from each upscale to the next "
            "based on the filter_slope setting. If there are more upscales than filters, "
            "then the earliest upscales will be capped at the max_filter value until the filters "
            "can reduce to the min_filters value at the final upscale. (EG: 512 -> 512 -> 512 -> "
            "256 -> 128 -> 64)."
            "\n\tcap_min: The filters will decline at a fixed rate from each upscale to the next "
            "based on the filter_slope setting. If there are more upscales than filters, then "
            "the earliest upscales will drop their filters until the min_filter value is met and "
            "repeat the min_filter value for the remaining upscales. (EG: 512 -> 256 -> 128 -> "
            "64 -> 64 -> 64)."),
        "choices": ["full", "cap_max", "cap_min"],
        "group": "decoder",
        "fixed": True,
        "gui_radio": True},
    "dec_filter_slope": {
        "default": -0.45,
        "info": (
            "The rate that the filters reduce at each upscale layer.\n"
            "\n\tFull Slope Mode: Negative numbers will drop the number of filters quicker at "
            "first and slow down each upscale. Positive numbers will drop the number of filters "
            "slower at first but then speed up each upscale. A value of 0.0 will reduce at a "
            "linear rate (i.e. the same number of filters will be reduced at each upscale).\n"
            "\n\tCap Min/Max Slope Mode: Only positive values will work here. Negative values "
            "will automatically be converted to their positive counterpart. A value of 0.5 will "
            "halve the number of filters at each upscale until the minimum value is reached. A "
            "value of 0.33 will be reduce the number of filters by a third until the minimum "
            "value is reached etc."),
        "datatype": float,
        "min_max": (-.99, .99),
        "rounding": 2,
        "group": "decoder",
        "fixed": True},
    "dec_res_blocks": {
        "default": 1,
        "info": (
            "The number of Residual Blocks to apply to each upscale layer. Set to 0 to disable "
            "residual blocks entirely."),
        "datatype": int,
        "rounding": 1,
        "min_max": (0, 8),
        "group": "decoder",
        "fixed": True},
    "dec_output_kernel": {
        "default": 5,
        "info": "The kernel size to apply to the final Convolution layer.",
        "datatype": int,
        "rounding": 2,
        "min_max": (1, 9),
        "group": "decoder",
        "fixed": True},
    "dec_gaussian": {
        "default": True,
        "info": (
            "Gaussian Noise acts as a regularization technique for preventing overfitting of "
            "data."
            "\n\tTrue - Apply a Gaussian Noise layer to each upscale."
            "\n\tFalse - Don't apply a Gaussian Noise layer to each upscale."),
        "datatype": bool,
        "group": "decoder",
        "fixed": True},
    "dec_skip_last_residual": {
        "default": True,
        "info": (
            "If Residual blocks have been enabled, enabling this option will not apply a "
            "Residual block to the final upscaler."
            "\n\tTrue - Don't apply a Residual block to the final upscale."
            "\n\tFalse - Apply a Residual block to all upscale layers."),
        "datatype": bool,
        "group": "decoder",
        "fixed": True}, </s> remove             info=_("[Nvidia Only]. Enable the Tensorflow GPU `allow_growth` configuration option. "
 </s> add             info=_("Enable the Tensorflow GPU `allow_growth` configuration option. " </s> remove     fc_depth=dict(
        default=1,
        info="The number of consecutive Dense (fully connected) layers to include in each side's "
             "intermediate layer.",
        datatype=int,
        rounding=1,
        min_max=(0, 16),
        group="hidden layers",
        fixed=True),
    fc_min_filters=dict(
        default=1024,
        info="The number of filters to use for the initial fully connected layer. The number of "
             "nodes actually used is: fc_min_filters x fc_dimensions x fc_dimensions.\nNB: This "
             "value may be scaled down, depending on output resolution.",
        datatype=int,
        rounding=16,
        min_max=(16, 5120),
        group="hidden layers",
        fixed=True),
    fc_max_filters=dict(
        default=1024,
        info="This is the number of filters to be used in the final reshape layer at the end of "
             "the fully connected layers. The actual number of nodes used for the final fully "
             "connected layer is: fc_min_filters x fc_dimensions x fc_dimensions.\nNB: This value "
             "may be scaled down, depending on output resolution.",
        datatype=int,
        rounding=64,
        min_max=(128, 5120),
        group="hidden layers",
        fixed=True),
    fc_dimensions=dict(
        default=4,
        info="The height and width dimension for the final reshape layer at the end of the fully "
             "connected layers.\nNB: The total number of nodes within the final fully connected "
             "layer will be: fc_dimensions x fc_dimensions x fc_max_filters.",
        datatype=int,
        rounding=1,
        min_max=(1, 16),
        group="hidden layers",
        fixed=True),
    fc_filter_slope=dict(
        default=-0.5,
        info="The rate that the filters move from the minimum number of filters to the maximum "
             "number of filters. EG:\n"
             "Negative numbers will change the number of filters quicker at first and slow down "
             "each layer.\n"
             "Positive numbers will change the number of filters slower at first but then speed "
             "up each layer.\n"
             "0.0 - This will change at a linear rate (i.e. the same number of filters will be "
             "changed at each layer).",
        datatype=float,
        min_max=(-.99, .99),
        rounding=2,
        group="hidden layers",
        fixed=True),
    fc_dropout=dict(
        default=0.0,
        info="Dropout is a form of regularization that can prevent a model from over-fitting and "
             "help to keep neurons 'alive'. 0.5 will dropout half the connections between each "
             "fully connected layer, 0.25 will dropout a quarter of the connections etc. Set to "
             "0.0 to disable.",
        datatype=float,
        rounding=2,
        min_max=(0.0, 0.99),
        group="hidden layers",
        fixed=False),
    fc_upsampler=dict(
        default="upsample2d",
        info="The type of dimensional upsampling to perform at the end of the fully connected "
             "layers, if upsamples > 0. The number of filters used for the upscale layers will be "
             "the value given in 'fc_upsample_filters'."
             "\n\tupsample2d - A lightweight and VRAM friendly method. 'quick and dirty' but does "
             "not learn any parameters"
             "\n\tsubpixel - Sub-pixel upscaler using depth-to-space which may require more "
             "VRAM."
             "\n\tresize_images - Uses the Keras resize_image function to save about half as much "
             "vram as the heaviest methods."
             "\n\tupscale_fast - Developed by Andenixa. Focusses on speed to upscale, but "
             "requires more VRAM."
             "\n\tupscale_hybrid - Developed by Andenixa. Uses a combination of PixelShuffler and "
             "Upsampling2D to upscale, saving about 1/3rd of VRAM of the heaviest methods.",
        datatype=str,
        choices=["resize_images", "subpixel", "upscale_fast", "upscale_hybrid", "upsample2d"],
        group="hidden layers",
        gui_radio=False,
        fixed=True),
    fc_upsamples=dict(
        default=1,
        info="Some upsampling can occur within the Fully Connected layers rather than in the "
             "Decoder to increase the dimensional space. Set how many upscale layers should occur "
             "within the Fully Connected layers.",
        datatype=int,
        min_max=(0, 4),
        rounding=1,
        group="hidden layers",
        fixed=True),
    fc_upsample_filters=dict(
        default=512,
        info="If you have selected an upsampler which requires filters (i.e. any upsampler with "
             "the exception of Upsampling2D), then this is the number of filters to be used for "
             "the upsamplers within the fully connected layers,  NB: This value may be scaled "
             "down, depending on output resolution. Also note, that this figure will dictate the "
             "number of filters used for the G-Block, if selected.",
        datatype=int,
        rounding=64,
        min_max=(128, 5120),
        group="hidden layers",
        fixed=True),
 </s> add     "fc_depth": {
        "default": 1,
        "info": (
            "The number of consecutive Dense (fully connected) layers to include in each "
            "side's intermediate layer."),
        "datatype": int,
        "rounding": 1,
        "min_max": (0, 16),
        "group": "hidden layers",
        "fixed": True},
    "fc_min_filters": {
        "default": 1024,
        "info": (
            "The number of filters to use for the initial fully connected layer. The number of "
            "nodes actually used is: fc_min_filters x fc_dimensions x fc_dimensions.\nNB: This "
            "value may be scaled down, depending on output resolution."),
        "datatype": int,
        "rounding": 16,
        "min_max": (16, 5120),
        "group": "hidden layers",
        "fixed": True},
    "fc_max_filters": {
        "default": 1024,
        "info": (
            "This is the number of filters to be used in the final reshape layer at the end of "
            "the fully connected layers. The actual number of nodes used for the final fully "
            "connected layer is: fc_min_filters x fc_dimensions x fc_dimensions.\nNB: This value "
            "may be scaled down, depending on output resolution."),
        "datatype": int,
        "rounding": 64,
        "min_max": (128, 5120),
        "group": "hidden layers",
        "fixed": True},
    "fc_dimensions": {
        "default": 4,
        "info": (
            "The height and width dimension for the final reshape layer at the end of the "
            "fully connected layers.\nNB: The total number of nodes within the final fully "
            "connected layer will be: fc_dimensions x fc_dimensions x fc_max_filters."),
        "datatype": int,
        "rounding": 1,
        "min_max": (1, 16),
        "group": "hidden layers",
        "fixed": True},
    "fc_filter_slope": {
        "default": -0.5,
        "info": (
            "The rate that the filters move from the minimum number of filters to the maximum "
            "number of filters. EG:\n"
            "Negative numbers will change the number of filters quicker at first and slow down "
            "each layer.\n"
            "Positive numbers will change the number of filters slower at first but then speed "
            "up each layer.\n"
            "0.0 - This will change at a linear rate (i.e. the same number of filters will be "
            "changed at each layer)."),
        "datatype": float,
        "min_max": (-.99, .99),
        "rounding": 2,
        "group": "hidden layers",
        "fixed": True},
    "fc_dropout": {
        "default": 0.0,
        "info": (
            "Dropout is a form of regularization that can prevent a model from over-fitting "
            "and help to keep neurons 'alive'. 0.5 will dropout half the connections between each "
            "fully connected layer, 0.25 will dropout a quarter of the connections etc. Set to "
            "0.0 to disable."),
        "datatype": float,
        "rounding": 2,
        "min_max": (0.0, 0.99),
        "group": "hidden layers",
        "fixed": False},
    "fc_upsampler": {
        "default": "upsample2d",
        "info": (
            "The type of dimensional upsampling to perform at the end of the fully connected "
            "layers, if upsamples > 0. The number of filters used for the upscale layers will be "
            "the value given in 'fc_upsample_filters'."
            "\n\tupsample2d - A lightweight and VRAM friendly method. 'quick and dirty' but does "
            "not learn any parameters"
            "\n\tsubpixel - Sub-pixel upscaler using depth-to-space which may require more "
            "VRAM."
            "\n\tresize_images - Uses the Keras resize_image function to save about half as much "
            "vram as the heaviest methods."
            "\n\tupscale_fast - Developed by Andenixa. Focusses on speed to upscale, but "
            "requires more VRAM."
            "\n\tupscale_hybrid - Developed by Andenixa. Uses a combination of PixelShuffler and "
            "Upsampling2D to upscale, saving about 1/3rd of VRAM of the heaviest methods."),
        "datatype": str,
        "choices": ["resize_images", "subpixel", "upscale_fast", "upscale_hybrid", "upsample2d"],
        "group": "hidden layers",
        "gui_radio": False,
        "fixed": True},
    "fc_upsamples": {
        "default": 1,
        "info": (
            "Some upsampling can occur within the Fully Connected layers rather than in the "
            "Decoder to increase the dimensional space. Set how many upscale layers should occur "
            "within the Fully Connected layers."),
        "datatype": int,
        "min_max": (0, 4),
        "rounding": 1,
        "group": "hidden layers",
        "fixed": True},
    "fc_upsample_filters": {
        "default": 512,
        "info": (
            "If you have selected an upsampler which requires filters (i.e. any upsampler with "
            "the exception of Upsampling2D), then this is the number of filters to be used for "
            "the upsamplers within the fully connected layers,  NB: This value may be scaled "
            "down, depending on output resolution. Also note, that this figure will dictate the "
            "number of filters used for the G-Block, if selected."),
        "datatype": int,
        "rounding": 64,
        "min_max": (128, 5120),
        "group": "hidden layers",
        "fixed": True}, </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},
        info="BiseNet mask still runs fairly quickly on CPU on some setups. Enable "
          gui_radio=False,
          fixed=True),
      "cpu": dict(
          default=False,
        info="BiseNet mask still runs fairly quickly on CPU on some setups. Enable "
               "CPU mode here to use the CPU for this masker to save some VRAM at a speed cost.",
          datatype=bool,
          group="settings"),
      "weights": dict(
          default="faceswap",
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 
plugins/extract/mask/bisenet_fp_defaults.py