




import inspect
import os
import unittest

import torch

import accelerate
from accelerate import debug_launcher
from accelerate.test_utils import (
    execute_subprocess_async,
    require_cpu,
    require_multi_gpu,
    require_single_gpu,
    test_sync,
)
from accelerate.utils import patch_environment




class       UpperCAmelCase_   ( unittest.TestCase							):




							'''simple docstring'''



							def  _UpperCAmelCase  (       self							:						Union[str, Any]      )      ->       Optional[int]:
										SCREAMING_SNAKE_CASE     =       inspect.getfile(accelerate.test_utils      )
										SCREAMING_SNAKE_CASE     =       os.path.sep.join(mod_file.split(os.path.sep      )[:-1] + ["""scripts""", """test_sync.py"""]      )





							@require_cpu
							def  _UpperCAmelCase  (       self							:						Dict      )      ->       Optional[Any]:
										debug_launcher(test_sync.main							,  num_processes=1      )





							@require_cpu
							def  _UpperCAmelCase  (       self							:						str      )      ->       Any:
										debug_launcher(test_sync.main      )





							@require_single_gpu
							def  _UpperCAmelCase  (       self							:						Any      )      ->       List[str]:
										test_sync.main()







							@require_multi_gpu
							def  _UpperCAmelCase  (       self							:						Optional[Any]      )      ->       Dict:
										print(f"""Found {torch.cuda.device_count()} devices."""      )
										SCREAMING_SNAKE_CASE     =       ["""torchrun""", f"""--nproc_per_node={torch.cuda.device_count()}""", self.test_file_path]
										with patch_environment(omp_num_threads=1      ):
													execute_subprocess_async(a							,  env=os.environ.copy()      )












import argparse

from transformers import ConvBertConfig, ConvBertModel, TFConvBertModel, load_tf_weights_in_convbert
from transformers.utils import logging


logging.set_verbosity_info()
def        lowerCamelCase_     (     SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE ):
			'''simple docstring'''
			SCREAMING_SNAKE_CASE     =       ConvBertConfig.from_json_file(SCREAMING_SNAKE_CASE )
			SCREAMING_SNAKE_CASE     =       ConvBertModel(SCREAMING_SNAKE_CASE )

			SCREAMING_SNAKE_CASE     =       load_tf_weights_in_convbert(SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE       ,						SCREAMING_SNAKE_CASE )
			model.save_pretrained(SCREAMING_SNAKE_CASE )

			SCREAMING_SNAKE_CASE     =       TFConvBertModel.from_pretrained(SCREAMING_SNAKE_CASE       ,						from_pt=SCREAMING_SNAKE_CASE )
			tf_model.save_pretrained(SCREAMING_SNAKE_CASE )


if __name__ == "__main__":
		__A    :				str    						=	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(
		    """--convbert_config_file""",
		    default=None,
		    type=str,
		    required=True,
		    help=(
		        """The config json file corresponding to the pre-trained ConvBERT model. \n"""
		        """This specifies the model architecture."""
		    ),
		)
		parser.add_argument(
		    """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
		)
		__A    :				List[Any]    						=	parser.parse_args()
		convert_orig_tfa_checkpoint_to_pytorch(args.tf_checkpoint_path, args.convbert_config_file, args.pytorch_dump_path)






