


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       lowerCAmelCase			(		lowerCAmelCase_			, lowerCAmelCase_			, lowerCAmelCase_			, lowerCAmelCase_			)->			Dict:
				# Initialise PyTorch model
				lowerCAmelCase_			:   int     					=					ElectraConfig.from_json_file(a__			)
				print(f"""Building PyTorch model from configuration: {config}"""			)

				if discriminator_or_generator == "discriminator":
								lowerCAmelCase_			:   Optional[Any]     					=					ElectraForPreTraining(a__			)
				elif discriminator_or_generator == "generator":
								lowerCAmelCase_			:   List[str]     					=					ElectraForMaskedLM(a__			)
				else:
								raise ValueError('''The discriminator_or_generator argument should be either \'discriminator\' or \'generator\''''			)

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

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


if __name__ == "__main__":
						_UpperCAmelCase      :	Optional[int]  =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      :	int  =parser.parse_args()
						convert_tf_checkpoint_to_pytorch(
						    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
						)

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_A							=       {'''configuration_dinat''': ['''DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DinatConfig''']}


try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      _A							=       [
          '''DINAT_PRETRAINED_MODEL_ARCHIVE_LIST''',
          '''DinatForImageClassification''',
          '''DinatModel''',
          '''DinatPreTrainedModel''',
          '''DinatBackbone''',
      ]

if TYPE_CHECKING:
      from .configuration_dinat import DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP, DinatConfig

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_dinat import (
                DINAT_PRETRAINED_MODEL_ARCHIVE_LIST,
                DinatBackbone,
                DinatForImageClassification,
                DinatModel,
                DinatPreTrainedModel,
            )

else:
      import sys

      _A							=       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



