



"""simple docstring"""





from argparse import ArgumentParser, Namespace

from ..utils import logging
from . import BaseTransformersCLICommand
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Namespace    ):


						'''simple docstring'''






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


__lowerCAmelCase       :					Union[str, Any]      					=					'''
transformers can only be used from the commandline to convert TensorFlow models in PyTorch, In that case, it requires
TensorFlow to be installed. Please see https://www.tensorflow.org/install/ for installation instructions.
'''






class    _lowerCAmelCase    (				SCREAMING_SNAKE_CASE__		):





		"""simple docstring"""






		@staticmethod
		def    UpperCAmelCase__							(					_lowercase   ) ->						List[str]:







								'''simple docstring'''

								snake_case_   : Optional[int]						=			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=_lowercase							,    required=_lowercase							,    help="""Model's type."""   )
								train_parser.add_argument(
								    """--tf_checkpoint"""							,    type=_lowercase							,    required=_lowercase							,    help="""TensorFlow checkpoint path or folder."""   )
								train_parser.add_argument(
								    """--pytorch_dump_output"""							,    type=_lowercase							,    required=_lowercase							,    help="""Path to the PyTorch saved model output."""   )
								train_parser.add_argument("""--config"""							,    type=_lowercase							,    default=""""""							,    help="""Configuration file path or folder."""   )
								train_parser.add_argument(
								    """--finetuning_task_name"""							,    type=_lowercase							,    default=_lowercase							,    help="""Optional fine-tuning task name if the TF model was a finetuned model."""							,    )
								train_parser.set_defaults(func=_lowercase   )





		def __init__(					self							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    _lowercase							,    *_lowercase							,    ) ->						Tuple:







								'''simple docstring'''

								snake_case_   : Tuple						=			logging.get_logger("""transformers-cli/converting"""   )

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





		def    UpperCAmelCase__							(					self   ) ->						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(_lowercase   )

														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(_lowercase   )

														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(_lowercase   )

														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(_lowercase   )

														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(_lowercase   )

														if "ckpt" in self._tf_checkpoint.lower():
																				snake_case_   : Optional[int]						=			self._tf_checkpoint
																				snake_case_   : str						=			""""""
														else:
																				snake_case_   : List[Any]						=			self._tf_checkpoint
																				snake_case_   : str						=			""""""
														convert_transfo_xl_checkpoint_to_pytorch(
														    _lowercase							,    self._config							,    self._pytorch_dump_output							,    _lowercase   )
								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(_lowercase   )

														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(_lowercase   )

														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"""





import argparse
import json
from collections import OrderedDict

import torch
from huggingface_hub import cached_download, hf_hub_url

from transformers import AutoImageProcessor, CvtConfig, CvtForImageClassification
def 	__lowerCAmelCase						(		__UpperCamelCase      :			List[Any]    ):


						'''simple docstring'''






						snake_case_   : List[str]						=			[]
						embed.append(
						    (
						        F'cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.weight',
						        F'stage{idx}.patch_embed.proj.weight',
						    )    )
						embed.append(
						    (
						        F'cvt.encoder.stages.{idx}.embedding.convolution_embeddings.projection.bias',
						        F'stage{idx}.patch_embed.proj.bias',
						    )    )
						embed.append(
						    (
						        F'cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.weight',
						        F'stage{idx}.patch_embed.norm.weight',
						    )    )
						embed.append(
						    (
						        F'cvt.encoder.stages.{idx}.embedding.convolution_embeddings.normalization.bias',
						        F'stage{idx}.patch_embed.norm.bias',
						    )    )
						return embed
def 	__lowerCAmelCase						(		__UpperCamelCase      :			str					, __UpperCamelCase      :			int    ):


						'''simple docstring'''






						snake_case_   : str						=			[]
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.convolution.weight',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_q.conv.weight',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.weight',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.weight',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.bias',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.bias',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_mean',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_mean',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.running_var',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.running_var',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_query.convolution_projection.normalization.num_batches_tracked',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_q.bn.num_batches_tracked',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.convolution.weight',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_k.conv.weight',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.weight',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.weight',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.bias',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.bias',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_mean',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_mean',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.running_var',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.running_var',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_key.convolution_projection.normalization.num_batches_tracked',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_k.bn.num_batches_tracked',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.convolution.weight',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_v.conv.weight',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.weight',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.weight',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.bias',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.bias',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_mean',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_mean',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.running_var',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.running_var',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.convolution_projection_value.convolution_projection.normalization.num_batches_tracked',
						        F'stage{idx}.blocks.{cnt}.attn.conv_proj_v.bn.num_batches_tracked',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.weight',
						        F'stage{idx}.blocks.{cnt}.attn.proj_q.weight',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_query.bias',
						        F'stage{idx}.blocks.{cnt}.attn.proj_q.bias',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.weight',
						        F'stage{idx}.blocks.{cnt}.attn.proj_k.weight',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_key.bias',
						        F'stage{idx}.blocks.{cnt}.attn.proj_k.bias',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.weight',
						        F'stage{idx}.blocks.{cnt}.attn.proj_v.weight',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.attention.projection_value.bias',
						        F'stage{idx}.blocks.{cnt}.attn.proj_v.bias',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.weight',
						        F'stage{idx}.blocks.{cnt}.attn.proj.weight',
						    )    )
						attention_weights.append(
						    (
						        F'cvt.encoder.stages.{idx}.layers.{cnt}.attention.output.dense.bias',
						        F'stage{idx}.blocks.{cnt}.attn.proj.bias',
						    )    )
						attention_weights.append(
						    (F'cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.weight', F'stage{idx}.blocks.{cnt}.mlp.fc1.weight')    )
						attention_weights.append(
						    (F'cvt.encoder.stages.{idx}.layers.{cnt}.intermediate.dense.bias', F'stage{idx}.blocks.{cnt}.mlp.fc1.bias')    )
						attention_weights.append(
						    (F'cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.weight', F'stage{idx}.blocks.{cnt}.mlp.fc2.weight')    )
						attention_weights.append(
						    (F'cvt.encoder.stages.{idx}.layers.{cnt}.output.dense.bias', F'stage{idx}.blocks.{cnt}.mlp.fc2.bias')    )
						attention_weights.append(
						    (F'cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.weight', F'stage{idx}.blocks.{cnt}.norm1.weight')    )
						attention_weights.append(
						    (F'cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_before.bias', F'stage{idx}.blocks.{cnt}.norm1.bias')    )
						attention_weights.append(
						    (F'cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.weight', F'stage{idx}.blocks.{cnt}.norm2.weight')    )
						attention_weights.append(
						    (F'cvt.encoder.stages.{idx}.layers.{cnt}.layernorm_after.bias', F'stage{idx}.blocks.{cnt}.norm2.bias')    )
						return attention_weights
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Tuple    ):


						'''simple docstring'''






						snake_case_   : int						=			[]
						token.append((F'cvt.encoder.stages.{idx}.cls_token', """stage2.cls_token""")    )
						return token
def 	__lowerCAmelCase						(		):


						'''simple docstring'''






						snake_case_   : Union[str, Any]						=			[]
						head.append(("""layernorm.weight""", """norm.weight""")    )
						head.append(("""layernorm.bias""", """norm.bias""")    )
						head.append(("""classifier.weight""", """head.weight""")    )
						head.append(("""classifier.bias""", """head.bias""")    )
						return head
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Union[str, Any]					, __UpperCamelCase      :			Union[str, Any]					, __UpperCamelCase      :			Optional[Any]					, __UpperCamelCase      :			List[Any]    ):


						'''simple docstring'''






						snake_case_   : Union[str, Any]						=			"""imagenet-1k-id2label.json"""
						snake_case_   : Optional[Any]						=			1_0_0_0

						snake_case_   : Any						=			"""huggingface/label-files"""
						snake_case_   : Tuple						=			num_labels
						snake_case_   : Dict						=			json.load(open(cached_download(hf_hub_url(__UpperCamelCase					, __UpperCamelCase					, repo_type="""dataset"""    )    )					, """r"""    )    )
						snake_case_   : str						=			{int(__UpperCamelCase    ): v for k, v in idalabel.items()}

						snake_case_   : List[str]						=			idalabel
						snake_case_   : Any						=			{v: k for k, v in idalabel.items()}

						snake_case_   : Dict						=			CvtConfig(num_labels=__UpperCamelCase					, idalabel=__UpperCamelCase					, labelaid=__UpperCamelCase    )

						# For depth size 13 (13 = 1+2+10)
						if cvt_model.rsplit("""/"""					, 1    )[-1][4:6] == "13":
												snake_case_   : Any						=			[1, 2, 1_0]

						# For depth size 21 (21 = 1+4+16)
						elif cvt_model.rsplit("""/"""					, 1    )[-1][4:6] == "21":
												snake_case_   : Any						=			[1, 4, 1_6]

						# For wide cvt (similar to wide-resnet) depth size 24 (w24 = 2 + 2 20)
						else:
												snake_case_   : Optional[int]						=			[2, 2, 2_0]
												snake_case_   : str						=			[3, 1_2, 1_6]
												snake_case_   : Any						=			[1_9_2, 7_6_8, 1_0_2_4]

						snake_case_   : Union[str, Any]						=			CvtForImageClassification(__UpperCamelCase    )
						snake_case_   : str						=			AutoImageProcessor.from_pretrained("""facebook/convnext-base-224-22k-1k"""    )
						snake_case_   : List[Any]						=			image_size
						snake_case_   : str						=			torch.load(__UpperCamelCase					, map_location=torch.device("""cpu"""    )    )

						snake_case_   : Any						=			OrderedDict()
						snake_case_   : Tuple						=			[]

						for idx in range(len(config.depth    )    ):
												if config.cls_token[idx]:
																		snake_case_   : Optional[Any]						=			list_of_state_dict + cls_token(__UpperCamelCase    )
												snake_case_   : str						=			list_of_state_dict + embeddings(__UpperCamelCase    )
												for cnt in range(config.depth[idx]    ):
																		snake_case_   : List[str]						=			list_of_state_dict + attention(__UpperCamelCase					, __UpperCamelCase    )

						snake_case_   : str						=			list_of_state_dict + final()
						for gg in list_of_state_dict:
												print(__UpperCamelCase    )
						for i in range(len(__UpperCamelCase    )    ):
												snake_case_   : Union[str, Any]						=			original_weights[list_of_state_dict[i][1]]

						model.load_state_dict(__UpperCamelCase    )
						model.save_pretrained(__UpperCamelCase    )
						image_processor.save_pretrained(__UpperCamelCase    )


# Download the weights from zoo: https://1drv.ms/u/s!AhIXJn_J-blW9RzF3rMW7SsLHa8h?e=blQ0Al

if __name__ == "__main__":
					__lowerCAmelCase       :					Optional[int]      					=					argparse.ArgumentParser()
					parser.add_argument(
					    '''--cvt_model''',
					    default='''cvt-w24''',
					    type=str,
					    help='''Name of the cvt model you\'d like to convert.''',
					)
					parser.add_argument(
					    '''--image_size''',
					    default=384,
					    type=int,
					    help='''Input Image Size''',
					)
					parser.add_argument(
					    '''--cvt_file_name''',
					    default=R'''cvtmodels\CvT-w24-384x384-IN-22k.pth''',
					    type=str,
					    help='''Input Image Size''',
					)
					parser.add_argument(
					    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
					)

					__lowerCAmelCase       :					Dict      					=					parser.parse_args()
					convert_cvt_checkpoint(args.cvt_model, args.image_size, args.cvt_file_name, args.pytorch_dump_folder_path)

