import unittest

from transformers import SqueezeBertConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

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


if is_torch_available():
		import torch

		from transformers import (
		    SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
		    SqueezeBertForMaskedLM,
		    SqueezeBertForMultipleChoice,
		    SqueezeBertForQuestionAnswering,
		    SqueezeBertForSequenceClassification,
		    SqueezeBertForTokenClassification,
		    SqueezeBertModel,
		)






class 		a__						(					A__					):

					def __init__(    self      :       Tuple,_A      :       Optional[int],_A      :       Any=13,_A      :       List[str]=7,_A      :       int=True,_A      :       Dict=True,_A      :       Dict=False,_A      :       List[Any]=True,_A      :       Any=99,_A      :       Optional[int]=32,_A      :       Any=5,_A      :       List[Any]=4,_A      :       Dict=64,_A      :       Optional[Any]="gelu",_A      :       Tuple=0.1,_A      :       Any=0.1,_A      :       List[Any]=512,_A      :       Dict=16,_A      :       Optional[Any]=2,_A      :       Union[str, Any]=0.02,_A      :       List[str]=3,_A      :       Optional[Any]=4,_A      :       Union[str, Any]=None,_A      :       Tuple=2,_A      :       List[str]=2,_A      :       str=2,_A      :       Dict=2,_A      :       Optional[Any]=4,_A      :       Union[str, Any]=1,):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    parent
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    batch_size
							SCREAMING_SNAKE_CASE_  :		Dict				      =    seq_length
							SCREAMING_SNAKE_CASE_  :		Dict				      =    is_training
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    use_input_mask
							SCREAMING_SNAKE_CASE_  :		int				      =    use_token_type_ids
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    use_labels
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    vocab_size
							SCREAMING_SNAKE_CASE_  :		Any				      =    hidden_size
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    num_hidden_layers
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    num_attention_heads
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    intermediate_size
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    hidden_act
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    hidden_dropout_prob
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    attention_probs_dropout_prob
							SCREAMING_SNAKE_CASE_  :		str				      =    max_position_embeddings
							SCREAMING_SNAKE_CASE_  :		str				      =    type_vocab_size
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    type_sequence_label_size
							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    initializer_range
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    num_labels
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    num_choices
							SCREAMING_SNAKE_CASE_  :		Dict				      =    scope
							SCREAMING_SNAKE_CASE_  :		int				      =    q_groups
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    k_groups
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    v_groups
							SCREAMING_SNAKE_CASE_  :		Tuple				      =    post_attention_groups
							SCREAMING_SNAKE_CASE_  :		int				      =    intermediate_groups
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    output_groups

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







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    ids_tensor([self.batch_size, self.seq_length],self.vocab_size    )

							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    None
							if self.use_input_mask:
									SCREAMING_SNAKE_CASE_  :		List[str]				      =    random_attention_mask([self.batch_size, self.seq_length]    )

							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    None
							SCREAMING_SNAKE_CASE_  :		Any				      =    None
							SCREAMING_SNAKE_CASE_  :		str				      =    None
							if self.use_labels:
									SCREAMING_SNAKE_CASE_  :		str				      =    ids_tensor([self.batch_size],self.type_sequence_label_size    )
									SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    ids_tensor([self.batch_size, self.seq_length],self.num_labels    )
									SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    ids_tensor([self.batch_size],self.num_choices    )

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    self.get_config()

							return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels

					def 				__UpperCamelCase   (    self      :       str    ):







							"""simple docstring"""






							return SqueezeBertConfig(
							    embedding_size=self.hidden_size,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,attention_probs_dropout_prob=self.hidden_dropout_prob,attention_dropout=self.attention_probs_dropout_prob,max_position_embeddings=self.max_position_embeddings,initializer_range=self.initializer_range,q_groups=self.q_groups,k_groups=self.k_groups,v_groups=self.v_groups,post_attention_groups=self.post_attention_groups,intermediate_groups=self.intermediate_groups,output_groups=self.output_groups,)

					def 				__UpperCamelCase   (    self      :       Tuple,_A      :       Union[str, Any],_A      :       Union[str, Any],_A      :       int,_A      :       Optional[int],_A      :       Union[str, Any],_A      :       Any    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    SqueezeBertModel(config=_A    )
							model.to(_A    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Any				      =    model(_A,_A    )
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    model(_A    )
							self.parent.assertEqual(result.last_hidden_state.shape,(self.batch_size, self.seq_length, self.hidden_size)    )

					def 				__UpperCamelCase   (    self      :       Dict,_A      :       Any,_A      :       Tuple,_A      :       str,_A      :       Any,_A      :       Union[str, Any],_A      :       Any    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    SqueezeBertForMaskedLM(config=_A    )
							model.to(_A    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    model(_A,attention_mask=_A,labels=_A    )
							self.parent.assertEqual(result.logits.shape,(self.batch_size, self.seq_length, self.vocab_size)    )

					def 				__UpperCamelCase   (    self      :       Optional[int],_A      :       Union[str, Any],_A      :       Union[str, Any],_A      :       Any,_A      :       Tuple,_A      :       int,_A      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    SqueezeBertForQuestionAnswering(config=_A    )
							model.to(_A    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Dict				      =    model(
							    _A,attention_mask=_A,start_positions=_A,end_positions=_A    )
							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      :       List[Any],_A      :       List[str],_A      :       Tuple,_A      :       List[Any],_A      :       List[str],_A      :       List[str],_A      :       List[str]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    self.num_labels
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    SqueezeBertForSequenceClassification(_A    )
							model.to(_A    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Dict				      =    model(_A,attention_mask=_A,labels=_A    )
							self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_labels)    )

					def 				__UpperCamelCase   (    self      :       str,_A      :       Optional[int],_A      :       str,_A      :       List[Any],_A      :       List[str],_A      :       str,_A      :       Dict    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    self.num_labels
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    SqueezeBertForTokenClassification(config=_A    )
							model.to(_A    )
							model.eval()

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    model(_A,attention_mask=_A,labels=_A    )
							self.parent.assertEqual(result.logits.shape,(self.batch_size, self.seq_length, self.num_labels)    )

					def 				__UpperCamelCase   (    self      :       List[Any],_A      :       Tuple,_A      :       str,_A      :       Optional[Any],_A      :       int,_A      :       str,_A      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    self.num_choices
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    SqueezeBertForMultipleChoice(config=_A    )
							model.to(_A    )
							model.eval()
							SCREAMING_SNAKE_CASE_  :		Dict				      =    input_ids.unsqueeze(1    ).expand(-1,self.num_choices,-1    ).contiguous()
							SCREAMING_SNAKE_CASE_  :		str				      =    input_mask.unsqueeze(1    ).expand(-1,self.num_choices,-1    ).contiguous()
							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    model(
							    _A,attention_mask=_A,labels=_A,)
							self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_choices)    )






					def 				__UpperCamelCase   (    self      :       Optional[int]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    self.prepare_config_and_inputs()
							((SCREAMING_SNAKE_CASE_)      ,    (SCREAMING_SNAKE_CASE_)      ,    (SCREAMING_SNAKE_CASE_)      ,    (SCREAMING_SNAKE_CASE_)      ,    (SCREAMING_SNAKE_CASE_)      ,    (SCREAMING_SNAKE_CASE_))  :		Dict				      =    config_and_inputs
							SCREAMING_SNAKE_CASE_  :		Dict				      =    {"input_ids": input_ids, "attention_mask": input_mask}
							return config, inputs_dict







@require_torch
class 		a__						(					A__    ,		A__    ,		unittest.TestCase					):
					A	       =							(
					    (
					        SqueezeBertModel,
					        SqueezeBertForMaskedLM,
					        SqueezeBertForMultipleChoice,
					        SqueezeBertForQuestionAnswering,
					        SqueezeBertForSequenceClassification,
					        SqueezeBertForTokenClassification,
					    )
					    if is_torch_available()
					    else None
					)
					A	       =							(
					    {
					        'feature-extraction': SqueezeBertModel,
					        'fill-mask': SqueezeBertForMaskedLM,
					        'question-answering': SqueezeBertForQuestionAnswering,
					        'text-classification': SqueezeBertForSequenceClassification,
					        'token-classification': SqueezeBertForTokenClassification,
					        'zero-shot': SqueezeBertForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)
					A	       =							False
					A	       =							True
					A	       =							False

					def 				__UpperCamelCase   (    self      :       int    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    SqueezeBertModelTester(self    )
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    ConfigTester(self,config_class=_A,dim=37    )

					def 				__UpperCamelCase   (    self      :       List[str]    ):







							"""simple docstring"""






							self.config_tester.run_common_tests()

					def 				__UpperCamelCase   (    self      :       Tuple    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_model(*_A    )

					def 				__UpperCamelCase   (    self      :       List[Any]    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		List[str]				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_for_masked_lm(*_A    )

					def 				__UpperCamelCase   (    self      :       int    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_for_question_answering(*_A    )

					def 				__UpperCamelCase   (    self      :       Dict    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_for_sequence_classification(*_A    )

					def 				__UpperCamelCase   (    self      :       Tuple    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		int				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_for_token_classification(*_A    )

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







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Tuple				      =    self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_squeezebert_for_multiple_choice(*_A    )






					@slow
					def 				__UpperCamelCase   (    self      :       Any    ):







							"""simple docstring"""






							for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									SCREAMING_SNAKE_CASE_  :		Tuple				      =    SqueezeBertModel.from_pretrained(_A    )
									self.assertIsNotNone(_A    )







@require_sentencepiece
@require_tokenizers
@require_torch
class 		a__						(					unittest.TestCase					):

					@slow
					def 				__UpperCamelCase   (    self      :       int    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		str				      =    SqueezeBertForSequenceClassification.from_pretrained("squeezebert/squeezebert-mnli"    )

							SCREAMING_SNAKE_CASE_  :		Optional[int]				      =    torch.tensor([[1, 2_9414, 232, 328, 740, 1140, 1_2695, 69, 13, 1588, 2]]    )
							SCREAMING_SNAKE_CASE_  :		List[Any]				      =    model(_A    )[0]
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    torch.Size((1, 3)    )
							self.assertEqual(output.shape,_A    )
							SCREAMING_SNAKE_CASE_  :		int				      =    torch.tensor([[0.6401, -0.0349, -0.6041]]    )
							self.assertTrue(torch.allclose(_A,_A,atol=1E-4    )    )


import copy
from collections import OrderedDict
from typing import Mapping

from packaging import version

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


_lowerCamelCase					   =logging.get_logger(__name__)

_lowerCamelCase					   ={
    """microsoft/conditional-detr-resnet-50""": (
        """https://huggingface.co/microsoft/conditional-detr-resnet-50/resolve/main/config.json"""
    ),
}





class 							A__		(	__SCREAMING_SNAKE_CASE):
      _UpperCAmelCase				:    Union[str, Any]           =			"""conditional_detr"""
      _UpperCAmelCase				:    Optional[int]           =			["""past_key_values"""]
      _UpperCAmelCase				:    Optional[Any]           =			{
          """hidden_size""": """d_model""",
          """num_attention_heads""": """encoder_attention_heads""",
      }
      def __init__(      self    ,  __magic_name__=True    ,  __magic_name__=None    ,  __magic_name__=3    ,  __magic_name__=3_0_0    ,  __magic_name__=6    ,  __magic_name__=2_0_4_8    ,  __magic_name__=8    ,  __magic_name__=6    ,  __magic_name__=2_0_4_8    ,  __magic_name__=8    ,  __magic_name__=0.0    ,  __magic_name__=0.0    ,  __magic_name__=True    ,  __magic_name__="relu"    ,  __magic_name__=2_5_6    ,  __magic_name__=0.1    ,  __magic_name__=0.0    ,  __magic_name__=0.0    ,  __magic_name__=0.02    ,  __magic_name__=1.0    ,  __magic_name__=False    ,  __magic_name__="sine"    ,  __magic_name__="resnet50"    ,  __magic_name__=True    ,  __magic_name__=False    ,  __magic_name__=2    ,  __magic_name__=5    ,  __magic_name__=2    ,  __magic_name__=1    ,  __magic_name__=1    ,  __magic_name__=2    ,  __magic_name__=5    ,  __magic_name__=2    ,  __magic_name__=0.25    ,  **__magic_name__    ,  ):
       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."""      )
         lowerCamelCase		:	Optional[int]							=      CONFIG_MAPPING["""resnet"""](out_features=["""stage4"""]      )
        elif isinstance(__magic_name__    ,  __magic_name__      ):
         lowerCamelCase		:	List[Any]							=      backbone_config.get("""model_type"""      )
         lowerCamelCase		:	Dict							=      CONFIG_MAPPING[backbone_model_type]
         lowerCamelCase		:	str							=      config_class.from_dict(__magic_name__      )

       lowerCamelCase		:	Dict							=      use_timm_backbone
       lowerCamelCase		:	str							=      backbone_config
       lowerCamelCase		:	Tuple							=      num_channels
       lowerCamelCase		:	Dict							=      num_queries
       lowerCamelCase		:	Any							=      d_model
       lowerCamelCase		:	Optional[Any]							=      encoder_ffn_dim
       lowerCamelCase		:	List[str]							=      encoder_layers
       lowerCamelCase		:	Union[str, Any]							=      encoder_attention_heads
       lowerCamelCase		:	Any							=      decoder_ffn_dim
       lowerCamelCase		:	Dict							=      decoder_layers
       lowerCamelCase		:	Union[str, Any]							=      decoder_attention_heads
       lowerCamelCase		:	Dict							=      dropout
       lowerCamelCase		:	List[str]							=      attention_dropout
       lowerCamelCase		:	Union[str, Any]							=      activation_dropout
       lowerCamelCase		:	Optional[int]							=      activation_function
       lowerCamelCase		:	int							=      init_std
       lowerCamelCase		:	str							=      init_xavier_std
       lowerCamelCase		:	Tuple							=      encoder_layerdrop
       lowerCamelCase		:	str							=      decoder_layerdrop
       lowerCamelCase		:	Tuple							=      encoder_layers
       lowerCamelCase		:	Optional[int]							=      auxiliary_loss
       lowerCamelCase		:	Optional[Any]							=      position_embedding_type
       lowerCamelCase		:	Optional[int]							=      backbone
       lowerCamelCase		:	Union[str, Any]							=      use_pretrained_backbone
       lowerCamelCase		:	str							=      dilation
       # Hungarian matcher
       lowerCamelCase		:	Optional[Any]							=      class_cost
       lowerCamelCase		:	Dict							=      bbox_cost
       lowerCamelCase		:	Tuple							=      giou_cost
       # Loss coefficients
       lowerCamelCase		:	Union[str, Any]							=      mask_loss_coefficient
       lowerCamelCase		:	Dict							=      dice_loss_coefficient
       lowerCamelCase		:	Optional[int]							=      cls_loss_coefficient
       lowerCamelCase		:	Optional[int]							=      bbox_loss_coefficient
       lowerCamelCase		:	Optional[int]							=      giou_loss_coefficient
       lowerCamelCase		:	Optional[int]							=      focal_alpha
       super().__init__(is_encoder_decoder=__magic_name__    ,  **__magic_name__      )
      @property
      def 						UpperCamelCase__							(      self      ):
       return self.encoder_attention_heads
      @property
      def 						UpperCamelCase__							(      self      ):
       return self.d_model






      def 						UpperCamelCase__							(      self      ):
       lowerCamelCase		:	Optional[int]							=      copy.deepcopy(self.__dict__      )
       if self.backbone_config is not None:
        lowerCamelCase		:	Optional[int]							=      self.backbone_config.to_dict()
       lowerCamelCase		:	Optional[Any]							=      self.__class__.model_type
       return output





class 							A__		(	__SCREAMING_SNAKE_CASE):
      _UpperCAmelCase				:    Any           =			version.parse("""1.11""")
      @property
      def 						UpperCamelCase__							(      self      ):
       return OrderedDict(
           [
               ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
               ("""pixel_mask""", {0: """batch"""}),
           ]      )
      @property
      def 						UpperCamelCase__							(      self      ):
       return 1e-5






      @property
      def 						UpperCamelCase__							(      self      ):
       return 1_2




