

import argparse

import torch

from transformers import ElectraConfig, ElectraForMaskedLM, ElectraForPreTraining, load_tf_weights_in_electra
from transformers.utils import logging


logging.set_verbosity_info()


def    _UpperCAmelCase    (					_SCREAMING_SNAKE_CASE   :						int	,				_SCREAMING_SNAKE_CASE   :						Tuple	,				_SCREAMING_SNAKE_CASE   :						Any	,				_SCREAMING_SNAKE_CASE   :						Tuple    ):





    """simple docstring"""


    SCREAMING_SNAKE_CASE_													=  ElectraConfig.from_json_file(_SCREAMING_SNAKE_CASE    )
    print(f"""Building PyTorch model from configuration: {config}"""    )

    if discriminator_or_generator == "discriminator":
        SCREAMING_SNAKE_CASE_													=  ElectraForPreTraining(_SCREAMING_SNAKE_CASE    )
    elif discriminator_or_generator == "generator":
        SCREAMING_SNAKE_CASE_													=  ElectraForMaskedLM(_SCREAMING_SNAKE_CASE    )
    else:
        raise ValueError('The discriminator_or_generator argument should be either \'discriminator\' or \'generator\''    )

    # Load weights from tf checkpoint
    load_tf_weights_in_electra(
        _SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE	,				_SCREAMING_SNAKE_CASE	,				discriminator_or_generator=_SCREAMING_SNAKE_CASE    )

    # Save pytorch-model
    print(f"""Save PyTorch model to {pytorch_dump_path}"""    )
    torch.save(model.state_dict()	,				_SCREAMING_SNAKE_CASE    )


if __name__ == "__main__":
       UpperCamelCase__					: Union[str, Any]								=      argparse.ArgumentParser()
       # Required parameters
       parser.add_argument(
           "--tf_checkpoint_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
       )
       parser.add_argument(
           "--config_file",
           default=None,
           type=str,
           required=True,
           help="The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.",
       )
       parser.add_argument(
           "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
       )
       parser.add_argument(
           "--discriminator_or_generator",
           default=None,
           type=str,
           required=True,
           help=(
               "Whether to export the generator or the discriminator. Should be a string, either 'discriminator' or "
               "'generator'."
           ),
       )
       UpperCamelCase__					: Union[str, Any]								=      parser.parse_args()
       convert_tf_checkpoint_to_pytorch(
           args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
       )





def    _UpperCAmelCase    (					_SCREAMING_SNAKE_CASE   :						int	,				_SCREAMING_SNAKE_CASE   :						int	,				_SCREAMING_SNAKE_CASE   :						int    ):





    """simple docstring"""


    if power < 0:
        return -1
    base %= mod
    SCREAMING_SNAKE_CASE_													=  1

    while power > 0:
        if power & 1:
            SCREAMING_SNAKE_CASE_													=  (result * base) % mod
        SCREAMING_SNAKE_CASE_													=  power >> 1
        SCREAMING_SNAKE_CASE_													=  (base * base) % mod

    return result


def    _UpperCAmelCase    (					):





    """simple docstring"""


    print(modular_exponential(3	,				200	,				13    )    )


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       main()


