

import inspect
import unittest

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

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


if is_torch_available():
  import torch

  from transformers import MODEL_MAPPING, PoolFormerConfig, PoolFormerForImageClassification, PoolFormerModel
  from transformers.models.poolformer.modeling_poolformer import POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
  from PIL import Image

  from transformers import PoolFormerImageProcessor





class A__     (			_lowercase			):



 """simple docstring"""







 def  __magic_name__							(		self			:						Dict							):






      '''simple docstring'''




      _lowerCAmelCase :       int	   =     self.config_class(**self.inputs_dict							)
      self.parent.assertTrue(hasattr(snake_case__  ,    "hidden_sizes"							)							)
      self.parent.assertTrue(hasattr(snake_case__  ,    "num_encoder_blocks"							)							)





class A__     :



 """simple docstring"""







 def __init__(		self			:						Union[str, Any]  ,    A_			:						List[Any]  ,    A_			:						Optional[Any]=1_3  ,    A_			:						Optional[Any]=6_4  ,    A_			:						str=3  ,    A_			:						Union[str, Any]=4  ,    A_			:						Dict=[2, 2, 2, 2]  ,    A_			:						Any=[8, 4, 2, 1]  ,    A_			:						Dict=[1_6, 3_2, 6_4, 1_2_8]  ,    A_			:						Any=[1, 4, 8, 1_6]  ,    A_			:						Optional[Any]=False  ,    A_			:						Tuple=True  ,    A_			:						int="gelu"  ,    A_			:						Union[str, Any]=0.1  ,    A_			:						Optional[Any]=0.02  ,    A_			:						str=3  ,    A_			:						Union[str, Any]=None  ,    ):






      '''simple docstring'''




      _lowerCAmelCase :       List[str]	   =     parent
      _lowerCAmelCase :       Any	   =     batch_size
      _lowerCAmelCase :       Optional[Any]	   =     image_size
      _lowerCAmelCase :       Dict	   =     num_channels
      _lowerCAmelCase :       Optional[Any]	   =     num_encoder_blocks
      _lowerCAmelCase :       Dict	   =     sr_ratios
      _lowerCAmelCase :       List[Any]	   =     depths
      _lowerCAmelCase :       Dict	   =     hidden_sizes
      _lowerCAmelCase :       int	   =     downsampling_rates
      _lowerCAmelCase :       Tuple	   =     is_training
      _lowerCAmelCase :       str	   =     use_labels
      _lowerCAmelCase :       int	   =     hidden_act
      _lowerCAmelCase :       Optional[Any]	   =     hidden_dropout_prob
      _lowerCAmelCase :       Union[str, Any]	   =     initializer_range
      _lowerCAmelCase :       Union[str, Any]	   =     num_labels
      _lowerCAmelCase :       str	   =     scope

 def  __magic_name__							(		self			:						str							):






      '''simple docstring'''




      _lowerCAmelCase :       Optional[Any]	   =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

      _lowerCAmelCase :       Dict	   =     None
      if self.use_labels:
           _lowerCAmelCase :       Dict	   =     ids_tensor([self.batch_size, self.image_size, self.image_size]  ,    self.num_labels							)

      _lowerCAmelCase :       Optional[Any]	   =     PoolFormerConfig(
          image_size=self.image_size  ,    num_channels=self.num_channels  ,    num_encoder_blocks=self.num_encoder_blocks  ,    depths=self.depths  ,    hidden_sizes=self.hidden_sizes  ,    hidden_act=self.hidden_act  ,    hidden_dropout_prob=self.hidden_dropout_prob  ,    initializer_range=self.initializer_range  ,    )

      return config, pixel_values, labels

 def  __magic_name__							(		self			:						List[Any]  ,    A_			:						Optional[int]  ,    A_			:						Union[str, Any]  ,    A_			:						List[Any]							):






      '''simple docstring'''




      _lowerCAmelCase :       List[str]	   =     PoolFormerModel(config=snake_case__							)
      model.to(snake_case__							)
      model.eval()
      _lowerCAmelCase :       Tuple	   =     model(snake_case__							)
      _lowerCAmelCase :       Union[str, Any]	   =     self.image_size // 32.0
      self.parent.assertEqual(
          result.last_hidden_state.shape  ,    (self.batch_size, self.hidden_sizes[-1], expected_height, expected_width)							)


 def  __magic_name__							(		self			:						str							):






      '''simple docstring'''




      _lowerCAmelCase :       List[Any]	   =     self.prepare_config_and_inputs()
      _lowerCAmelCase :       Dict	   =     config_and_inputs
      _lowerCAmelCase :       Optional[int]	   =     {"""pixel_values""": pixel_values}
      return config, inputs_dict





