




import os
import unicodedata
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import SPIECE_UNDERLINE, logging


_A     =			logging.get_logger(__name__)

_A     =			{'''vocab_file''': '''spiece.model'''}

_A     =			{
    '''vocab_file''': {
        '''xlnet-base-cased''': '''https://huggingface.co/xlnet-base-cased/resolve/main/spiece.model''',
        '''xlnet-large-cased''': '''https://huggingface.co/xlnet-large-cased/resolve/main/spiece.model''',
    }
}

_A     =			{
    '''xlnet-base-cased''': None,
    '''xlnet-large-cased''': None,
}

# Segments (not really needed)
_A     =			0
_A     =			1
_A     =			2
_A     =			3
_A     =			4


class  A		(  __UpperCAmelCase     ):
		__snake_case									=   VOCAB_FILES_NAMES
		__snake_case									=   PRETRAINED_VOCAB_FILES_MAP
		__snake_case									=   PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
		__snake_case									=   'left'



		def __init__(     self,	UpperCamelCase__,	UpperCamelCase__=False,	UpperCamelCase__=True,	UpperCamelCase__=False,	UpperCamelCase__="<s>",	UpperCamelCase__="</s>",	UpperCamelCase__="<unk>",	UpperCamelCase__="<sep>",	UpperCamelCase__="<pad>",	UpperCamelCase__="<cls>",	UpperCamelCase__="<mask>",	UpperCamelCase__=["<eop>", "<eod>"],	UpperCamelCase__ = None,	**UpperCamelCase__,	):







								"""simple docstring"""



								lowerCAmelCase_      			=  AddedToken(UpperCamelCase__,	lstrip=UpperCamelCase__,	rstrip=UpperCamelCase__   ) if isinstance(UpperCamelCase__,	UpperCamelCase__   ) else mask_token

								lowerCAmelCase_      			=  {} if sp_model_kwargs is None else sp_model_kwargs

								super().__init__(
								    do_lower_case=UpperCamelCase__,	remove_space=UpperCamelCase__,	keep_accents=UpperCamelCase__,	bos_token=UpperCamelCase__,	eos_token=UpperCamelCase__,	unk_token=UpperCamelCase__,	sep_token=UpperCamelCase__,	pad_token=UpperCamelCase__,	cls_token=UpperCamelCase__,	mask_token=UpperCamelCase__,	additional_special_tokens=UpperCamelCase__,	sp_model_kwargs=self.sp_model_kwargs,	**UpperCamelCase__,	)

								lowerCAmelCase_      			=  3

								lowerCAmelCase_      			=  do_lower_case
								lowerCAmelCase_      			=  remove_space
								lowerCAmelCase_      			=  keep_accents
								lowerCAmelCase_      			=  vocab_file

								lowerCAmelCase_      			=  spm.SentencePieceProcessor(**self.sp_model_kwargs   )
								self.sp_model.Load(UpperCamelCase__   )



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return len(self.sp_model   )



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  {self.convert_ids_to_tokens(UpperCamelCase__   ): i for i in range(self.vocab_size   )}
								vocab.update(self.added_tokens_encoder   )
								return vocab



		def __getstate__(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  self.__dict__.copy()
								lowerCAmelCase_      			=  None
								return state



		def __setstate__(     self,	UpperCamelCase__   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  d

								# for backward compatibility
								if not hasattr(self,	'''sp_model_kwargs'''   ):
														lowerCAmelCase_      			=  {}

								lowerCAmelCase_      			=  spm.SentencePieceProcessor(**self.sp_model_kwargs   )
								self.sp_model.Load(self.vocab_file   )



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__   ):







								"""simple docstring"""



								if self.remove_space:
														lowerCAmelCase_      			=  ''' '''.join(inputs.strip().split()   )
								else:
														lowerCAmelCase_      			=  inputs
								lowerCAmelCase_      			=  outputs.replace('''``''',	'''"'''   ).replace('''\'\'''',	'''"'''   )

								if not self.keep_accents:
														lowerCAmelCase_      			=  unicodedata.normalize('''NFKD''',	UpperCamelCase__   )
														lowerCAmelCase_      			=  ''''''.join([c for c in outputs if not unicodedata.combining(UpperCamelCase__   )]   )
								if self.do_lower_case:
														lowerCAmelCase_      			=  outputs.lower()

								return outputs



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  self.preprocess_text(UpperCamelCase__   )
								lowerCAmelCase_      			=  self.sp_model.encode(UpperCamelCase__,	out_type=UpperCamelCase__   )
								lowerCAmelCase_      			=  []
								for piece in pieces:
														if len(UpperCamelCase__   ) > 1 and piece[-1] == str(''','''   ) and piece[-2].isdigit():
																				lowerCAmelCase_      			=  self.sp_model.EncodeAsPieces(piece[:-1].replace(UpperCamelCase__,	''''''   )   )
																				if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
																										if len(cur_pieces[0]   ) == 1:
																																lowerCAmelCase_      			=  cur_pieces[1:]
																										else:
																																lowerCAmelCase_      			=  cur_pieces[0][1:]
																				cur_pieces.append(piece[-1]   )
																				new_pieces.extend(UpperCamelCase__   )
														else:
																				new_pieces.append(UpperCamelCase__   )

								return new_pieces



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__   ):







								"""simple docstring"""



								return self.sp_model.PieceToId(UpperCamelCase__   )



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__   ):







								"""simple docstring"""



								return self.sp_model.IdToPiece(UpperCamelCase__   )



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  ''''''.join(UpperCamelCase__   ).replace(UpperCamelCase__,	''' '''   ).strip()
								return out_string



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__,	UpperCamelCase__ = False,	UpperCamelCase__ = None,	UpperCamelCase__ = True,	**UpperCamelCase__,	):







								"""simple docstring"""



								lowerCAmelCase_      			=  kwargs.pop('''use_source_tokenizer''',	UpperCamelCase__   )

								lowerCAmelCase_      			=  self.convert_ids_to_tokens(UpperCamelCase__,	skip_special_tokens=UpperCamelCase__   )

								# To avoid mixing byte-level and unicode for byte-level BPT
								# we need to build string separately for added tokens and byte-level tokens
								# cf. https://github.com/huggingface/transformers/issues/1133
								lowerCAmelCase_      			=  []
								lowerCAmelCase_      			=  []
								for token in filtered_tokens:
														if skip_special_tokens and token in self.all_special_ids:
																				continue
														if token in self.added_tokens_encoder:
																				if current_sub_text:
																										sub_texts.append(self.convert_tokens_to_string(UpperCamelCase__   )   )
																										lowerCAmelCase_      			=  []
																				sub_texts.append(UpperCamelCase__   )
														else:
																				current_sub_text.append(UpperCamelCase__   )
								if current_sub_text:
														sub_texts.append(self.convert_tokens_to_string(UpperCamelCase__   )   )

								# Mimic the behavior of the Rust tokenizer:
								# By default, there are no spaces between special tokens
								lowerCAmelCase_      			=  ''''''.join(UpperCamelCase__   )

								lowerCAmelCase_      			=  (
								    clean_up_tokenization_spaces
								    if clean_up_tokenization_spaces is not None
								    else self.clean_up_tokenization_spaces
								)
								if clean_up_tokenization_spaces:
														lowerCAmelCase_      			=  self.clean_up_tokenization(UpperCamelCase__   )
														return clean_text
								else:
														return text



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__,	UpperCamelCase__ = None   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  [self.sep_token_id]
								lowerCAmelCase_      			=  [self.cls_token_id]
								if token_ids_a is None:
														return token_ids_a + sep + cls
								return token_ids_a + sep + token_ids_a + sep + cls



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__,	UpperCamelCase__ = None,	UpperCamelCase__ = False   ):







								"""simple docstring"""



								if already_has_special_tokens:
														return super().get_special_tokens_mask(
														    token_ids_a=UpperCamelCase__,	token_ids_a=UpperCamelCase__,	already_has_special_tokens=UpperCamelCase__   )

								if token_ids_a is not None:
														return ([0] * len(UpperCamelCase__   )) + [1] + ([0] * len(UpperCamelCase__   )) + [1, 1]
								return ([0] * len(UpperCamelCase__   )) + [1, 1]



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__,	UpperCamelCase__ = None   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  [self.sep_token_id]
								lowerCAmelCase_      			=  [2]

								if token_ids_a is None:
														return len(token_ids_a + sep   ) * [0] + cls_segment_id
								return len(token_ids_a + sep   ) * [0] + len(token_ids_a + sep   ) * [1] + cls_segment_id







		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__,	UpperCamelCase__ = None   ):







								"""simple docstring"""



								if not os.path.isdir(UpperCamelCase__   ):
														logger.error(f"Vocabulary path ({save_directory}) should be a directory"   )
														return
								lowerCAmelCase_      			=  os.path.join(
								    UpperCamelCase__,	(filename_prefix + '''-''' if filename_prefix else '''''') + VOCAB_FILES_NAMES['''vocab_file''']   )

								if os.path.abspath(self.vocab_file   ) != os.path.abspath(UpperCamelCase__   ) and os.path.isfile(self.vocab_file   ):
														copyfile(self.vocab_file,	UpperCamelCase__   )
								elif not os.path.isfile(self.vocab_file   ):
														with open(UpperCamelCase__,	'''wb'''   ) as fi:
																				lowerCAmelCase_      			=  self.sp_model.serialized_model_proto()
																				fi.write(UpperCamelCase__   )

								return (out_vocab_file,)










