          group="g-block hidden layers",
          fixed=False),
  
      # Decoder
      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),
  
      # Weight management
      freeze_layers=dict(
          default="keras_encoder",
          info="If the command line option 'freeze-weights' is enabled, then the layers indicated "
 
</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     fc_gblock_depth=dict(
        default=3,
        info="The number of consecutive Dense (fully connected) layers to include in the G-Block "
             "shared layer.",
        datatype=int,
        rounding=1,
        min_max=(1, 16),
        group="g-block hidden layers",
        fixed=True),
    fc_gblock_min_nodes=dict(
        default=512,
        info="The number of nodes to use for the initial G-Block shared fully connected layer.",
        datatype=int,
        rounding=64,
        min_max=(128, 5120),
        group="g-block hidden layers",
        fixed=True),
    fc_gblock_max_nodes=dict(
        default=512,
        info="The number of nodes to use for the final G-Block shared fully connected layer.",
        datatype=int,
        rounding=64,
        min_max=(128, 5120),
        group="g-block hidden layers",
        fixed=True),
    fc_gblock_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 for the G-Block shared layers. 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="g-block hidden layers",
        fixed=True),
    fc_gblock_dropout=dict(
        default=0.0,
        info="Dropout is a regularization technique 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="g-block hidden layers",
        fixed=False),
 </s> add     "fc_gblock_depth": {
        "default": 3,
        "info": (
            "The number of consecutive Dense (fully connected) layers to include in the "
            "G-Block shared layer."),
        "datatype": int,
        "rounding": 1,
        "min_max": (1, 16),
        "group": "g-block hidden layers",
        "fixed": True},
    "fc_gblock_min_nodes": {
        "default": 512,
        "info": "The number of nodes to use for the initial G-Block shared fully connected layer.",
        "datatype": int,
        "rounding": 64,
        "min_max": (128, 5120),
        "group": "g-block hidden layers",
        "fixed": True},
    "fc_gblock_max_nodes": {
        "default": 512,
        "info": "The number of nodes to use for the final G-Block shared fully connected layer.",
        "datatype": int,
        "rounding": 64,
        "min_max": (128, 5120),
        "group": "g-block hidden layers",
        "fixed": True},
    "fc_gblock_filter_slope": {
        "default": -0.5,
        "info": (
            "The rate that the filters move from the minimum number of filters to the maximum "
            "number of filters for the G-Block shared layers. 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": "g-block hidden layers",
        "fixed": True},
    "fc_gblock_dropout": {
        "default": 0.0,
        "info": (
            "Dropout is a regularization technique 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": "g-block hidden layers",
        "fixed": False}, </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     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     fs_original_depth=dict(
        default=4,
        info="Faceswap Encoder only: The number of convolutions to perform within the encoder.",
        datatype=int,
        min_max=(2, 10),
        rounding=1,
        group="faceswap encoder configuration",
        fixed=True),
    fs_original_min_filters=dict(
        default=128,
        info="Faceswap Encoder only: The minumum number of filters to use for encoder "
             "convolutions. (i.e. the number of filters to use for the first encoder layer).",
        datatype=int,
        min_max=(16, 2048),
        rounding=64,
        group="faceswap encoder configuration",
        fixed=True),
    fs_original_max_filters=dict(
        default=1024,
        info="Faceswap Encoder only: The maximum number of filters to use for encoder "
             "convolutions. (i.e. the number of filters to use for the final encoder layer).",
        datatype=int,
        min_max=(256, 8192),
        rounding=128,
        group="faceswap encoder configuration",
        fixed=True),
    fs_original_use_alt=dict(
        default=False,
        info="Use a slightly alternate version of the Faceswap Encoder."
             "\n\tTrue - Use the alternate variation of the Faceswap Encoder."
             "\n\tFalse - Use the original Faceswap Encoder.",
        datatype=bool,
        group="faceswap encoder configuration",
        fixed=True),
 </s> add     "fs_original_depth": {
        "default": 4,
        "info": "Faceswap Encoder only: The number of convolutions to perform within the encoder.",
        "datatype": int,
        "min_max": (2, 10),
        "rounding": 1,
        "group": "faceswap encoder configuration",
        "fixed": True},
    "fs_original_min_filters": {
        "default": 128,
        "info": (
            "Faceswap Encoder only: The minumum number of filters to use for encoder "
            "convolutions. (i.e. the number of filters to use for the first encoder layer)."),
        "datatype": int,
        "min_max": (16, 2048),
        "rounding": 64,
        "group": "faceswap encoder configuration",
        "fixed": True},
    "fs_original_max_filters": {
        "default": 1024,
        "info": (
            "Faceswap Encoder only: The maximum number of filters to use for encoder "
            "convolutions. (i.e. the number of filters to use for the final encoder layer)."),
        "datatype": int,
        "min_max": (256, 8192),
        "rounding": 128,
        "group": "faceswap encoder configuration",
        "fixed": True},
    "fs_original_use_alt": {
        "default": False,
        "info": (
            "Use a slightly alternate version of the Faceswap Encoder."
            "\n\tTrue - Use the alternate variation of the Faceswap Encoder."
            "\n\tFalse - Use the original Faceswap Encoder."),
        "datatype": bool,
        "group": "faceswap encoder configuration",
        "fixed": True},
    "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},
          group="g-block hidden layers",
          fixed=False),
  
      # Decoder
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
    "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},
  
      # Weight management
      freeze_layers=dict(
          default="keras_encoder",
          info="If the command line option 'freeze-weights' is enabled, then the layers indicated "
keep keep keep keep replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace replace 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 
plugins/train/model/phaze_a_defaults.py