


import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
	    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
	    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
	    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
	    LayoutLMvaConfig,
	    LayoutLMvaForQuestionAnswering,
	    LayoutLMvaForSequenceClassification,
	    LayoutLMvaForTokenClassification,
	    LayoutLMvaModel,
	)
	from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
	from PIL import Image

	from transformers import LayoutLMvaImageProcessor




class       lowercase_					:





				def __init__(				self       ,  lowercase_       ,  lowercase_=2       ,  lowercase_=3       ,  lowercase_=4       ,  lowercase_=2       ,  lowercase_=7       ,  lowercase_=True       ,  lowercase_=True       ,  lowercase_=True       ,  lowercase_=True       ,  lowercase_=99       ,  lowercase_=36       ,  lowercase_=3       ,  lowercase_=4       ,  lowercase_=37       ,  lowercase_="gelu"       ,  lowercase_=0.1       ,  lowercase_=0.1       ,  lowercase_=512       ,  lowercase_=16       ,  lowercase_=2       ,  lowercase_=0.02       ,  lowercase_=6       ,  lowercase_=6       ,  lowercase_=3       ,  lowercase_=4       ,  lowercase_=None       ,  lowercase_=1000       ,  )  -> str:
											a__      =parent
											a__      =batch_size
											a__      =num_channels
											a__      =image_size
											a__      =patch_size
											a__      =text_seq_length
											a__      =is_training
											a__      =use_input_mask
											a__      =use_token_type_ids
											a__      =use_labels
											a__      =vocab_size
											a__      =hidden_size
											a__      =num_hidden_layers
											a__      =num_attention_heads
											a__      =intermediate_size
											a__      =hidden_act
											a__      =hidden_dropout_prob
											a__      =attention_probs_dropout_prob
											a__      =max_position_embeddings
											a__      =type_vocab_size
											a__      =type_sequence_label_size
											a__      =initializer_range
											a__      =coordinate_size
											a__      =shape_size
											a__      =num_labels
											a__      =num_choices
											a__      =scope
											a__      =range_bbox

											# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
											a__      =text_seq_length
											a__      =(image_size // patch_size) ** 2 + 1
											a__      =self.text_seq_length + self.image_seq_length





				def 						__UpperCamelCase    (				self)  -> Optional[Any]:
											a__      =ids_tensor([self.batch_size, self.text_seq_length]       ,  self.vocab_size)

											a__      =ids_tensor([self.batch_size, self.text_seq_length, 4]       ,  self.range_bbox)
											# Ensure that bbox is legal
											for i in range(bbox.shape[0]):
																		for j in range(bbox.shape[1]):
																									if bbox[i, j, 3] < bbox[i, j, 1]:
																																a__      =bbox[i, j, 3]
																																a__      =bbox[i, j, 1]
																																a__      =t
																									if bbox[i, j, 2] < bbox[i, j, 0]:
																																a__      =bbox[i, j, 2]
																																a__      =bbox[i, j, 0]
																																a__      =t

											a__      =floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

											a__      =None
											if self.use_input_mask:
																		a__      =random_attention_mask([self.batch_size, self.text_seq_length])

											a__      =None
											if self.use_token_type_ids:
																		a__      =ids_tensor([self.batch_size, self.text_seq_length]       ,  self.type_vocab_size)

											a__      =None
											a__      =None
											if self.use_labels:
																		a__      =ids_tensor([self.batch_size]       ,  self.type_sequence_label_size)
																		a__      =ids_tensor([self.batch_size, self.text_seq_length]       ,  self.num_labels)

											a__      =LayoutLMvaConfig(
											    vocab_size=self.vocab_size       ,  hidden_size=self.hidden_size       ,  num_hidden_layers=self.num_hidden_layers       ,  num_attention_heads=self.num_attention_heads       ,  intermediate_size=self.intermediate_size       ,  hidden_act=self.hidden_act       ,  hidden_dropout_prob=self.hidden_dropout_prob       ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,  max_position_embeddings=self.max_position_embeddings       ,  type_vocab_size=self.type_vocab_size       ,  initializer_range=self.initializer_range       ,  coordinate_size=self.coordinate_size       ,  shape_size=self.shape_size       ,  input_size=self.image_size       ,  patch_size=self.patch_size       ,  )

											return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_)  -> str:
											a__      =LayoutLMvaModel(config=lowercase_)
											model.to(lowercase_)
											model.eval()

											# text + image
											a__      =model(lowercase_       ,  pixel_values=lowercase_)
											a__      =model(
											    lowercase_       ,  bbox=lowercase_       ,  pixel_values=lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_)
											a__      =model(lowercase_       ,  bbox=lowercase_       ,  pixel_values=lowercase_       ,  token_type_ids=lowercase_)
											a__      =model(lowercase_       ,  bbox=lowercase_       ,  pixel_values=lowercase_)

											self.parent.assertEqual(result.last_hidden_state.shape       ,  (self.batch_size, self.seq_length, self.hidden_size))

											# text only
											a__      =model(lowercase_)
											self.parent.assertEqual(
											    result.last_hidden_state.shape       ,  (self.batch_size, self.text_seq_length, self.hidden_size))

											# image only
											a__      =model(pixel_values=lowercase_)
											self.parent.assertEqual(
											    result.last_hidden_state.shape       ,  (self.batch_size, self.image_seq_length, self.hidden_size))





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_)  -> List[str]:
											a__      =self.num_labels
											a__      =LayoutLMvaForSequenceClassification(lowercase_)
											model.to(lowercase_)
											model.eval()
											a__      =model(
											    lowercase_       ,  bbox=lowercase_       ,  pixel_values=lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_       ,  )
											self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_labels))





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_)  -> str:
											a__      =self.num_labels
											a__      =LayoutLMvaForTokenClassification(config=lowercase_)
											model.to(lowercase_)
											model.eval()
											a__      =model(
											    lowercase_       ,  bbox=lowercase_       ,  pixel_values=lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  labels=lowercase_       ,  )
											self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.text_seq_length, self.num_labels))





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_)  -> str:
											a__      =LayoutLMvaForQuestionAnswering(config=lowercase_)
											model.to(lowercase_)
											model.eval()
											a__      =model(
											    lowercase_       ,  bbox=lowercase_       ,  pixel_values=lowercase_       ,  attention_mask=lowercase_       ,  token_type_ids=lowercase_       ,  start_positions=lowercase_       ,  end_positions=lowercase_       ,  )
											self.parent.assertEqual(result.start_logits.shape       ,  (self.batch_size, self.seq_length))
											self.parent.assertEqual(result.end_logits.shape       ,  (self.batch_size, self.seq_length))





				def 						__UpperCamelCase    (				self)  -> Tuple:
											a__      =self.prepare_config_and_inputs()
											(
											    (
											    a__
											)    ,     (
											    a__
											)    ,     (
											    a__
											)    ,     (
											    a__
											)    ,     (
											    a__
											)    ,     (
											    a__
											)    ,     (
											    a__
											)    ,     (
											    a__
											)    ,     
											)      =config_and_inputs
											a__      ={
											    'input_ids': input_ids,
											    'bbox': bbox,
											    'pixel_values': pixel_values,
											    'token_type_ids': token_type_ids,
											    'attention_mask': input_mask,
											}
											return config, inputs_dict