import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    SwiftFormerConfig,
    SwiftFormerForImageClassification,
    ViTImageProcessor,
)
from transformers.utils import logging


logging.set_verbosity_info()
_A     =			logging.get_logger(__name__)

_A     =			torch.device('''cpu''')





def __UpperCamelCase			(       ):
						lowerCAmelCase_      			=  '''http://images.cocodataset.org/val2017/000000039769.jpg'''
						lowerCAmelCase_      			=  Image.open(requests.get(_A ,  stream=_A  ).raw  )
						return im





def __UpperCamelCase			(       _A  ):
						if swiftformer_name == "swiftformer_xs":
												return torch.tensor([-2.1_7_0_3E0_0, 2.1_1_0_7E0_0, -2.0_8_1_1E0_0, 8.8_6_8_5E-0_1, 2.4_3_6_0E-0_1]  )

						elif swiftformer_name == "swiftformer_s":
												return torch.tensor([3.9_6_3_6E-0_1, 2.3_4_7_8E-0_1, -1.6_9_6_3E0_0, -1.7_3_8_1E0_0, -8.6_3_3_7E-0_1]  )

						elif swiftformer_name == "swiftformer_l1":
												return torch.tensor([-4.2_7_6_8E-0_1, -4.7_4_2_9E-0_1, -1.0_8_9_7E0_0, -1.0_2_4_8E0_0, 3.5_5_2_3E-0_2]  )

						elif swiftformer_name == "swiftformer_l3":
												return torch.tensor([-2.5_3_3_0E-0_1, 2.4_2_1_1E-0_1, -6.0_1_8_5E-0_1, -8.2_7_8_9E-0_1, -6.0_4_4_6E-0_2]  )