@require_torch
class A__     (			_lowercase	,		_lowercase	,		unittest.TestCase			):



 """simple docstring"""







 _lowercase  :       str  			=    (PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
 _lowercase  :       List[str]  			=    (
     {'''feature-extraction''': PoolFormerModel, '''image-classification''': PoolFormerForImageClassification}
     if is_torch_available()
     else {}
 )

 _lowercase  :       List[str]  			=    False
 _lowercase  :       Dict  			=    False
 _lowercase  :       Union[str, Any]  			=    False
 _lowercase  :       Optional[Any]  			=    False
 _lowercase  :       str  			=    False

 def  __magic_name__							(		self			:						List[str]							):






      '''simple docstring'''




      _lowerCAmelCase :       Tuple	   =     PoolFormerModelTester(self							)
      _lowerCAmelCase :       Optional[int]	   =     PoolFormerConfigTester(self  ,    config_class=snake_case__							)

 def  __magic_name__							(		self			:						int							):






      '''simple docstring'''




      self.config_tester.run_common_tests()

 def  __magic_name__							(		self			:						Dict							):






      '''simple docstring'''




      _lowerCAmelCase :       List[str]	   =     self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*snake_case__							)

 @unittest.skip("PoolFormer does not use inputs_embeds"							)
 def  __magic_name__							(		self			:						List[Any]							):






      '''simple docstring'''




      pass

 @unittest.skip("PoolFormer does not have get_input_embeddings method and get_output_embeddings methods"							)
 def  __magic_name__							(		self			:						List[str]							):






      '''simple docstring'''




      pass

 def  __magic_name__							(		self			:						Any							):






      '''simple docstring'''




      def check_hidden_states_output(A_			:						Optional[Any]  ,    A_			:						Optional[Any]  ,    A_			:						Dict							):
           _lowerCAmelCase :       List[Any]	   =     model_class(snake_case__							)
           model.to(snake_case__							)
           model.eval()

           with torch.no_grad():
                _lowerCAmelCase :       Union[str, Any]	   =     model(**self._prepare_for_class(snake_case__  ,    snake_case__							)							)

           _lowerCAmelCase :       Dict	   =     outputs.hidden_states

           _lowerCAmelCase :       Dict	   =     self.model_tester.num_encoder_blocks
           self.assertEqual(len(snake_case__							)  ,    snake_case__							)

           # verify the first hidden states (first block)
           self.assertListEqual(
               list(hidden_states[0].shape[-3:]							)  ,    [
                   self.model_tester.hidden_sizes[0],
                   self.model_tester.image_size // 4,
                   self.model_tester.image_size // 4,
               ]  ,    )

      _lowerCAmelCase :       Tuple	   =     self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           _lowerCAmelCase :       str	   =     True
           check_hidden_states_output(snake_case__  ,    snake_case__  ,    snake_case__							)

           # check that output_hidden_states also work using config
           del inputs_dict["output_hidden_states"]
           _lowerCAmelCase :       Optional[int]	   =     True

           check_hidden_states_output(snake_case__  ,    snake_case__  ,    snake_case__							)

 def  __magic_name__							(		self			:						int							):






      '''simple docstring'''




      if not self.model_tester.is_training:
           return

      _lowerCAmelCase :       Any	   =     self.model_tester.prepare_config_and_inputs_for_common()
      _lowerCAmelCase :       List[str]	   =     True

      for model_class in self.all_model_classes:
           if model_class in get_values(snake_case__							):
                continue
           _lowerCAmelCase :       Any	   =     model_class(snake_case__							)
           model.to(snake_case__							)
           model.train()
           _lowerCAmelCase :       List[str]	   =     self._prepare_for_class(snake_case__  ,    snake_case__  ,    return_labels=snake_case__							)
           _lowerCAmelCase :       Any	   =     model(**snake_case__							).loss
           loss.backward()

 def  __magic_name__							(		self			:						int							):






      '''simple docstring'''




      _lowerCAmelCase :       str	   =     self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
           _lowerCAmelCase :       List[Any]	   =     model_class(snake_case__							)
           _lowerCAmelCase :       Optional[int]	   =     inspect.signature(model.forward							)
           # signature.parameters is an OrderedDict => so arg_names order is deterministic
           _lowerCAmelCase :       Dict	   =     [*signature.parameters.keys()]

           _lowerCAmelCase :       Optional[Any]	   =     ["""pixel_values"""]
           self.assertListEqual(arg_names[:1]  ,    snake_case__							)


 @slow
 def  __magic_name__							(		self			:						Any							):






      '''simple docstring'''




      for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowerCAmelCase :       int	   =     PoolFormerModel.from_pretrained(snake_case__							)
           self.assertIsNotNone(snake_case__							)