@require_torch
class       lowercase_					(lowercase__      ,					lowercase__      ,					unittest.TestCase   ):
				snake_case	    =False
				snake_case	    =False
				snake_case	    =False

				snake_case	    =(
				    (
				        LayoutLMvaModel,
				        LayoutLMvaForSequenceClassification,
				        LayoutLMvaForTokenClassification,
				        LayoutLMvaForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				snake_case	    =(
				    {'document-question-answering': LayoutLMvaForQuestionAnswering, 'feature-extraction': LayoutLMvaModel}
				    if is_torch_available()
				    else {}
				)





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_       ,  lowercase_)  -> Dict:
											# `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
											# embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
											# the sequence dimension of the text embedding only.
											# (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
											return True





				def 						__UpperCamelCase    (				self)  -> int:
											a__      =LayoutLMvaModelTester(self)
											a__      =ConfigTester(self       ,  config_class=lowercase_       ,  hidden_size=37)





				def 						__UpperCamelCase    (				self       ,  lowercase_       ,  lowercase_       ,  lowercase_=False)  -> Tuple:
											a__      =copy.deepcopy(lowercase_)
											if model_class in get_values(lowercase_):
																		a__      ={
																		    k: v.unsqueeze(1).expand(-1       ,  self.model_tester.num_choices       ,  -1).contiguous()
																		    if isinstance(lowercase_       ,  torch.Tensor) and v.ndim > 1
																		    else v
																		    for k, v in inputs_dict.items()
																		}
											if return_labels:
																		if model_class in get_values(lowercase_):
																									a__      =torch.ones(self.model_tester.batch_size       ,  dtype=torch.long       ,  device=lowercase_)
																		elif model_class in get_values(lowercase_):
																									a__      =torch.zeros(
																									    self.model_tester.batch_size       ,  dtype=torch.long       ,  device=lowercase_)
																									a__      =torch.zeros(
																									    self.model_tester.batch_size       ,  dtype=torch.long       ,  device=lowercase_)
																		elif model_class in [
																		    *get_values(lowercase_),
																		]:
																									a__      =torch.zeros(
																									    self.model_tester.batch_size       ,  dtype=torch.long       ,  device=lowercase_)
																		elif model_class in [
																		    *get_values(lowercase_),
																		]:
																									a__      =torch.zeros(
																									    (self.model_tester.batch_size, self.model_tester.text_seq_length)       ,  dtype=torch.long       ,  device=lowercase_       ,  )

											return inputs_dict





				def 						__UpperCamelCase    (				self)  -> str:
											self.config_tester.run_common_tests()





				def 						__UpperCamelCase    (				self)  -> List[str]:
											a__      =self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*lowercase_)





				def 						__UpperCamelCase    (				self)  -> Optional[Any]:
											a__      =self.model_tester.prepare_config_and_inputs()
											for type in ["absolute", "relative_key", "relative_key_query"]:
																		a__      =type
																		self.model_tester.create_and_check_model(*lowercase_)





				def 						__UpperCamelCase    (				self)  -> List[Any]:
											a__      =self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_sequence_classification(*lowercase_)





				def 						__UpperCamelCase    (				self)  -> List[str]:
											a__      =self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_token_classification(*lowercase_)





				def 						__UpperCamelCase    (				self)  -> List[str]:
											a__      =self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_question_answering(*lowercase_)





				@slow
				def 						__UpperCamelCase    (				self)  -> Optional[Any]:
											for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		a__      =LayoutLMvaModel.from_pretrained(lowercase_)
																		self.assertIsNotNone(lowercase_)