def __UpperCamelCase			(       _A ,  _A ,  _A  ):
						lowerCAmelCase_      			=  dct.pop(_A  )
						lowerCAmelCase_      			=  val





def __UpperCamelCase			(       _A  ):
						lowerCAmelCase_      			=  []
						for k in state_dict.keys():
												lowerCAmelCase_      			=  k
												if ".pwconv" in k:
																		lowerCAmelCase_      			=  k_new.replace('''.pwconv''' ,  '''.point_wise_conv'''  )
												if ".dwconv" in k:
																		lowerCAmelCase_      			=  k_new.replace('''.dwconv''' ,  '''.depth_wise_conv'''  )
												if ".Proj." in k:
																		lowerCAmelCase_      			=  k_new.replace('''.Proj.''' ,  '''.proj.'''  )
												if "patch_embed" in k_new:
																		lowerCAmelCase_      			=  k_new.replace('''patch_embed''' ,  '''swiftformer.patch_embed.patch_embedding'''  )
												if "network" in k_new:
																		lowerCAmelCase_      			=  k_new.split('''.'''  )
																		if ls[2].isdigit():
																								lowerCAmelCase_      			=  '''swiftformer.encoder.network.''' + ls[1] + '''.blocks.''' + ls[2] + '''.''' + '''.'''.join(ls[3:]  )
																		else:
																								lowerCAmelCase_      			=  k_new.replace('''network''' ,  '''swiftformer.encoder.network'''  )
												rename_keys.append((k, k_new)  )
						return rename_keys