def 						_snake_case		(     )							->   List[Any]:

     """simple docstring"""







     _lowerCAmelCase :       Any	   =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
     return image





@require_torch
class A__     (			unittest.TestCase			):



 """simple docstring"""







 @slow
 def  __magic_name__							(		self			:						str							):






      '''simple docstring'''




      _lowerCAmelCase :       Tuple	   =     PoolFormerImageProcessor()
      _lowerCAmelCase :       Dict	   =     PoolFormerForImageClassification.from_pretrained("sail/poolformer_s12"							).to(snake_case__							)

      _lowerCAmelCase :       List[Any]	   =     image_processor(images=prepare_img()  ,    return_tensors="pt"							).to(snake_case__							)

      # forward pass
      with torch.no_grad():
           _lowerCAmelCase :       List[str]	   =     model(**snake_case__							)

      # verify the logits
      _lowerCAmelCase :       str	   =     torch.Size((1, 1_0_0_0)							)
      self.assertEqual(outputs.logits.shape  ,    snake_case__							)

      _lowerCAmelCase :       List[Any]	   =     torch.tensor([-0.6113, 0.1685, -0.0492]							).to(snake_case__							)
      self.assertTrue(torch.allclose(outputs.logits[0, :3]  ,    snake_case__  ,    atol=1E-4							)							)








"""simple docstring"""
import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_url
from PIL import Image

from transformers import DeformableDetrConfig, DeformableDetrForObjectDetection, DeformableDetrImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
lowercase		:    List[str]			=       logging.get_logger(__name__)


def      lowerCamelCase_     (						lowerCamelCase_			)  ->      str:


					'''simple docstring'''
					if "backbone.0.body" in orig_key:
										__a:    Any		     =       orig_key.replace("""backbone.0.body"""						,					"""backbone.conv_encoder.model"""			)
					if "transformer" in orig_key:
										__a:    str		     =       orig_key.replace("""transformer."""						,					""""""			)
					if "norm1" in orig_key:
										if "encoder" in orig_key:
															__a:    List[str]		     =       orig_key.replace("""norm1"""						,					"""self_attn_layer_norm"""			)
										else:
															__a:    Optional[int]		     =       orig_key.replace("""norm1"""						,					"""encoder_attn_layer_norm"""			)
					if "norm2" in orig_key:
										if "encoder" in orig_key:
															__a:    Union[str, Any]		     =       orig_key.replace("""norm2"""						,					"""final_layer_norm"""			)
										else:
															__a:    str		     =       orig_key.replace("""norm2"""						,					"""self_attn_layer_norm"""			)
					if "norm3" in orig_key:
										__a:    int		     =       orig_key.replace("""norm3"""						,					"""final_layer_norm"""			)
					if "linear1" in orig_key:
										__a:    Dict		     =       orig_key.replace("""linear1"""						,					"""fc1"""			)
					if "linear2" in orig_key:
										__a:    Any		     =       orig_key.replace("""linear2"""						,					"""fc2"""			)
					if "query_embed" in orig_key:
										__a:    Dict		     =       orig_key.replace("""query_embed"""						,					"""query_position_embeddings"""			)
					if "cross_attn" in orig_key:
										__a:    Dict		     =       orig_key.replace("""cross_attn"""						,					"""encoder_attn"""			)

					return orig_key


