




'''simple docstring'''



import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto import CONFIG_MAPPING


lowerCamelCase_			=						logging.get_logger(__name__)

lowerCamelCase_			=						{
    'SenseTime/deformable-detr': 'https://huggingface.co/sensetime/deformable-detr/resolve/main/config.json',
    # See all Deformable DETR models at https://huggingface.co/models?filter=deformable-detr
}







class 		lowercase_   (			A       ):


   """simple docstring"""

   lowerCamelCase_      =						'''deformable_detr'''
   lowerCamelCase_      =						{
       '''hidden_size''': '''d_model''',
       '''num_attention_heads''': '''encoder_attention_heads''',
   }



   def __init__(   self :     str  ,				__lowerCamelCase :     int=True  ,				__lowerCamelCase :     List[Any]=None  ,				__lowerCamelCase :     List[str]=3  ,				__lowerCamelCase :     Tuple=3_0_0  ,				__lowerCamelCase :     int=1_0_2_4  ,				__lowerCamelCase :     str=6  ,				__lowerCamelCase :     Optional[int]=1_0_2_4  ,				__lowerCamelCase :     List[str]=8  ,				__lowerCamelCase :     Optional[int]=6  ,				__lowerCamelCase :     List[Any]=1_0_2_4  ,				__lowerCamelCase :     Dict=8  ,				__lowerCamelCase :     List[Any]=0.0  ,				__lowerCamelCase :     Optional[int]=True  ,				__lowerCamelCase :     Union[str, Any]="relu"  ,				__lowerCamelCase :     Optional[int]=2_5_6  ,				__lowerCamelCase :     Optional[int]=0.1  ,				__lowerCamelCase :     Optional[Any]=0.0  ,				__lowerCamelCase :     List[str]=0.0  ,				__lowerCamelCase :     List[Any]=0.0_2  ,				__lowerCamelCase :     str=1.0  ,				__lowerCamelCase :     Optional[Any]=True  ,				__lowerCamelCase :     List[Any]=False  ,				__lowerCamelCase :     Any="sine"  ,				__lowerCamelCase :     Tuple="resnet50"  ,				__lowerCamelCase :     Tuple=True  ,				__lowerCamelCase :     List[Any]=False  ,				__lowerCamelCase :     int=4  ,				__lowerCamelCase :     int=4  ,				__lowerCamelCase :     Any=4  ,				__lowerCamelCase :     int=False  ,				__lowerCamelCase :     Optional[Any]=3_0_0  ,				__lowerCamelCase :     Optional[int]=False  ,				__lowerCamelCase :     Dict=1  ,				__lowerCamelCase :     Dict=5  ,				__lowerCamelCase :     Tuple=2  ,				__lowerCamelCase :     Dict=1  ,				__lowerCamelCase :     Union[str, Any]=1  ,				__lowerCamelCase :     Dict=5  ,				__lowerCamelCase :     Optional[int]=2  ,				__lowerCamelCase :     str=0.1  ,				__lowerCamelCase :     List[str]=0.2_5  ,				__lowerCamelCase :     List[Any]=False  ,				**__lowerCamelCase :     List[str]  ,				):

      """simple docstring"""
      if backbone_config is not None and use_timm_backbone:
         raise ValueError("You can't specify both `backbone_config` and `use_timm_backbone`."   )

      if not use_timm_backbone:
         if backbone_config is None:
            logger.info("`backbone_config` is `None`. Initializing the config with the default `ResNet` backbone."   )
            _SCREAMING_SNAKE_CASE	=				CONFIG_MAPPING["resnet"](out_features=["stage4"]   )
         elif isinstance(__lowerCamelCase  ,				__lowerCamelCase   ):
            _SCREAMING_SNAKE_CASE	=				backbone_config.get("model_type"   )
            _SCREAMING_SNAKE_CASE	=				CONFIG_MAPPING[backbone_model_type]
            _SCREAMING_SNAKE_CASE	=				config_class.from_dict(__lowerCamelCase   )
      _SCREAMING_SNAKE_CASE	=				use_timm_backbone
      _SCREAMING_SNAKE_CASE	=				backbone_config
      _SCREAMING_SNAKE_CASE	=				num_channels
      _SCREAMING_SNAKE_CASE	=				num_queries
      _SCREAMING_SNAKE_CASE	=				max_position_embeddings
      _SCREAMING_SNAKE_CASE	=				d_model
      _SCREAMING_SNAKE_CASE	=				encoder_ffn_dim
      _SCREAMING_SNAKE_CASE	=				encoder_layers
      _SCREAMING_SNAKE_CASE	=				encoder_attention_heads
      _SCREAMING_SNAKE_CASE	=				decoder_ffn_dim
      _SCREAMING_SNAKE_CASE	=				decoder_layers
      _SCREAMING_SNAKE_CASE	=				decoder_attention_heads
      _SCREAMING_SNAKE_CASE	=				dropout
      _SCREAMING_SNAKE_CASE	=				attention_dropout
      _SCREAMING_SNAKE_CASE	=				activation_dropout
      _SCREAMING_SNAKE_CASE	=				activation_function
      _SCREAMING_SNAKE_CASE	=				init_std
      _SCREAMING_SNAKE_CASE	=				init_xavier_std
      _SCREAMING_SNAKE_CASE	=				encoder_layerdrop
      _SCREAMING_SNAKE_CASE	=				auxiliary_loss
      _SCREAMING_SNAKE_CASE	=				position_embedding_type
      _SCREAMING_SNAKE_CASE	=				backbone
      _SCREAMING_SNAKE_CASE	=				use_pretrained_backbone
      _SCREAMING_SNAKE_CASE	=				dilation
      # deformable attributes
      _SCREAMING_SNAKE_CASE	=				num_feature_levels
      _SCREAMING_SNAKE_CASE	=				encoder_n_points
      _SCREAMING_SNAKE_CASE	=				decoder_n_points
      _SCREAMING_SNAKE_CASE	=				two_stage
      _SCREAMING_SNAKE_CASE	=				two_stage_num_proposals
      _SCREAMING_SNAKE_CASE	=				with_box_refine
      if two_stage is True and with_box_refine is False:
         raise ValueError("If two_stage is True, with_box_refine must be True."   )
      # Hungarian matcher
      _SCREAMING_SNAKE_CASE	=				class_cost
      _SCREAMING_SNAKE_CASE	=				bbox_cost
      _SCREAMING_SNAKE_CASE	=				giou_cost
      # Loss coefficients
      _SCREAMING_SNAKE_CASE	=				mask_loss_coefficient
      _SCREAMING_SNAKE_CASE	=				dice_loss_coefficient
      _SCREAMING_SNAKE_CASE	=				bbox_loss_coefficient
      _SCREAMING_SNAKE_CASE	=				giou_loss_coefficient
      _SCREAMING_SNAKE_CASE	=				eos_coefficient
      _SCREAMING_SNAKE_CASE	=				focal_alpha
      _SCREAMING_SNAKE_CASE	=				disable_custom_kernels
      super().__init__(is_encoder_decoder=__lowerCamelCase  ,				**__lowerCamelCase   )



   @property
   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      return self.encoder_attention_heads



   @property
   def 							lowerCAmelCase_      (   self :     Tuple   ):

      """simple docstring"""
      return self.d_model



   def 							lowerCAmelCase_      (   self :     Optional[int]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				copy.deepcopy(self.__dict__   )
      if self.backbone_config is not None:
         _SCREAMING_SNAKE_CASE	=				self.backbone_config.to_dict()
      _SCREAMING_SNAKE_CASE	=				self.__class__.model_type
      return output







'''simple docstring'''



import unittest
from pathlib import Path
from tempfile import NamedTemporaryFile, TemporaryDirectory

from transformers import BertConfig, BertTokenizerFast, FeatureExtractionPipeline
from transformers.convert_graph_to_onnx import (
    convert,
    ensure_valid_input,
    generate_identified_filename,
    infer_shapes,
    quantize,
)
from transformers.testing_utils import require_tf, require_tokenizers, require_torch, slow







class 		lowercase_   :


   """simple docstring"""

   def 							lowerCAmelCase_      (   self :     int  ,				__lowerCamelCase :     str  ,				__lowerCamelCase :     Optional[int]  ,				__lowerCamelCase :     Tuple   ):

      """simple docstring"""
      return None







class 		lowercase_   :


   """simple docstring"""

   def 							lowerCAmelCase_      (   self :     Union[str, Any]  ,				__lowerCamelCase :     str  ,				__lowerCamelCase :     List[str]  ,				__lowerCamelCase :     Union[str, Any]  ,				__lowerCamelCase :     List[Any]   ):

      """simple docstring"""
      return None







class 		lowercase_   (			unittest.TestCase       ):


   """simple docstring"""

   lowerCamelCase_      =						[
       # (model_name, model_kwargs)
       ('''bert-base-cased''', {}),
       ('''gpt2''', {'''use_cache''': False}),  # We don't support exporting GPT2 past keys anymore
   ]



   @require_tf
   @slow
   def 							lowerCAmelCase_      (   self :     Union[str, Any]   ):

      """simple docstring"""
      for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
         self._test_export(__lowerCamelCase  ,				"tf"  ,				1_2  ,				**__lowerCamelCase   )



   @require_torch
   @slow
   def 							lowerCAmelCase_      (   self :     List[Any]   ):

      """simple docstring"""
      for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
         self._test_export(__lowerCamelCase  ,				"pt"  ,				1_2  ,				**__lowerCamelCase   )



   @require_torch
   @slow
   def 							lowerCAmelCase_      (   self :     List[Any]   ):

      """simple docstring"""
      from transformers import BertModel

      _SCREAMING_SNAKE_CASE	=				["[UNK]", "[SEP]", "[CLS]", "[PAD]", "[MASK]", "some", "other", "words"]
      with NamedTemporaryFile(mode="w+t"   ) as vocab_file:
         vocab_file.write("\n".join(__lowerCamelCase   )   )
         vocab_file.flush()
         _SCREAMING_SNAKE_CASE	=				BertTokenizerFast(vocab_file.name   )

      with TemporaryDirectory() as bert_save_dir:
         _SCREAMING_SNAKE_CASE	=				BertModel(BertConfig(vocab_size=len(__lowerCamelCase   )   )   )
         model.save_pretrained(__lowerCamelCase   )
         self._test_export(__lowerCamelCase  ,				"pt"  ,				1_2  ,				__lowerCamelCase   )



   @require_tf
   @slow
   def 							lowerCAmelCase_      (   self :     Optional[int]   ):

      """simple docstring"""
      for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
         _SCREAMING_SNAKE_CASE	=				self._test_export(__lowerCamelCase  ,				"tf"  ,				1_2  ,				**__lowerCamelCase   )
         _SCREAMING_SNAKE_CASE	=				quantize(Path(__lowerCamelCase   )   )

         # Ensure the actual quantized model is not bigger than the original one
         if quantized_path.stat().st_size >= Path(__lowerCamelCase   ).stat().st_size:
            self.fail("Quantized model is bigger than initial ONNX model"   )



   @require_torch
   @slow
   def 							lowerCAmelCase_      (   self :     Union[str, Any]   ):

      """simple docstring"""
      for model, model_kwargs in OnnxExportTestCase.MODEL_TO_TEST:
         _SCREAMING_SNAKE_CASE	=				self._test_export(__lowerCamelCase  ,				"pt"  ,				1_2  ,				**__lowerCamelCase   )
         _SCREAMING_SNAKE_CASE	=				quantize(__lowerCamelCase   )

         # Ensure the actual quantized model is not bigger than the original one
         if quantized_path.stat().st_size >= Path(__lowerCamelCase   ).stat().st_size:
            self.fail("Quantized model is bigger than initial ONNX model"   )



   def 							lowerCAmelCase_      (   self :     Tuple  ,				__lowerCamelCase :     Optional[Any]  ,				__lowerCamelCase :     Any  ,				__lowerCamelCase :     Dict  ,				__lowerCamelCase :     Optional[int]=None  ,				**__lowerCamelCase :     int   ):

      """simple docstring"""
      try:
         # Compute path
         with TemporaryDirectory() as tempdir:
            _SCREAMING_SNAKE_CASE	=				Path(__lowerCamelCase   ).joinpath("model.onnx"   )

         # Remove folder if exists
         if path.parent.exists():
            path.parent.rmdir()

         # Export
         convert(__lowerCamelCase  ,				__lowerCamelCase  ,				__lowerCamelCase  ,				__lowerCamelCase  ,				__lowerCamelCase  ,				**__lowerCamelCase   )

         return path
      except Exception as e:
         self.fail(__lowerCamelCase   )



   @require_torch
   @require_tokenizers
   @slow
   def 							lowerCAmelCase_      (   self :     Tuple   ):

      """simple docstring"""
      from transformers import BertModel

      _SCREAMING_SNAKE_CASE	=				BertModel(BertConfig.from_pretrained("lysandre/tiny-bert-random"   )   )
      _SCREAMING_SNAKE_CASE	=				BertTokenizerFast.from_pretrained("lysandre/tiny-bert-random"   )
      self._test_infer_dynamic_axis(__lowerCamelCase  ,				__lowerCamelCase  ,				"pt"   )



   @require_tf
   @require_tokenizers
   @slow
   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      from transformers import TFBertModel

      _SCREAMING_SNAKE_CASE	=				TFBertModel(BertConfig.from_pretrained("lysandre/tiny-bert-random"   )   )
      _SCREAMING_SNAKE_CASE	=				BertTokenizerFast.from_pretrained("lysandre/tiny-bert-random"   )
      self._test_infer_dynamic_axis(__lowerCamelCase  ,				__lowerCamelCase  ,				"tf"   )



   def 							lowerCAmelCase_      (   self :     List[Any]  ,				__lowerCamelCase :     Tuple  ,				__lowerCamelCase :     Optional[Any]  ,				__lowerCamelCase :     List[Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				FeatureExtractionPipeline(__lowerCamelCase  ,				__lowerCamelCase   )

      _SCREAMING_SNAKE_CASE	=				["input_ids", "token_type_ids", "attention_mask", "output_0", "output_1"]
      _SCREAMING_SNAKE_CASE,	_SCREAMING_SNAKE_CASE,	_SCREAMING_SNAKE_CASE,	_SCREAMING_SNAKE_CASE	=				infer_shapes(__lowerCamelCase  ,				__lowerCamelCase   )

      # Assert all variables are present
      self.assertEqual(len(__lowerCamelCase   )  ,				len(__lowerCamelCase   )   )
      self.assertTrue(all(var_name in shapes for var_name in variable_names   )   )
      self.assertSequenceEqual(variable_names[:3]  ,				__lowerCamelCase   )
      self.assertSequenceEqual(variable_names[3:]  ,				__lowerCamelCase   )

      # Assert inputs are {0: batch, 1: sequence}
      for var_name in ["input_ids", "token_type_ids", "attention_mask"]:
         self.assertDictEqual(shapes[var_name]  ,				{0: "batch", 1: "sequence"}   )

      # Assert outputs are {0: batch, 1: sequence} and {0: batch}
      self.assertDictEqual(shapes["output_0"]  ,				{0: "batch", 1: "sequence"}   )
      self.assertDictEqual(shapes["output_1"]  ,				{0: "batch"}   )



   def 							lowerCAmelCase_      (   self :     Union[str, Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				["input_ids", "attention_mask", "token_type_ids"]
      _SCREAMING_SNAKE_CASE	=				{"input_ids": [1, 2, 3, 4], "attention_mask": [0, 0, 0, 0], "token_type_ids": [1, 1, 1, 1]}
      _SCREAMING_SNAKE_CASE,	_SCREAMING_SNAKE_CASE	=				ensure_valid_input(FuncContiguousArgs()  ,				__lowerCamelCase  ,				__lowerCamelCase   )

      # Should have exactly the same number of args (all are valid)
      self.assertEqual(len(__lowerCamelCase   )  ,				3   )

      # Should have exactly the same input names
      self.assertEqual(set(__lowerCamelCase   )  ,				set(__lowerCamelCase   )   )

      # Parameter should be reordered according to their respective place in the function:
      # (input_ids, token_type_ids, attention_mask)
      self.assertEqual(__lowerCamelCase  ,				(tokens["input_ids"], tokens["token_type_ids"], tokens["attention_mask"])   )

      # Generated args are interleaved with another args (for instance parameter "past" in GPT2)
      _SCREAMING_SNAKE_CASE,	_SCREAMING_SNAKE_CASE	=				ensure_valid_input(FuncNonContiguousArgs()  ,				__lowerCamelCase  ,				__lowerCamelCase   )

      # Should have exactly the one arg (all before the one not provided "some_other_args")
      self.assertEqual(len(__lowerCamelCase   )  ,				1   )
      self.assertEqual(len(__lowerCamelCase   )  ,				1   )

      # Should have only "input_ids"
      self.assertEqual(inputs_args[0]  ,				tokens["input_ids"]   )
      self.assertEqual(ordered_input_names[0]  ,				"input_ids"   )



   def 							lowerCAmelCase_      (   self :     Optional[int]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				generate_identified_filename(Path("/home/something/my_fake_model.onnx"   )  ,				"-test"   )
      self.assertEqual("/home/something/my_fake_model-test.onnx"  ,				generated.as_posix()   )

