
"""simple docstring"""






from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand





def __A						(   a_ :							Namespace     )->							Tuple:




		'''simple docstring'''






		return ConvertCommand(
		    args.model_type		,		args.tf_checkpoint		,		args.pytorch_dump_output		,		args.config		,		args.finetuning_task_name     )


lowerCamelCase__ :       int						     =			"\ntransformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires\nTensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.\n"




class 				lowercase__(				_UpperCAmelCase   ):
	'''simple docstring'''

	@staticmethod
	def   __lowerCAmelCase (						lowerCamelCase_    :ArgumentParser					)							->			Any:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     str				= parser.add_parser(
			    '''convert'''		, help='''CLI tool to run convert model from original author checkpoints to Transformers PyTorch checkpoints.'''		, )
			train_parser.add_argument('''--model_type'''		, type=lowerCamelCase_		, required=lowerCamelCase_		, help='''Model\'s type.'''					)
			train_parser.add_argument(
			    '''--tf_checkpoint'''		, type=lowerCamelCase_		, required=lowerCamelCase_		, help='''TensorFlow checkpoint path or folder.'''					)
			train_parser.add_argument(
			    '''--pytorch_dump_output'''		, type=lowerCamelCase_		, required=lowerCamelCase_		, help='''Path to the PyTorch saved model output.'''					)
			train_parser.add_argument('''--config'''		, type=lowerCamelCase_		, default=''''''		, help='''Configuration file path or folder.'''					)
			train_parser.add_argument(
			    '''--finetuning_task_name'''		, type=lowerCamelCase_		, default=lowerCamelCase_		, help='''Optional fine-tuning task name if the TF model was a finetuned model.'''		, )
			train_parser.set_defaults(func=lowerCamelCase_					)





	def __init__(						self    :List[Any]		, lowerCamelCase_    :str		, lowerCamelCase_    :str		, lowerCamelCase_    :str		, lowerCamelCase_    :str		, lowerCamelCase_    :str		, *lowerCamelCase_    :Dict		, )							->			Union[str, Any]:







			'''simple docstring'''




			SCREAMING_SNAKE_CASE       :     Optional[Any]				= logging.get_logger('''transformers-cli/converting'''					)

			self._logger.info(f"Loading model {model_type}"					)
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= model_type
			SCREAMING_SNAKE_CASE       :     List[Any]				= tf_checkpoint
			SCREAMING_SNAKE_CASE       :     List[str]				= pytorch_dump_output
			SCREAMING_SNAKE_CASE       :     Optional[int]				= config
			SCREAMING_SNAKE_CASE       :     str				= finetuning_task_name







	def   __lowerCAmelCase (						self    :List[str]					)							->			List[Any]:







			'''simple docstring'''




			if self._model_type == "albert":
					try:
							from ..models.albert.convert_albert_original_tf_checkpoint_to_pytorch import (
							    convert_tf_checkpoint_to_pytorch,
							)
					except ImportError:
							raise ImportError(lowerCamelCase_					)

					convert_tf_checkpoint_to_pytorch(self._tf_checkpoint		, self._config		, self._pytorch_dump_output					)
			elif self._model_type == "bert":
					try:
							from ..models.bert.convert_bert_original_tf_checkpoint_to_pytorch import (
							    convert_tf_checkpoint_to_pytorch,
							)
					except ImportError:
							raise ImportError(lowerCamelCase_					)

					convert_tf_checkpoint_to_pytorch(self._tf_checkpoint		, self._config		, self._pytorch_dump_output					)
			elif self._model_type == "funnel":
					try:
							from ..models.funnel.convert_funnel_original_tf_checkpoint_to_pytorch import (
							    convert_tf_checkpoint_to_pytorch,
							)
					except ImportError:
							raise ImportError(lowerCamelCase_					)

					convert_tf_checkpoint_to_pytorch(self._tf_checkpoint		, self._config		, self._pytorch_dump_output					)
			elif self._model_type == "t5":
					try:
							from ..models.ta.convert_ta_original_tf_checkpoint_to_pytorch import convert_tf_checkpoint_to_pytorch
					except ImportError:
							raise ImportError(lowerCamelCase_					)

					convert_tf_checkpoint_to_pytorch(self._tf_checkpoint		, self._config		, self._pytorch_dump_output					)
			elif self._model_type == "gpt":
					from ..models.openai.convert_openai_original_tf_checkpoint_to_pytorch import (
					    convert_openai_checkpoint_to_pytorch,
					)

					convert_openai_checkpoint_to_pytorch(self._tf_checkpoint		, self._config		, self._pytorch_dump_output					)
			elif self._model_type == "transfo_xl":
					try:
							from ..models.transfo_xl.convert_transfo_xl_original_tf_checkpoint_to_pytorch import (
							    convert_transfo_xl_checkpoint_to_pytorch,
							)
					except ImportError:
							raise ImportError(lowerCamelCase_					)

					if "ckpt" in self._tf_checkpoint.lower():
							SCREAMING_SNAKE_CASE       :     Dict				= self._tf_checkpoint
							SCREAMING_SNAKE_CASE       :     Tuple				= ''''''
					else:
							SCREAMING_SNAKE_CASE       :     List[Any]				= self._tf_checkpoint
							SCREAMING_SNAKE_CASE       :     Optional[int]				= ''''''
					convert_transfo_xl_checkpoint_to_pytorch(
					    lowerCamelCase_		, self._config		, self._pytorch_dump_output		, lowerCamelCase_					)
			elif self._model_type == "gpt2":
					try:
							from ..models.gpta.convert_gpta_original_tf_checkpoint_to_pytorch import (
							    convert_gpta_checkpoint_to_pytorch,
							)
					except ImportError:
							raise ImportError(lowerCamelCase_					)

					convert_gpta_checkpoint_to_pytorch(self._tf_checkpoint		, self._config		, self._pytorch_dump_output					)
			elif self._model_type == "xlnet":
					try:
							from ..models.xlnet.convert_xlnet_original_tf_checkpoint_to_pytorch import (
							    convert_xlnet_checkpoint_to_pytorch,
							)
					except ImportError:
							raise ImportError(lowerCamelCase_					)

					convert_xlnet_checkpoint_to_pytorch(
					    self._tf_checkpoint		, self._config		, self._pytorch_dump_output		, self._finetuning_task_name					)
			elif self._model_type == "xlm":
					from ..models.xlm.convert_xlm_original_pytorch_checkpoint_to_pytorch import (
					    convert_xlm_checkpoint_to_pytorch,
					)

					convert_xlm_checkpoint_to_pytorch(self._tf_checkpoint		, self._pytorch_dump_output					)
			elif self._model_type == "lxmert":
					from ..models.lxmert.convert_lxmert_original_tf_checkpoint_to_pytorch import (
					    convert_lxmert_checkpoint_to_pytorch,
					)

					convert_lxmert_checkpoint_to_pytorch(self._tf_checkpoint		, self._pytorch_dump_output					)
			elif self._model_type == "rembert":
					from ..models.rembert.convert_rembert_tf_checkpoint_to_pytorch import (
					    convert_rembert_tf_checkpoint_to_pytorch,
					)

					convert_rembert_tf_checkpoint_to_pytorch(self._tf_checkpoint		, self._config		, self._pytorch_dump_output					)
			else:
					raise ValueError(
					    '''--model_type should be selected in the list [bert, gpt, gpt2, t5, transfo_xl, xlnet, xlm, lxmert]'''					)