def   _lowercase(					):
							a__      =Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'     )
							return image







@require_torch
class       lowercase_					(unittest.TestCase   ):





				@cached_property
				def 						__UpperCamelCase    (				self)  -> List[str]:
											return LayoutLMvaImageProcessor(apply_ocr=lowercase_) if is_vision_available() else None





				@slow
				def 						__UpperCamelCase    (				self)  -> Optional[Any]:
											a__      =LayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base').to(lowercase_)

											a__      =self.default_image_processor
											a__      =prepare_img()
											a__      =image_processor(images=lowercase_       ,  return_tensors='pt').pixel_values.to(lowercase_)

											a__      =torch.tensor([[1, 2]])
											a__      =torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]).unsqueeze(0)

											# forward pass
											a__      =model(
											    input_ids=input_ids.to(lowercase_)       ,  bbox=bbox.to(lowercase_)       ,  pixel_values=pixel_values.to(lowercase_)       ,  )

											# verify the logits
											a__      =torch.Size((1, 199, 768))
											self.assertEqual(outputs.last_hidden_state.shape       ,  lowercase_)

											a__      =torch.tensor(
											    [[-0.05_29, 0.36_18, 0.16_32], [-0.15_87, -0.16_67, -0.04_00], [-0.15_57, -0.16_71, -0.05_05]]).to(lowercase_)

											self.assertTrue(torch.allclose(outputs.last_hidden_state[0, :3, :3]       ,  lowercase_       ,  atol=1e-4))





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()
_lowerCAmelCase:						List[str]   				=       logging.get_logger(__name__)

_lowerCAmelCase:						Tuple   				=       torch.device('cpu')






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






def   _lowercase(					__a				:						Optional[Any]     ):
							if swiftformer_name == "swiftformer_xs":
														return torch.tensor([-2.1703e00, 2.1107e00, -2.0811e00, 8.8685e-01, 2.4360e-01]     )

							elif swiftformer_name == "swiftformer_s":
														return torch.tensor([3.9636e-01, 2.3478e-01, -1.6963e00, -1.7381e00, -8.6337e-01]     )

							elif swiftformer_name == "swiftformer_l1":
														return torch.tensor([-4.2768e-01, -4.7429e-01, -1.0897e00, -1.0248e00, 3.5523e-02]     )

							elif swiftformer_name == "swiftformer_l3":
														return torch.tensor([-2.5330e-01, 2.4211e-01, -6.0185e-01, -8.2789e-01, -6.0446e-02]     )






def   _lowercase(					__a				:						int    ,     __a				:						int    ,     __a				:						Optional[Any]     ):
							a__      =dct.pop(__a     )
							a__      =val






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






@torch.no_grad()
def   _lowercase(					__a				:						Union[str, Any]    ,     __a				:						int    ,     __a				:						str     ):
							a__      =SwiftFormerConfig()

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

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

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

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

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

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

							a__      =create_rename_keys(__a     )
							for rename_key_src, rename_key_dest in rename_keys:
														rename_key(__a    ,     __a    ,     __a     )

							# load HuggingFace model
							a__      =SwiftFormerForImageClassification(__a     ).eval()
							hf_model.load_state_dict(__a     )

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

							# compare outputs from both models
							a__      =get_expected_output(__a     )
							a__      =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__":
	_lowerCAmelCase:						Optional[Any]   				=       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.')

	_lowerCAmelCase:						Optional[int]   				=       parser.parse_args()
	convert_swiftformer_checkpoint(args.swiftformer_name, args.pytorch_dump_folder_path, args.original_ckpt)