@torch.no_grad()
def __UpperCamelCase			(       _A ,  _A ,  _A  ):
						lowerCAmelCase_      			=  SwiftFormerConfig()

						# dataset (ImageNet-21k only or also fine-tuned on ImageNet 2012), patch_size and image_size
						lowerCAmelCase_      			=  1000
						lowerCAmelCase_      			=  '''huggingface/label-files'''
						lowerCAmelCase_      			=  '''imagenet-1k-id2label.json'''
						lowerCAmelCase_      			=  json.load(open(hf_hub_download(_A ,  _A ,  repo_type='''dataset'''  ) ,  '''r'''  )  )
						lowerCAmelCase_      			=  {int(_A  ): v for k, v in idalabel.items()}
						lowerCAmelCase_      			=  idalabel
						lowerCAmelCase_      			=  {v: k for k, v in idalabel.items()}

						# size of the architecture
						if swiftformer_name == "swiftformer_xs":
												lowerCAmelCase_      			=  [3, 3, 6, 4]
												lowerCAmelCase_      			=  [48, 56, 112, 220]

						elif swiftformer_name == "swiftformer_s":
												lowerCAmelCase_      			=  [3, 3, 9, 6]
												lowerCAmelCase_      			=  [48, 64, 168, 224]

						elif swiftformer_name == "swiftformer_l1":
												lowerCAmelCase_      			=  [4, 3, 10, 5]
												lowerCAmelCase_      			=  [48, 96, 192, 384]

						elif swiftformer_name == "swiftformer_l3":
												lowerCAmelCase_      			=  [4, 4, 12, 6]
												lowerCAmelCase_      			=  [64, 128, 320, 512]

						# load state_dict of original model, remove and rename some keys
						if original_ckpt:
												if original_ckpt.startswith('''https'''  ):
																		lowerCAmelCase_      			=  torch.hub.load_state_dict_from_url(_A ,  map_location='''cpu''' ,  check_hash=_A  )
												else:
																		lowerCAmelCase_      			=  torch.load(_A ,  map_location='''cpu'''  )
						lowerCAmelCase_      			=  checkpoint

						lowerCAmelCase_      			=  create_rename_keys(_A  )
						for rename_key_src, rename_key_dest in rename_keys:
												rename_key(_A ,  _A ,  _A  )

						# load HuggingFace model
						lowerCAmelCase_      			=  SwiftFormerForImageClassification(_A  ).eval()
						hf_model.load_state_dict(_A  )

						# prepare test inputs
						lowerCAmelCase_      			=  prepare_img()
						lowerCAmelCase_      			=  ViTImageProcessor.from_pretrained('''preprocessor_config'''  )
						lowerCAmelCase_      			=  processor(images=_A ,  return_tensors='''pt'''  )

						# compare outputs from both models
						lowerCAmelCase_      			=  get_expected_output(_A  )
						lowerCAmelCase_      			=  hf_model(inputs['''pixel_values''']  ).logits

						assert hf_logits.shape == torch.Size([1, 1000]  )
						assert torch.allclose(hf_logits[0, 0:5] ,  _A ,  atol=1E-3  )

						Path(_A  ).mkdir(exist_ok=_A  )
						print(f"Saving model {swiftformer_name} to {pytorch_dump_folder_path}"  )
						hf_model.save_pretrained(_A  )


if __name__ == "__main__":
						_A     =			argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '''--swiftformer_name''',
						    default='''swiftformer_xs''',
						    choices=['''swiftformer_xs''', '''swiftformer_s''', '''swiftformer_l1''', '''swiftformer_l3'''],
						    type=str,
						    help='''Name of the SwiftFormer model you\'d like to convert.''',
						)
						parser.add_argument(
						    '''--pytorch_dump_folder_path''',
						    default='''./converted_outputs/''',
						    type=str,
						    help='''Path to the output PyTorch model directory.''',
						)
						parser.add_argument('''--original_ckpt''', default=None, type=str, help='''Path to the original model checkpoint.''')

						_A     =			parser.parse_args()
						convert_swiftformer_checkpoint(args.swiftformer_name, args.pytorch_dump_folder_path, args.original_ckpt)