"""simple docstring"""






from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


lowerCamelCase__ :       int						     =			logging.get_logger(__name__)




class 				lowercase__(				_UpperCAmelCase		,						_UpperCAmelCase   ):
	'''simple docstring'''

	UpperCamelCase				=  """maskformer-swin"""

	UpperCamelCase				=  {
	    """num_attention_heads""": """num_heads""",
	    """num_hidden_layers""": """num_layers""",
	}





	def __init__(						self    :Optional[int]		, lowerCamelCase_    :List[Any]=2_24		, lowerCamelCase_    :Tuple=4		, lowerCamelCase_    :Optional[Any]=3		, lowerCamelCase_    :List[str]=96		, lowerCamelCase_    :int=[2, 2, 6, 2]		, lowerCamelCase_    :Union[str, Any]=[3, 6, 12, 24]		, lowerCamelCase_    :Optional[int]=7		, lowerCamelCase_    :Tuple=4.0		, lowerCamelCase_    :Tuple=True		, lowerCamelCase_    :Dict=0.0		, lowerCamelCase_    :Any=0.0		, lowerCamelCase_    :List[Any]=0.1		, lowerCamelCase_    :Dict="gelu"		, lowerCamelCase_    :Optional[int]=False		, lowerCamelCase_    :List[str]=0.0_2		, lowerCamelCase_    :Any=1E-5		, lowerCamelCase_    :Union[str, Any]=None		, lowerCamelCase_    :List[str]=None		, **lowerCamelCase_    :Union[str, Any]		, )							->			Dict:







			'''simple docstring'''




			super().__init__(**lowerCamelCase_					)

			SCREAMING_SNAKE_CASE       :     int				= image_size
			SCREAMING_SNAKE_CASE       :     Optional[Any]				= patch_size
			SCREAMING_SNAKE_CASE       :     str				= num_channels
			SCREAMING_SNAKE_CASE       :     Union[str, Any]				= embed_dim
			SCREAMING_SNAKE_CASE       :     List[Any]				= depths
			SCREAMING_SNAKE_CASE       :     List[str]				= len(lowerCamelCase_					)
			SCREAMING_SNAKE_CASE       :     str				= num_heads
			SCREAMING_SNAKE_CASE       :     Any				= window_size
			SCREAMING_SNAKE_CASE       :     List[str]				= mlp_ratio
			SCREAMING_SNAKE_CASE       :     str				= qkv_bias
			SCREAMING_SNAKE_CASE       :     Tuple				= hidden_dropout_prob
			SCREAMING_SNAKE_CASE       :     int				= attention_probs_dropout_prob
			SCREAMING_SNAKE_CASE       :     int				= drop_path_rate
			SCREAMING_SNAKE_CASE       :     Tuple				= hidden_act
			SCREAMING_SNAKE_CASE       :     Any				= use_absolute_embeddings
			SCREAMING_SNAKE_CASE       :     List[str]				= layer_norm_eps
			SCREAMING_SNAKE_CASE       :     List[str]				= initializer_range
			# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
			# this indicates the channel dimension after the last stage of the model
			SCREAMING_SNAKE_CASE       :     int				= int(embed_dim * 2 ** (len(lowerCamelCase_					) - 1)					)
			SCREAMING_SNAKE_CASE       :     Dict				= ['''stem'''] + [f"stage{idx}" for idx in range(1		, len(lowerCamelCase_					) + 1					)]
			SCREAMING_SNAKE_CASE,					SCREAMING_SNAKE_CASE       :     int				= get_aligned_output_features_output_indices(
			    out_features=lowerCamelCase_		, out_indices=lowerCamelCase_		, stage_names=self.stage_names					)





