





import inspect
import unittest

from huggingface_hub import hf_hub_download

from transformers import ConvNextConfig, UperNetConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

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


if is_torch_available():
    import torch

    from transformers import UperNetForSemanticSegmentation
    from transformers.models.upernet.modeling_upernet import UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor

class   lowerCAmelCase				:
 def __init__( self    : str     ,	UpperCAmelCase    : int     ,	UpperCAmelCase    : int=13     ,	UpperCAmelCase    : str=32     ,	UpperCAmelCase    : List[Any]=3     ,	UpperCAmelCase    : int=4     ,	UpperCAmelCase    : Dict=[10, 20, 30, 40]     ,	UpperCAmelCase    : int=[2, 2, 3, 2]     ,	UpperCAmelCase    : Dict=True     ,	UpperCAmelCase    : str=True     ,	UpperCAmelCase    : Tuple=37     ,	UpperCAmelCase    : List[str]="gelu"     ,	UpperCAmelCase    : Dict=10     ,	UpperCAmelCase    : Tuple=0.0_2     ,	UpperCAmelCase    : str=["stage2", "stage3", "stage4"]     ,	UpperCAmelCase    : Union[str, Any]=3     ,	UpperCAmelCase    : Optional[Any]=None     ,	)     ->      Union[str, Any]:
     lowerCamelCase__       : Tuple   					=						parent
     lowerCamelCase__       : Dict   					=						batch_size
     lowerCamelCase__       : Dict   					=						image_size
     lowerCamelCase__       : Union[str, Any]   					=						num_channels
     lowerCamelCase__       : Optional[int]   					=						num_stages
     lowerCamelCase__       : Union[str, Any]   					=						hidden_sizes
     lowerCamelCase__       : int   					=						depths
     lowerCamelCase__       : Union[str, Any]   					=						is_training
     lowerCamelCase__       : str   					=						use_labels
     lowerCamelCase__       : Union[str, Any]   					=						intermediate_size
     lowerCamelCase__       : Any   					=						hidden_act
     lowerCamelCase__       : Optional[int]   					=						type_sequence_label_size
     lowerCamelCase__       : Tuple   					=						initializer_range
     lowerCamelCase__       : Union[str, Any]   					=						out_features
     lowerCamelCase__       : Dict   					=						num_labels
     lowerCamelCase__       : int   					=						scope
     lowerCamelCase__       : Any   					=						num_stages
 def 	A_      ( self    : Optional[int]      )     ->      int:
     lowerCamelCase__       : Optional[Any]   					=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

     lowerCamelCase__       : str   					=						None
     if self.use_labels:
         lowerCamelCase__       : List[str]   					=						ids_tensor([self.batch_size]     ,	self.type_sequence_label_size      )

     lowerCamelCase__       : Optional[Any]   					=						self.get_config()

     return config, pixel_values, labels
 def 	A_      ( self    : Union[str, Any]      )     ->      int:
     return ConvNextConfig(
         num_channels=self.num_channels     ,	num_stages=self.num_stages     ,	hidden_sizes=self.hidden_sizes     ,	depths=self.depths     ,	is_training=self.is_training     ,	intermediate_size=self.intermediate_size     ,	hidden_act=self.hidden_act     ,	out_features=self.out_features     ,	)
 def 	A_      ( self    : Tuple      )     ->      List[str]:
     return UperNetConfig(
         backbone_config=self.get_backbone_config()     ,	hidden_size=512     ,	pool_scales=[1, 2, 3, 6]     ,	use_auxiliary_head=UpperCAmelCase     ,	auxiliary_loss_weight=0.4     ,	auxiliary_in_channels=40     ,	auxiliary_channels=256     ,	auxiliary_num_convs=1     ,	auxiliary_concat_input=UpperCAmelCase     ,	loss_ignore_index=255     ,	num_labels=self.num_labels     ,	)
 def 	A_      ( self    : Tuple     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : List[Any]     ,	UpperCAmelCase    : List[str]      )     ->      Tuple:
     lowerCamelCase__       : Union[str, Any]   					=						UperNetForSemanticSegmentation(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : int   					=						model(UpperCAmelCase      )
     self.parent.assertEqual(
         result.logits.shape     ,	(self.batch_size, self.num_labels, self.image_size, self.image_size)      )







 def 	A_      ( self    : List[Any]      )     ->      Optional[int]:
     lowerCamelCase__       : Dict   					=						self.prepare_config_and_inputs()
     (
         (
         lowerCamelCase__
     )					,				(
         lowerCamelCase__
     )					,				(
         lowerCamelCase__
     )					,				
     )       : Optional[int]   					=						config_and_inputs
     lowerCamelCase__       : Optional[int]   					=						{'pixel_values': pixel_values}
     return config, inputs_dict


@require_torch
class   lowerCAmelCase				(   __UpperCamelCase,    __UpperCamelCase,    unittest.TestCase     ):
 UpperCAmelCase__						=						(UperNetForSemanticSegmentation,) if is_torch_available() else ()
 UpperCAmelCase__						=						{"""image-segmentation""": UperNetForSemanticSegmentation} if is_torch_available() else {}
 UpperCAmelCase__						=						False
 UpperCAmelCase__						=						False
 UpperCAmelCase__						=						False
 UpperCAmelCase__						=						False
 UpperCAmelCase__						=						False
 UpperCAmelCase__						=						False
 def 	A_      ( self    : Any      )     ->      Dict:
     lowerCamelCase__       : Optional[int]   					=						UperNetModelTester(self      )
     lowerCamelCase__       : List[Any]   					=						ConfigTester(self     ,	config_class=UpperCAmelCase     ,	has_text_modality=UpperCAmelCase     ,	hidden_size=37      )
 def 	A_      ( self    : Dict      )     ->      List[Any]:
     self.create_and_test_config_common_properties()
     self.config_tester.create_and_test_config_to_json_string()
     self.config_tester.create_and_test_config_to_json_file()
     self.config_tester.create_and_test_config_from_and_save_pretrained()
     self.config_tester.create_and_test_config_with_num_labels()
     self.config_tester.check_config_can_be_init_without_params()
     self.config_tester.check_config_arguments_init()
 def 	A_      ( self    : Optional[int]      )     ->      int:
     return
 def 	A_      ( self    : Any      )     ->      List[str]:
     lowerCamelCase__					,				lowerCamelCase__       : str   					=						self.model_tester.prepare_config_and_inputs_for_common()

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

         lowerCamelCase__       : Any   					=						['pixel_values']
         self.assertListEqual(arg_names[:1]     ,	UpperCAmelCase      )
 def 	A_      ( self    : Any      )     ->      Union[str, Any]:
     lowerCamelCase__       : Tuple   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_semantic_segmentation(*UpperCAmelCase      )
 @unittest.skip(reason='UperNet does not use inputs_embeds'      )
 def 	A_      ( self    : Optional[Any]      )     ->      Tuple:
     pass
 @unittest.skip(reason='UperNet does not support input and output embeddings'      )
 def 	A_      ( self    : int      )     ->      Union[str, Any]:
     pass
 @unittest.skip(reason='UperNet does not have a base model'      )
 def 	A_      ( self    : Dict      )     ->      List[str]:
     pass
 @unittest.skip(reason='UperNet does not have a base model'      )
 def 	A_      ( self    : Union[str, Any]      )     ->      Union[str, Any]:
     pass
 @require_torch_multi_gpu
 @unittest.skip(reason='UperNet has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'      )
 def 	A_      ( self    : Optional[Any]      )     ->      Tuple:
     pass
 @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'      )
 def 	A_      ( self    : Any      )     ->      Union[str, Any]:
     pass
 def 	A_      ( self    : Union[str, Any]      )     ->      Union[str, Any]:
     def check_hidden_states_output(UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : Tuple     ,	UpperCAmelCase    : int      ):
         lowerCamelCase__       : Union[str, Any]   					=						model_class(UpperCAmelCase      )
         model.to(UpperCAmelCase      )
         model.eval()

         with torch.no_grad():
             lowerCamelCase__       : int   					=						model(**self._prepare_for_class(UpperCAmelCase     ,	UpperCAmelCase      )      )

         lowerCamelCase__       : Tuple   					=						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

         lowerCamelCase__       : List[str]   					=						self.model_tester.num_stages
         self.assertEqual(len(UpperCAmelCase      )     ,	expected_num_stages + 1      )

         # ConvNext's feature maps are of shape (batch_size, num_channels, height, width)
         self.assertListEqual(
             list(hidden_states[0].shape[-2:]      )     ,	[self.model_tester.image_size // 4, self.model_tester.image_size // 4]     ,	)

     lowerCamelCase__					,				lowerCamelCase__       : Optional[Any]   					=						self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         lowerCamelCase__       : Union[str, Any]   					=						True
         check_hidden_states_output(UpperCAmelCase     ,	UpperCAmelCase     ,	UpperCAmelCase      )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         lowerCamelCase__       : Union[str, Any]   					=						True

         check_hidden_states_output(UpperCAmelCase     ,	UpperCAmelCase     ,	UpperCAmelCase      )
 def 	A_      ( self    : Any      )     ->      List[str]:
     lowerCamelCase__					,				lowerCamelCase__       : List[str]   					=						self.model_tester.prepare_config_and_inputs_for_common()

     lowerCamelCase__       : Optional[Any]   					=						_config_zero_init(UpperCAmelCase      )
     lowerCamelCase__       : Any   					=						_config_zero_init(configs_no_init.backbone_config      )
     for model_class in self.all_model_classes:
         lowerCamelCase__       : Tuple   					=						model_class(config=UpperCAmelCase      )
         for name, param in model.named_parameters():
             if param.requires_grad:
                 self.assertIn(
                     ((param.data.mean() * 1e9).round() / 1e9).item()     ,	[0.0, 1.0]     ,	msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""     ,	)
 @unittest.skip(reason='UperNet does not have tied weights'      )
 def 	A_      ( self    : str      )     ->      int:
     pass







 @slow
 def 	A_      ( self    : str      )     ->      Any:
     for model_name in UPERNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         lowerCamelCase__       : str   					=						UperNetForSemanticSegmentation.from_pretrained(UpperCAmelCase      )
         self.assertIsNotNone(UpperCAmelCase      )


def 			SCREAMING_SNAKE_CASE (			)     ->	Optional[int]:
    lowerCamelCase__       : Tuple   					=						hf_hub_download(
        repo_id='hf-internal-testing/fixtures_ade20k'		,      repo_type='dataset'		,      filename='ADE_val_00000001.jpg'					)
    lowerCamelCase__       : Dict   					=						Image.open(_UpperCAmelCase					).convert('RGB'					)
    return image


@require_torch
@require_vision
@slow
class   lowerCAmelCase				(   unittest.TestCase     ):
 def 	A_      ( self    : Optional[Any]      )     ->      Union[str, Any]:
     lowerCamelCase__       : Optional[Any]   					=						AutoImageProcessor.from_pretrained('openmmlab/upernet-swin-tiny'      )
     lowerCamelCase__       : int   					=						UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-swin-tiny'      ).to(UpperCAmelCase      )

     lowerCamelCase__       : Dict   					=						prepare_img()
     lowerCamelCase__       : List[Any]   					=						processor(images=UpperCAmelCase     ,	return_tensors='pt'      ).to(UpperCAmelCase      )

     with torch.no_grad():
         lowerCamelCase__       : Union[str, Any]   					=						model(**UpperCAmelCase      )

     lowerCamelCase__       : List[str]   					=						torch.Size((1, model.config.num_labels, 512, 512)      )
     self.assertEqual(outputs.logits.shape     ,	UpperCAmelCase      )

     lowerCamelCase__       : List[str]   					=						torch.tensor(
         [[-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.5_9_5_8, -7.5_9_5_8, -7.4_3_0_2], [-7.4_7_9_7, -7.4_7_9_7, -7.3_0_6_8]]      ).to(UpperCAmelCase      )
     self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]     ,	UpperCAmelCase     ,	atol=1e-4      )      )







 def 	A_      ( self    : List[str]      )     ->      Any:
     lowerCamelCase__       : Optional[int]   					=						AutoImageProcessor.from_pretrained('openmmlab/upernet-convnext-tiny'      )
     lowerCamelCase__       : str   					=						UperNetForSemanticSegmentation.from_pretrained('openmmlab/upernet-convnext-tiny'      ).to(UpperCAmelCase      )

     lowerCamelCase__       : int   					=						prepare_img()
     lowerCamelCase__       : Union[str, Any]   					=						processor(images=UpperCAmelCase     ,	return_tensors='pt'      ).to(UpperCAmelCase      )

     with torch.no_grad():
         lowerCamelCase__       : str   					=						model(**UpperCAmelCase      )

     lowerCamelCase__       : Union[str, Any]   					=						torch.Size((1, model.config.num_labels, 512, 512)      )
     self.assertEqual(outputs.logits.shape     ,	UpperCAmelCase      )

     lowerCamelCase__       : Union[str, Any]   					=						torch.tensor(
         [[-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.8_1_1_0, -8.8_1_1_0, -8.6_5_2_1], [-8.7_7_4_6, -8.7_7_4_6, -8.6_1_3_0]]      ).to(UpperCAmelCase      )
     self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]     ,	UpperCAmelCase     ,	atol=1e-4      )      )












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   lowerCAmelCase				(   __UpperCamelCase     ):
 def __init__( self    : str     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Dict=13     ,	UpperCAmelCase    : List[Any]=7     ,	UpperCAmelCase    : Tuple=True     ,	UpperCAmelCase    : str=True     ,	UpperCAmelCase    : int=False     ,	UpperCAmelCase    : Optional[Any]=True     ,	UpperCAmelCase    : int=99     ,	UpperCAmelCase    : Dict=32     ,	UpperCAmelCase    : Dict=5     ,	UpperCAmelCase    : List[str]=4     ,	UpperCAmelCase    : Optional[Any]=64     ,	UpperCAmelCase    : Any="gelu"     ,	UpperCAmelCase    : List[str]=0.1     ,	UpperCAmelCase    : Optional[Any]=0.1     ,	UpperCAmelCase    : Any=512     ,	UpperCAmelCase    : List[str]=16     ,	UpperCAmelCase    : Union[str, Any]=2     ,	UpperCAmelCase    : Union[str, Any]=0.0_2     ,	UpperCAmelCase    : Dict=3     ,	UpperCAmelCase    : List[Any]=4     ,	UpperCAmelCase    : int=None     ,	UpperCAmelCase    : Optional[int]=2     ,	UpperCAmelCase    : Tuple=2     ,	UpperCAmelCase    : Optional[Any]=2     ,	UpperCAmelCase    : Tuple=2     ,	UpperCAmelCase    : List[str]=4     ,	UpperCAmelCase    : Dict=1     ,	)     ->      List[Any]:
     lowerCamelCase__       : Any   					=						parent
     lowerCamelCase__       : Tuple   					=						batch_size
     lowerCamelCase__       : Union[str, Any]   					=						seq_length
     lowerCamelCase__       : Optional[Any]   					=						is_training
     lowerCamelCase__       : Optional[Any]   					=						use_input_mask
     lowerCamelCase__       : List[Any]   					=						use_token_type_ids
     lowerCamelCase__       : str   					=						use_labels
     lowerCamelCase__       : Any   					=						vocab_size
     lowerCamelCase__       : Any   					=						hidden_size
     lowerCamelCase__       : int   					=						num_hidden_layers
     lowerCamelCase__       : Optional[Any]   					=						num_attention_heads
     lowerCamelCase__       : Optional[int]   					=						intermediate_size
     lowerCamelCase__       : int   					=						hidden_act
     lowerCamelCase__       : List[Any]   					=						hidden_dropout_prob
     lowerCamelCase__       : List[str]   					=						attention_probs_dropout_prob
     lowerCamelCase__       : Any   					=						max_position_embeddings
     lowerCamelCase__       : Dict   					=						type_vocab_size
     lowerCamelCase__       : Optional[int]   					=						type_sequence_label_size
     lowerCamelCase__       : Any   					=						initializer_range
     lowerCamelCase__       : int   					=						num_labels
     lowerCamelCase__       : Tuple   					=						num_choices
     lowerCamelCase__       : Optional[Any]   					=						scope
     lowerCamelCase__       : Dict   					=						q_groups
     lowerCamelCase__       : Optional[Any]   					=						k_groups
     lowerCamelCase__       : Any   					=						v_groups
     lowerCamelCase__       : List[str]   					=						post_attention_groups
     lowerCamelCase__       : Dict   					=						intermediate_groups
     lowerCamelCase__       : Optional[int]   					=						output_groups
 def 	A_      ( self    : str      )     ->      str:
     lowerCamelCase__       : List[Any]   					=						ids_tensor([self.batch_size, self.seq_length]     ,	self.vocab_size      )

     lowerCamelCase__       : Tuple   					=						None
     if self.use_input_mask:
         lowerCamelCase__       : Any   					=						random_attention_mask([self.batch_size, self.seq_length]      )

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

     lowerCamelCase__       : int   					=						self.get_config()

     return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels
 def 	A_      ( self    : Union[str, Any]      )     ->      List[Any]:
     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 	A_      ( self    : List[Any]     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : str     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : List[str]      )     ->      List[str]:
     lowerCamelCase__       : List[Any]   					=						SqueezeBertModel(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Optional[Any]   					=						model(UpperCAmelCase     ,	UpperCAmelCase      )
     lowerCamelCase__       : Union[str, Any]   					=						model(UpperCAmelCase      )
     self.parent.assertEqual(result.last_hidden_state.shape     ,	(self.batch_size, self.seq_length, self.hidden_size)      )
 def 	A_      ( self    : List[str]     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : Tuple     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : Union[str, Any]     ,	UpperCAmelCase    : List[Any]      )     ->      Optional[Any]:
     lowerCamelCase__       : List[Any]   					=						SqueezeBertForMaskedLM(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Union[str, Any]   					=						model(UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase      )
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.seq_length, self.vocab_size)      )
 def 	A_      ( self    : int     ,	UpperCAmelCase    : Optional[int]     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : int     ,	UpperCAmelCase    : List[Any]     ,	UpperCAmelCase    : Union[str, Any]     ,	UpperCAmelCase    : List[str]      )     ->      Optional[Any]:
     lowerCamelCase__       : Union[str, Any]   					=						SqueezeBertForQuestionAnswering(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : List[Any]   					=						model(
         UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	start_positions=UpperCAmelCase     ,	end_positions=UpperCAmelCase      )
     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 	A_      ( self    : Tuple     ,	UpperCAmelCase    : str     ,	UpperCAmelCase    : Optional[int]     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Optional[Any]     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : Any      )     ->      Any:
     lowerCamelCase__       : int   					=						self.num_labels
     lowerCamelCase__       : Optional[int]   					=						SqueezeBertForSequenceClassification(UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Union[str, Any]   					=						model(UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase      )
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.num_labels)      )
 def 	A_      ( self    : int     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : Tuple     ,	UpperCAmelCase    : Any     ,	UpperCAmelCase    : List[str]     ,	UpperCAmelCase    : List[Any]     ,	UpperCAmelCase    : Optional[Any]      )     ->      List[str]:
     lowerCamelCase__       : str   					=						self.num_labels
     lowerCamelCase__       : int   					=						SqueezeBertForTokenClassification(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()

     lowerCamelCase__       : List[Any]   					=						model(UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase      )
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.seq_length, self.num_labels)      )
 def 	A_      ( self    : Optional[int]     ,	UpperCAmelCase    : int     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : Dict     ,	UpperCAmelCase    : List[Any]     ,	UpperCAmelCase    : str     ,	UpperCAmelCase    : int      )     ->      Tuple:
     lowerCamelCase__       : Optional[int]   					=						self.num_choices
     lowerCamelCase__       : List[str]   					=						SqueezeBertForMultipleChoice(config=UpperCAmelCase      )
     model.to(UpperCAmelCase      )
     model.eval()
     lowerCamelCase__       : Dict   					=						input_ids.unsqueeze(1      ).expand(-1     ,	self.num_choices     ,	-1      ).contiguous()
     lowerCamelCase__       : List[str]   					=						input_mask.unsqueeze(1      ).expand(-1     ,	self.num_choices     ,	-1      ).contiguous()
     lowerCamelCase__       : str   					=						model(
         UpperCAmelCase     ,	attention_mask=UpperCAmelCase     ,	labels=UpperCAmelCase     ,	)
     self.parent.assertEqual(result.logits.shape     ,	(self.batch_size, self.num_choices)      )







 def 	A_      ( self    : Optional[Any]      )     ->      Optional[int]:
     lowerCamelCase__       : Optional[Any]   					=						self.prepare_config_and_inputs()
     ((lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__)					,				(lowerCamelCase__))       : Tuple   					=						config_and_inputs
     lowerCamelCase__       : Optional[Any]   					=						{'input_ids': input_ids, 'attention_mask': input_mask}
     return config, inputs_dict