def      lowerCamelCase_     (						lowerCamelCase_			)  ->      List[str]:


					'''simple docstring'''
					# transformer decoder self-attention layers
					for i in range(6			):
										# read in weights + bias of input projection layer of self-attention
										__a:    Optional[Any]		     =       state_dict.pop(f"""decoder.layers.{i}.self_attn.in_proj_weight"""			)
										__a:    List[str]		     =       state_dict.pop(f"""decoder.layers.{i}.self_attn.in_proj_bias"""			)
										# next, add query, keys and values (in that order) to the state dict
										__a:    Optional[int]		     =       in_proj_weight[:2_56, :]
										__a:    int		     =       in_proj_bias[:2_56]
										__a:    Tuple		     =       in_proj_weight[2_56:5_12, :]
										__a:    Union[str, Any]		     =       in_proj_bias[2_56:5_12]
										__a:    Optional[int]		     =       in_proj_weight[-2_56:, :]
										__a:    Any		     =       in_proj_bias[-2_56:]


def      lowerCamelCase_     (						)  ->      Union[str, Any]:


					'''simple docstring'''
					__a:    List[Any]		     =       """http://images.cocodataset.org/val2017/000000039769.jpg"""
					__a:    Tuple		     =       Image.open(requests.get(lowerCamelCase_						,					stream=lowerCamelCase_			).raw			)

					return im


@torch.no_grad()
def      lowerCamelCase_     (						lowerCamelCase_						,					lowerCamelCase_						,					lowerCamelCase_						,					lowerCamelCase_						,					lowerCamelCase_						,					lowerCamelCase_						,					lowerCamelCase_						,					)  ->      Union[str, Any]:


					'''simple docstring'''
					__a:    Optional[Any]		     =       DeformableDetrConfig()
					# set config attributes
					if single_scale:
										__a:    Optional[int]		     =       1
					__a:    Optional[Any]		     =       dilation
					__a:    Dict		     =       with_box_refine
					__a:    Any		     =       two_stage
					# set labels
					__a:    str		     =       91
					__a:    Dict		     =       """huggingface/label-files"""
					__a:    Tuple		     =       """coco-detection-id2label.json"""
					__a:    Optional[int]		     =       json.load(open(cached_download(hf_hub_url(lowerCamelCase_						,					lowerCamelCase_						,					repo_type="""dataset"""			)			)						,					"""r"""			)			)
					__a:    Union[str, Any]		     =       {int(lowerCamelCase_			): v for k, v in idalabel.items()}
					__a:    Dict		     =       idalabel
					__a:    List[Any]		     =       {v: k for k, v in idalabel.items()}

					# load image processor
					__a:    Tuple		     =       DeformableDetrImageProcessor(format="""coco_detection"""			)

					# prepare image
					__a:    Tuple		     =       prepare_img()
					__a:    Optional[int]		     =       image_processor(images=lowerCamelCase_						,					return_tensors="""pt"""			)
					__a:    Any		     =       encoding["""pixel_values"""]

					logger.info("""Converting model..."""			)

					# load original state dict
					__a:    List[Any]		     =       torch.load(lowerCamelCase_						,					map_location="""cpu"""			)["""model"""]
					# rename keys
					for key in state_dict.copy().keys():
										__a:    Dict		     =       state_dict.pop(lowerCamelCase_			)
										__a:    List[str]		     =       val
					# query, key and value matrices need special treatment
					read_in_q_k_v(lowerCamelCase_			)
					# important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
					__a:    Optional[int]		     =       """model."""
					for key in state_dict.copy().keys():
										if not key.startswith("""class_embed"""			) and not key.startswith("""bbox_embed"""			):
															__a:    List[Any]		     =       state_dict.pop(lowerCamelCase_			)
															__a:    Optional[int]		     =       val
    # finally, create HuggingFace model and load state dict
					__a:    List[str]		     =       DeformableDetrForObjectDetection(lowerCamelCase_			)
					model.load_state_dict(lowerCamelCase_			)
					model.eval()

					__a:    List[str]		     =       """cuda""" if torch.cuda.is_available() else """cpu"""
					model.to(lowerCamelCase_			)
					# verify our conversion
					__a:    str		     =       model(pixel_values.to(lowerCamelCase_			)			)

					__a:    Union[str, Any]		     =       torch.tensor(
					    [[-9.6_645, -4.3_449, -5.8_705], [-9.7_035, -3.8_504, -5.0_724], [-10.5_634, -5.3_379, -7.5_116]]			)
					__a:    Union[str, Any]		     =       torch.tensor([[0.8_693, 0.2_289, 0.2_492], [0.3_150, 0.5_489, 0.5_845], [0.5_563, 0.7_580, 0.8_518]]			)

					if single_scale:
										__a:    Optional[Any]		     =       torch.tensor(
										    [[-9.9_051, -4.2_541, -6.4_852], [-9.6_947, -4.0_854, -6.8_033], [-10.0_665, -5.8_470, -7.7_003]]			)
										__a:    Any		     =       torch.tensor([[0.7_292, 0.4_991, 0.5_532], [0.7_959, 0.2_426, 0.4_236], [0.7_582, 0.3_518, 0.4_451]]			)

					if single_scale and dilation:
										__a:    Dict		     =       torch.tensor(
										    [[-8.9_652, -4.1_074, -5.6_635], [-9.0_596, -4.9_447, -6.6_075], [-10.1_178, -4.5_275, -6.2_671]]			)
										__a:    int		     =       torch.tensor([[0.7_665, 0.4_130, 0.4_769], [0.8_364, 0.1_841, 0.3_391], [0.6_261, 0.3_895, 0.7_978]]			)

					if with_box_refine:
										__a:    List[str]		     =       torch.tensor(
										    [[-8.8_895, -5.4_187, -6.8_153], [-8.4_706, -6.1_668, -7.6_184], [-9.0_042, -5.5_359, -6.9_141]]			)
										__a:    Optional[int]		     =       torch.tensor([[0.7_828, 0.2_208, 0.4_323], [0.0_892, 0.5_996, 0.1_319], [0.5_524, 0.6_389, 0.8_914]]			)

					if with_box_refine and two_stage:
										__a:    List[Any]		     =       torch.tensor(
										    [[-6.7_108, -4.3_213, -6.3_777], [-8.9_014, -6.1_799, -6.7_240], [-6.9_315, -4.4_735, -6.2_298]]			)
										__a:    Union[str, Any]		     =       torch.tensor([[0.2_583, 0.5_499, 0.4_683], [0.7_652, 0.9_068, 0.4_882], [0.5_490, 0.2_763, 0.0_564]]			)

					print("""Logits:"""						,					outputs.logits[0, :3, :3]			)

					assert torch.allclose(outputs.logits[0, :3, :3]						,					expected_logits.to(lowerCamelCase_			)						,					atol=1e-4			)
					assert torch.allclose(outputs.pred_boxes[0, :3, :3]						,					expected_boxes.to(lowerCamelCase_			)						,					atol=1e-4			)

					print("""Everything ok!"""			)

					# Save model and image processor
					logger.info(f"""Saving PyTorch model and image processor to {pytorch_dump_folder_path}..."""			)
					Path(lowerCamelCase_			).mkdir(exist_ok=lowerCamelCase_			)
					model.save_pretrained(lowerCamelCase_			)
					image_processor.save_pretrained(lowerCamelCase_			)

					# Push to hub
					if push_to_hub:
										__a:    Dict		     =       """deformable-detr"""
										model_name += "-single-scale" if single_scale else ""
										model_name += "-dc5" if dilation else ""
										model_name += "-with-box-refine" if with_box_refine else ""
										model_name += "-two-stage" if two_stage else ""
										print("""Pushing model to hub..."""			)
										model.push_to_hub(repo_path_or_name=lowerCamelCase_						,					organization="""nielsr"""						,					commit_message="""Add model"""			)


