
"""simple docstring"""




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 				a__			(					lowerCAmelCase						:							Tuple							,     lowerCAmelCase						:							Tuple							,     lowerCAmelCase						:							Tuple							,     lowerCAmelCase						:							Union[str, Any]		):






     '''simple docstring'''
     # Initialise PyTorch model
     UpperCAmelCase__				:			Optional[int]							=    ElectraConfig.from_json_file(_SCREAMING_SNAKE_CASE		)
     print(F"Building PyTorch model from configuration: {config}"		)

     if discriminator_or_generator == "discriminator":
          UpperCAmelCase__				:			Any							=    ElectraForPreTraining(_SCREAMING_SNAKE_CASE		)
     elif discriminator_or_generator == "generator":
          UpperCAmelCase__				:			int							=    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__":
    A__   :						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\'."""
        ),
    )
    A__   :						Optional[int] 							=     parser.parse_args()
    convert_tf_checkpoint_to_pytorch(
        args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
    )







"""simple docstring"""
import doctest

import projectq
from projectq.ops import H, Measure







def     _a					(   _SCREAMING_SNAKE_CASE					)     ->					int:
							snake_case_     							=		quantum_engine.allocate_qubit()
							H | qubit
							Measure | qubit
							return int(_SCREAMING_SNAKE_CASE					)


if __name__ == "__main__":
				doctest.testmod()

				# initialises a new quantum backend
				__SCREAMING_SNAKE_CASE				:     Dict		=     projectq.MainEngine()

				# Generate a list of 10 random numbers
				__SCREAMING_SNAKE_CASE				:     Optional[Any]		=     [get_random_number(quantum_engine) for _ in range(10)]

				# Flushes the quantum engine from memory
				quantum_engine.flush()

				print('Random numbers', random_numbers_list)