@require_torch
class   lowerCAmelCase				(   __UpperCamelCase,    __UpperCamelCase,    unittest.TestCase     ):
 UpperCAmelCase__						=						(
     (
         SqueezeBertModel,
         SqueezeBertForMaskedLM,
         SqueezeBertForMultipleChoice,
         SqueezeBertForQuestionAnswering,
         SqueezeBertForSequenceClassification,
         SqueezeBertForTokenClassification,
     )
     if is_torch_available()
     else None
 )
 UpperCAmelCase__						=						(
     {
         """feature-extraction""": SqueezeBertModel,
         """fill-mask""": SqueezeBertForMaskedLM,
         """question-answering""": SqueezeBertForQuestionAnswering,
         """text-classification""": SqueezeBertForSequenceClassification,
         """token-classification""": SqueezeBertForTokenClassification,
         """zero-shot""": SqueezeBertForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 UpperCAmelCase__						=						False
 UpperCAmelCase__						=						True
 UpperCAmelCase__						=						False
 def 	A_      ( self    : Union[str, Any]      )     ->      Dict:
     lowerCamelCase__       : Optional[Any]   					=						SqueezeBertModelTester(self      )
     lowerCamelCase__       : Optional[Any]   					=						ConfigTester(self     ,	config_class=UpperCAmelCase     ,	dim=37      )
 def 	A_      ( self    : str      )     ->      str:
     self.config_tester.run_common_tests()
 def 	A_      ( self    : str      )     ->      int:
     lowerCamelCase__       : List[str]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_model(*UpperCAmelCase      )
 def 	A_      ( self    : Union[str, Any]      )     ->      Tuple:
     lowerCamelCase__       : int   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_masked_lm(*UpperCAmelCase      )
 def 	A_      ( self    : Union[str, Any]      )     ->      Any:
     lowerCamelCase__       : List[str]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_question_answering(*UpperCAmelCase      )
 def 	A_      ( self    : Union[str, Any]      )     ->      List[str]:
     lowerCamelCase__       : Optional[Any]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_sequence_classification(*UpperCAmelCase      )
 def 	A_      ( self    : Optional[int]      )     ->      Optional[Any]:
     lowerCamelCase__       : Tuple   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_token_classification(*UpperCAmelCase      )
 def 	A_      ( self    : Any      )     ->      Optional[Any]:
     lowerCamelCase__       : List[str]   					=						self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_squeezebert_for_multiple_choice(*UpperCAmelCase      )







 @slow
 def 	A_      ( self    : Optional[int]      )     ->      Dict:
     for model_name in SQUEEZEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         lowerCamelCase__       : Any   					=						SqueezeBertModel.from_pretrained(UpperCAmelCase      )
         self.assertIsNotNone(UpperCAmelCase      )


@require_sentencepiece
@require_tokenizers
@require_torch
class   lowerCAmelCase				(   unittest.TestCase     ):
 @slow
 def 	A_      ( self    : Optional[Any]      )     ->      List[str]:
     lowerCamelCase__       : Dict   					=						SqueezeBertForSequenceClassification.from_pretrained('squeezebert/squeezebert-mnli'      )

     lowerCamelCase__       : Optional[int]   					=						torch.tensor([[1, 29414, 232, 328, 740, 1140, 12695, 69, 13, 1588, 2]]      )
     lowerCamelCase__       : Optional[int]   					=						model(UpperCAmelCase      )[0]
     lowerCamelCase__       : Dict   					=						torch.Size((1, 3)      )
     self.assertEqual(output.shape     ,	UpperCAmelCase      )
     lowerCamelCase__       : List[str]   					=						torch.tensor([[0.6_4_0_1, -0.0_3_4_9, -0.6_0_4_1]]      )
     self.assertTrue(torch.allclose(UpperCAmelCase     ,	UpperCAmelCase     ,	atol=1e-4      )      )