if __name__ == "__main__":
			lowercase		:    int			=       argparse.ArgumentParser()

			parser.add_argument(
			    '--checkpoint_path',
			    type=str,
			    default='/home/niels/checkpoints/deformable_detr/r50_deformable_detr-checkpoint.pth',
			    help='Path to Pytorch checkpoint (.pth file) you\'d like to convert.',
			)
			parser.add_argument('--single_scale', action='store_true', help='Whether to set config.num_features_levels = 1.')
			parser.add_argument('--dilation', action='store_true', help='Whether to set config.dilation=True.')
			parser.add_argument('--with_box_refine', action='store_true', help='Whether to set config.with_box_refine=True.')
			parser.add_argument('--two_stage', action='store_true', help='Whether to set config.two_stage=True.')
			parser.add_argument(
			    '--pytorch_dump_folder_path',
			    default=None,
			    type=str,
			    required=True,
			    help='Path to the folder to output PyTorch model.',
			)
			parser.add_argument(
			    '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
			)
			lowercase		:    Union[str, Any]			=       parser.parse_args()
			convert_deformable_detr_checkpoint(
			    args.checkpoint_path,
			    args.single_scale,
			    args.dilation,
			    args.with_box_refine,
			    args.two_stage,
			    args.pytorch_dump_folder_path,
			    args.push_to_hub,
			)
