  msgstr ""
  
  #: plugins/train/_config.py:258
  msgid ""
  "[Not PlaidML] Apply AutoClipping to the gradients. AutoClip analyzes the "
  "gradient weights and adjusts the normalization value dynamically to fit the "
  "data. Can help prevent NaNs and improve model optimization at the expense of "
  "VRAM. Ref: AutoClip: Adaptive Gradient Clipping for Source Separation "
  "Networks https://arxiv.org/abs/2007.14469"
  msgstr ""
 
</s> remove "[Not PlaidML], NVIDIA GPUs can run operations in float16 faster than in "
 </s> add "NVIDIA GPUs can run operations in float16 faster than in " </s> remove     enc_architecture=dict(
        default="fs_original",
        info="The encoder architecture to use. See the relevant config sections for specific "
             "architecture tweaking.\nNB: For keras based pre-built models, the global "
             "initializers and padding options will be ignored for the selected encoder."
             "\n\n\tdensenet: (32px -224px). Ref: Densely Connected Convolutional Networks "
             "(2016): https://arxiv.org/abs/1608.06993?source=post_page"
             "\n\n\tefficientnet: [Tensorflow 2.3+ only] EfficientNet has numerous variants (B0 - "
             "B8) that increases the model width, depth and dimensional space at each step. The "
             "minimum input resolution is 32px for all variants. The maximum input resolution for "
             "each variant is: b0: 224px, b1: 240px, b2: 260px, b3: 300px, b4: 380px, b5: 456px, "
             "b6: 528px, b7 600px. Ref: Rethinking Model Scaling for Convolutional Neural "
             "Networks (2020): https://arxiv.org/abs/1905.11946"
             "\n\n\tefficientnet_v2: [Tensorflow 2.8+ only] EfficientNetV2 is the follow up to "
             "efficientnet. It has numerous variants (B0 - B3 and Small, Medium and Large) that "
             "increases the model width, depth and dimensional space at each step. The minimum "
             "input resolution is 32px for all variants. The maximum input resolution for each "
             "variant is: b0: 224px, b1: 240px, b2: 260px, b3: 300px, s: 384px, m: 480px, l: "
             "480px. Ref: EfficientNetV2: Smaller Models and Faster Training (2021): "
             "https://arxiv.org/abs/2104.00298"
             "\n\n\tfs_original: (32px - 1024px). A configurable variant of the original facewap "
             "encoder. ImageNet weights cannot be loaded for this model. Additional parameters "
             "can be configured with the 'fs_enc' options. A version of this encoder is used in "
             "the following models: Original, Original (lowmem), Dfaker, DFL-H128, DFL-SAE, IAE, "
             "Lightweight."
             "\n\n\tinception_resnet_v2: (75px - 299px). Ref: Inception-ResNet and the Impact of "
             "Residual Connections on Learning (2016): https://arxiv.org/abs/1602.07261"
             "\n\n\tinceptionV3: (75px - 299px). Ref: Rethinking the Inception Architecture for "
             "Computer Vision (2015): https://arxiv.org/abs/1512.00567"
             "\n\n\tmobilenet: (32px - 224px). Additional MobileNet parameters can be set with "
             "the 'mobilenet' options. Ref: MobileNets: Efficient Convolutional Neural Networks "
             "for Mobile Vision Applications (2017): https://arxiv.org/abs/1704.04861"
             "\n\n\tmobilenet_v2: (32px - 224px). Additional MobileNet parameters can be set with "
             "the 'mobilenet' options. Ref: MobileNetV2: Inverted Residuals and Linear "
             "Bottlenecks (2018): https://arxiv.org/abs/1801.04381"
             "\n\n\tmobilenet_v3: (32px - 224px). Additional MobileNet parameters can be set with "
             "the 'mobilenet' options. Ref: Searching for MobileNetV3 (2019): "
             "https://arxiv.org/pdf/1905.02244.pdf"
             "\n\n\tnasnet: (32px - 331px (large) or 224px (mobile)). Ref: Learning Transferable "
             "Architectures for Scalable Image Recognition (2017): "
             "https://arxiv.org/abs/1707.07012"
             "\n\n\tresnet: (32px - 224px). Deep Residual Learning for Image Recognition (2015): "
             "https://arxiv.org/abs/1512.03385"
             "\n\n\tvgg: (32px - 224px). Very Deep Convolutional Networks for Large-Scale Image "
             "Recognition (2014): https://arxiv.org/abs/1409.1556"
             "\n\n\txception: (71px - 229px). Ref: Deep Learning with Depthwise Separable "
             "Convolutions (2017): https://arxiv.org/abs/1409.1556.\n",
        datatype=str,
        choices=_ENCODERS,
        gui_radio=False,
        group="encoder",
        fixed=True),
    enc_scaling=dict(
        default=7,
        info="Input scaling for the encoder. Some of the encoders have large input sizes, which "
             "often are not helpful for Faceswap. This setting scales the dimensional space that "
             "the encoder works in. For example an encoder with a maximum input size of 224px "
             "will be input an image of 112px at 50%% scaling. See the Architecture tooltip for "
             "the minimum and maximum sizes for each encoder. NB: The input size will be rounded "
             "down to the nearest 16 pixels.",
        datatype=int,
        min_max=(0, 100),
        rounding=1,
        group="encoder",
        fixed=True),
    enc_load_weights=dict(
        default=True,
        info="Load pre-trained weights trained on ImageNet data. Only available for non-Faceswap "
             "encoders (i.e. those not beginning with 'fs'). NB: If you use the global 'load "
             "weights' option and have selected to load weights from a previous model's 'encoder' "
             "or 'keras_encoder' then the weights loaded here will be replaced by the weights "
             "loaded from your saved model.",
        datatype=bool,
        group="encoder",
        fixed=True),
 </s> add     "enc_architecture": {
        "default": "fs_original",
        "info": (
            "The encoder architecture to use. See the relevant config sections for specific "
            "architecture tweaking.\nNB: For keras based pre-built models, the global "
            "initializers and padding options will be ignored for the selected encoder."
            "\n\n\tdensenet: (32px -224px). Ref: Densely Connected Convolutional Networks "
            "(2016): https://arxiv.org/abs/1608.06993?source=post_page"
            "\n\n\tefficientnet: [Tensorflow 2.3+ only] EfficientNet has numerous variants (B0 - "
            "B8) that increases the model width, depth and dimensional space at each step. The "
            "minimum input resolution is 32px for all variants. The maximum input resolution for "
            "each variant is: b0: 224px, b1: 240px, b2: 260px, b3: 300px, b4: 380px, b5: 456px, "
            "b6: 528px, b7 600px. Ref: Rethinking Model Scaling for Convolutional Neural "
            "Networks (2020): https://arxiv.org/abs/1905.11946"
            "\n\n\tefficientnet_v2: [Tensorflow 2.8+ only] EfficientNetV2 is the follow up to "
            "efficientnet. It has numerous variants (B0 - B3 and Small, Medium and Large) that "
            "increases the model width, depth and dimensional space at each step. The minimum "
            "input resolution is 32px for all variants. The maximum input resolution for each "
            "variant is: b0: 224px, b1: 240px, b2: 260px, b3: 300px, s: 384px, m: 480px, l: "
            "480px. Ref: EfficientNetV2: Smaller Models and Faster Training (2021): "
            "https://arxiv.org/abs/2104.00298"
            "\n\n\tfs_original: (32px - 1024px). A configurable variant of the original facewap "
            "encoder. ImageNet weights cannot be loaded for this model. Additional parameters "
            "can be configured with the 'fs_enc' options. A version of this encoder is used in "
            "the following models: Original, Original (lowmem), Dfaker, DFL-H128, DFL-SAE, IAE, "
            "Lightweight."
            "\n\n\tinception_resnet_v2: (75px - 299px). Ref: Inception-ResNet and the Impact of "
            "Residual Connections on Learning (2016): https://arxiv.org/abs/1602.07261"
            "\n\n\tinceptionV3: (75px - 299px). Ref: Rethinking the Inception Architecture for "
            "Computer Vision (2015): https://arxiv.org/abs/1512.00567"
            "\n\n\tmobilenet: (32px - 224px). Additional MobileNet parameters can be set with "
            "the 'mobilenet' options. Ref: MobileNets: Efficient Convolutional Neural Networks "
            "for Mobile Vision Applications (2017): https://arxiv.org/abs/1704.04861"
            "\n\n\tmobilenet_v2: (32px - 224px). Additional MobileNet parameters can be set with "
            "the 'mobilenet' options. Ref: MobileNetV2: Inverted Residuals and Linear "
            "Bottlenecks (2018): https://arxiv.org/abs/1801.04381"
            "\n\n\tmobilenet_v3: (32px - 224px). Additional MobileNet parameters can be set with "
            "the 'mobilenet' options. Ref: Searching for MobileNetV3 (2019): "
            "https://arxiv.org/pdf/1905.02244.pdf"
            "\n\n\tnasnet: (32px - 331px (large) or 224px (mobile)). Ref: Learning Transferable "
            "Architectures for Scalable Image Recognition (2017): "
            "https://arxiv.org/abs/1707.07012"
            "\n\n\tresnet: (32px - 224px). Deep Residual Learning for Image Recognition (2015): "
            "https://arxiv.org/abs/1512.03385"
            "\n\n\tvgg: (32px - 224px). Very Deep Convolutional Networks for Large-Scale Image "
            "Recognition (2014): https://arxiv.org/abs/1409.1556"
            "\n\n\txception: (71px - 229px). Ref: Deep Learning with Depthwise Separable "
            "Convolutions (2017): https://arxiv.org/abs/1409.1556.\n"),
        "datatype": str,
        "choices": _ENCODERS,
        "gui_radio": False,
        "group": "encoder",
        "fixed": True},
    "enc_scaling": {
        "default": 7,
        "info": (
            "Input scaling for the encoder. Some of the encoders have large input sizes, which "
            "often are not helpful for Faceswap. This setting scales the dimensional space that "
            "the encoder works in. For example an encoder with a maximum input size of 224px "
            "will be input an image of 112px at 50%% scaling. See the Architecture tooltip for "
            "the minimum and maximum sizes for each encoder. NB: The input size will be rounded "
            "down to the nearest 16 pixels."),
        "datatype": int,
        "min_max": (0, 100),
        "rounding": 1,
        "group": "encoder",
        "fixed": True},
    "enc_load_weights": {
        "default": True,
        "info": (
            "Load pre-trained weights trained on ImageNet data. Only available for non-"
            "Faceswap encoders (i.e. those not beginning with 'fs'). NB: If you use the global "
            "'load weights' option and have selected to load weights from a previous model's "
            "'encoder' or 'keras_encoder' then the weights loaded here will be replaced by the "
            "weights loaded from your saved model."),
        "datatype": bool,
        "group": "encoder",
        "fixed": True}, </s> remove     dec_upscale_method=dict(
        default="subpixel",
        info="The method to use for the upscales within the decoder. Images are upscaled multiple "
             "times within the decoder as the network learns to reconstruct the face."
             "\n\tsubpixel - Sub-pixel upscaler using depth-to-space which requires more "
             "VRAM."
             "\n\tresize_images - Uses the Keras resize_image function to save about half as much "
             "vram as the heaviest methods."
             "\n\tupscale_fast - Developed by Andenixa. Focusses on speed to upscale, but "
             "requires more VRAM."
             "\n\tupscale_hybrid - Developed by Andenixa. Uses a combination of PixelShuffler and "
             "Upsampling2D to upscale, saving about 1/3rd of VRAM of the heaviest methods."
             "\n\tupscale_dny - An alternative upscale implementation using Upsampling2D to "
             "upsale.",
        datatype=str,
        choices=["subpixel", "resize_images", "upscale_fast", "upscale_hybrid", "upscale_dny"],
        gui_radio=True,
        group="decoder",
        fixed=True),
    dec_upscales_in_fc=dict(
        default=0,
        min_max=(0, 6),
        rounding=1,
        info="It is possible to place some of the upscales at the end of the fully connected "
        "model. For models with split decoders, but a shared fully connected layer, this would "
        "have the effect of saving some VRAM but possibly at the cost of introducing artefacts. "
        "For models with a shared decoder but split fully connected layers, this would have the "
        "effect of increasing VRAM usage by processing some of the upscales for each side rather "
        "than together.",
        datatype=int,
        group="decoder",
        fixed=True),
    dec_norm=dict(
        default="none",
        info="Normalization to apply to apply after each upscale."
             "\n\tnone - Do not apply a normalization layer"
             "\n\tbatch - Apply Batch Normalization"
             "\n\tgroup - Apply Group Normalization"
             "\n\tinstance - Apply Instance Normalization"
             "\n\tlayer - Apply Layer Normalization (Ba et al., 2016)"
             "\n\trms - Apply Root Mean Squared Layer Normalization (Zhang et al., 2019). A "
             "simplified version of Layer Normalization with reduced overhead.",
        datatype=str,
        gui_radio=True,
        choices=["none", "batch", "group", "instance", "layer", "rms"],
        group="decoder",
        fixed=True),
    dec_min_filters=dict(
        default=64,
        info="The minimum number of filters to use in decoder upscalers (i.e. the number of "
             "filters to use for the final upscale layer).",
        datatype=int,
        min_max=(16, 512),
        rounding=16,
        group="decoder",
        fixed=True),
    dec_max_filters=dict(
        default=512,
        info="The maximum number of filters to use in decoder upscalers (i.e. the number of "
             "filters to use for the first upscale layer).",
        datatype=int,
        min_max=(256, 5120),
        rounding=64,
        group="decoder",
        fixed=True),
    dec_slope_mode=dict(
        default="full",
        info="Alters the action of the filter slope.\n"
             "\n\tfull: The number of filters at each upscale layer will reduce from the chosen "
             "max_filters at the first layer to the chosen min_filters at the last layer as "
             "dictated by the dec_filter_slope."
             "\n\tcap_max: The filters will decline at a fixed rate from each upscale to the next "
             "based on the filter_slope setting. If there are more upscales than filters, "
             "then the earliest upscales will be capped at the max_filter value until the filters "
             "can reduce to the min_filters value at the final upscale. (EG: 512 -> 512 -> 512 -> "
             "256 -> 128 -> 64)."
             "\n\tcap_min: The filters will decline at a fixed rate from each upscale to the next "
             "based on the filter_slope setting. If there are more upscales than filters, then "
             "the earliest upscales will drop their filters until the min_filter value is met and "
             "repeat the min_filter value for the remaining upscales. (EG: 512 -> 256 -> 128 -> "
             "64 -> 64 -> 64).",
        choices=["full", "cap_max", "cap_min"],
        group="decoder",
        fixed=True,
        gui_radio=True),
    dec_filter_slope=dict(
        default=-0.45,
        info="The rate that the filters reduce at each upscale layer.\n"
             "\n\tFull Slope Mode: Negative numbers will drop the number of filters quicker at "
             "first and slow down each upscale. Positive numbers will drop the number of filters "
             "slower at first but then speed up each upscale. A value of 0.0 will reduce at a "
             "linear rate (i.e. the same number of filters will be reduced at each upscale).\n"
             "\n\tCap Min/Max Slope Mode: Only positive values will work here. Negative values "
             "will automatically be converted to their positive counterpart. A value of 0.5 will "
             "halve the number of filters at each upscale until the minimum value is reached. A "
             "value of 0.33 will be reduce the number of filters by a third until the minimum "
             "value is reached etc.",
        datatype=float,
        min_max=(-.99, .99),
        rounding=2,
        group="decoder",
        fixed=True),
    dec_res_blocks=dict(
        default=1,
        info="The number of Residual Blocks to apply to each upscale layer. Set to 0 to disable "
             "residual blocks entirely.",
        datatype=int,
        rounding=1,
        min_max=(0, 8),
        group="decoder",
        fixed=True),
    dec_output_kernel=dict(
        default=5,
        info="The kernel size to apply to the final Convolution layer.",
        datatype=int,
        rounding=2,
        min_max=(1, 9),
        group="decoder",
        fixed=True),
    dec_gaussian=dict(
        default=True,
        info="Gaussian Noise acts as a regularization technique for preventing overfitting of "
             "data."
             "\n\tTrue - Apply a Gaussian Noise layer to each upscale."
             "\n\tFalse - Don't apply a Gaussian Noise layer to each upscale.",
        datatype=bool,
        group="decoder",
        fixed=True),
    dec_skip_last_residual=dict(
        default=True,
        info="If Residual blocks have been enabled, enabling this option will not apply a "
             "Residual block to the final upscaler."
             "\n\tTrue - Don't apply a Residual block to the final upscale."
             "\n\tFalse - Apply a Residual block to all upscale layers.",
        datatype=bool,
        group="decoder",
        fixed=True),
 </s> add     "dec_upscale_method": {
        "default": "subpixel",
        "info": (
            "The method to use for the upscales within the decoder. Images are upscaled "
            "multiple times within the decoder as the network learns to reconstruct the face."
            "\n\tsubpixel - Sub-pixel upscaler using depth-to-space which requires more "
            "VRAM."
            "\n\tresize_images - Uses the Keras resize_image function to save about half as much "
            "vram as the heaviest methods."
            "\n\tupscale_fast - Developed by Andenixa. Focusses on speed to upscale, but "
            "requires more VRAM."
            "\n\tupscale_hybrid - Developed by Andenixa. Uses a combination of PixelShuffler and "
            "Upsampling2D to upscale, saving about 1/3rd of VRAM of the heaviest methods."
            "\n\tupscale_dny - An alternative upscale implementation using Upsampling2D to "
            "upsale."),
        "datatype": str,
        "choices": ["subpixel", "resize_images", "upscale_fast", "upscale_hybrid", "upscale_dny"],
        "gui_radio": True,
        "group": "decoder",
        "fixed": True},
    "dec_upscales_in_fc": {
        "default": 0,
        "min_max": (0, 6),
        "rounding": 1,
        "info": (
            "It is possible to place some of the upscales at the end of the fully connected "
            "model. For models with split decoders, but a shared fully connected layer, this "
            "would have the effect of saving some VRAM but possibly at the cost of introducing "
            "artefacts. For models with a shared decoder but split fully connected layers, this "
            "would have the effect of increasing VRAM usage by processing some of the upscales "
            "for each side rather than together."),
        "datatype": int,
        "group": "decoder",
        "fixed": True},
    "dec_norm": {
        "default": "none",
        "info": (
            "Normalization to apply to apply after each upscale."
            "\n\tnone - Do not apply a normalization layer"
            "\n\tbatch - Apply Batch Normalization"
            "\n\tgroup - Apply Group Normalization"
            "\n\tinstance - Apply Instance Normalization"
            "\n\tlayer - Apply Layer Normalization (Ba et al., 2016)"
            "\n\trms - Apply Root Mean Squared Layer Normalization (Zhang et al., 2019). A "
            "simplified version of Layer Normalization with reduced overhead."),
        "datatype": str,
        "gui_radio": True,
        "choices": ["none", "batch", "group", "instance", "layer", "rms"],
        "group": "decoder",
        "fixed": True},
    "dec_min_filters": {
        "default": 64,
        "info": (
            "The minimum number of filters to use in decoder upscalers (i.e. the number of "
            "filters to use for the final upscale layer)."),
        "datatype": int,
        "min_max": (16, 512),
        "rounding": 16,
        "group": "decoder",
        "fixed": True},
    "dec_max_filters": {
        "default": 512,
        "info": (
            "The maximum number of filters to use in decoder upscalers (i.e. the number of "
            "filters to use for the first upscale layer)."),
        "datatype": int,
        "min_max": (256, 5120),
        "rounding": 64,
        "group": "decoder",
        "fixed": True},
    "dec_slope_mode": {
        "default": "full",
        "info": (
            "Alters the action of the filter slope.\n"
            "\n\tfull: The number of filters at each upscale layer will reduce from the chosen "
            "max_filters at the first layer to the chosen min_filters at the last layer as "
            "dictated by the dec_filter_slope."
            "\n\tcap_max: The filters will decline at a fixed rate from each upscale to the next "
            "based on the filter_slope setting. If there are more upscales than filters, "
            "then the earliest upscales will be capped at the max_filter value until the filters "
            "can reduce to the min_filters value at the final upscale. (EG: 512 -> 512 -> 512 -> "
            "256 -> 128 -> 64)."
            "\n\tcap_min: The filters will decline at a fixed rate from each upscale to the next "
            "based on the filter_slope setting. If there are more upscales than filters, then "
            "the earliest upscales will drop their filters until the min_filter value is met and "
            "repeat the min_filter value for the remaining upscales. (EG: 512 -> 256 -> 128 -> "
            "64 -> 64 -> 64)."),
        "choices": ["full", "cap_max", "cap_min"],
        "group": "decoder",
        "fixed": True,
        "gui_radio": True},
    "dec_filter_slope": {
        "default": -0.45,
        "info": (
            "The rate that the filters reduce at each upscale layer.\n"
            "\n\tFull Slope Mode: Negative numbers will drop the number of filters quicker at "
            "first and slow down each upscale. Positive numbers will drop the number of filters "
            "slower at first but then speed up each upscale. A value of 0.0 will reduce at a "
            "linear rate (i.e. the same number of filters will be reduced at each upscale).\n"
            "\n\tCap Min/Max Slope Mode: Only positive values will work here. Negative values "
            "will automatically be converted to their positive counterpart. A value of 0.5 will "
            "halve the number of filters at each upscale until the minimum value is reached. A "
            "value of 0.33 will be reduce the number of filters by a third until the minimum "
            "value is reached etc."),
        "datatype": float,
        "min_max": (-.99, .99),
        "rounding": 2,
        "group": "decoder",
        "fixed": True},
    "dec_res_blocks": {
        "default": 1,
        "info": (
            "The number of Residual Blocks to apply to each upscale layer. Set to 0 to disable "
            "residual blocks entirely."),
        "datatype": int,
        "rounding": 1,
        "min_max": (0, 8),
        "group": "decoder",
        "fixed": True},
    "dec_output_kernel": {
        "default": 5,
        "info": "The kernel size to apply to the final Convolution layer.",
        "datatype": int,
        "rounding": 2,
        "min_max": (1, 9),
        "group": "decoder",
        "fixed": True},
    "dec_gaussian": {
        "default": True,
        "info": (
            "Gaussian Noise acts as a regularization technique for preventing overfitting of "
            "data."
            "\n\tTrue - Apply a Gaussian Noise layer to each upscale."
            "\n\tFalse - Don't apply a Gaussian Noise layer to each upscale."),
        "datatype": bool,
        "group": "decoder",
        "fixed": True},
    "dec_skip_last_residual": {
        "default": True,
        "info": (
            "If Residual blocks have been enabled, enabling this option will not apply a "
            "Residual block to the final upscaler."
            "\n\tTrue - Don't apply a Residual block to the final upscale."
            "\n\tFalse - Apply a Residual block to all upscale layers."),
        "datatype": bool,
        "group": "decoder",
        "fixed": True}, </s> remove     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},
"Apply AutoClipping to the gradients. AutoClip analyzes the "
  msgstr ""
  
  #: plugins/train/_config.py:258
  msgid ""
"Apply AutoClipping to the gradients. AutoClip analyzes the "
  "gradient weights and adjusts the normalization value dynamically to fit the "
  "data. Can help prevent NaNs and improve model optimization at the expense of "
  "VRAM. Ref: AutoClip: Adaptive Gradient Clipping for Source Separation "
  "Networks https://arxiv.org/abs/2007.14469"
  msgstr ""
keep keep keep keep replace keep keep keep keep keep
 Remove plaidML support (#1325)

* Remove PlaidML reference from readme files

* Remove AMD option from installers

* remove amd requirements and update setup.py

* remove plaidml test from CI workflow

* gpustats: remove plaidml backend

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

* remove tf2.2 specific code from GUI event reader

* lib.model - remove all plaidml implementations

* plugins.extract - remove plaidml code

* plugins.train remove plaidml code

* lib.convert - remove plaidml code

* tools.model: remove plaidml code

* Remove plaidML tests from unit tests

* remove plaidml_utils and docsting cleanups

* Remove plaidML refs from configs

* fix keras imports 
locales/plugins.train._config.pot