

"""simple docstring"""




import unittest

import numpy as np

from transformers.testing_utils import is_flaky, require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
						import torch

if is_vision_available():
						from PIL import Image

						from transformers import DonutImageProcessor





class  lowerCamelCase    (unittest.TestCase      ):

			def __init__(       self					:    Any     ,					__UpperCAmelCase					:    Optional[int]     ,					__UpperCAmelCase					:    Dict=7     ,					__UpperCAmelCase					:    Union[str, Any]=3     ,					__UpperCAmelCase					:    List[str]=1_8     ,					__UpperCAmelCase					:    Dict=3_0     ,					__UpperCAmelCase					:    List[Any]=4_0_0     ,					__UpperCAmelCase					:    Optional[Any]=True     ,					__UpperCAmelCase					:    Tuple=None     ,					__UpperCAmelCase					:    str=True     ,					__UpperCAmelCase					:    Tuple=False     ,					__UpperCAmelCase					:    List[str]=True     ,					__UpperCAmelCase					:    Optional[int]=True     ,					__UpperCAmelCase					:    Optional[Any]=[0.5, 0.5, 0.5]     ,					__UpperCAmelCase					:    List[str]=[0.5, 0.5, 0.5]     ,					) ->     List[str]:
						SCREAMING_SNAKE_CASE__										=   parent
						SCREAMING_SNAKE_CASE__										=   batch_size
						SCREAMING_SNAKE_CASE__										=   num_channels
						SCREAMING_SNAKE_CASE__										=   image_size
						SCREAMING_SNAKE_CASE__										=   min_resolution
						SCREAMING_SNAKE_CASE__										=   max_resolution
						SCREAMING_SNAKE_CASE__										=   do_resize
						SCREAMING_SNAKE_CASE__										=   size if size is not None else {'height': 1_8, 'width': 2_0}
						SCREAMING_SNAKE_CASE__										=   do_thumbnail
						SCREAMING_SNAKE_CASE__										=   do_align_axis
						SCREAMING_SNAKE_CASE__										=   do_pad
						SCREAMING_SNAKE_CASE__										=   do_normalize
						SCREAMING_SNAKE_CASE__										=   image_mean
						SCREAMING_SNAKE_CASE__										=   image_std





			def        SCREAMING_SNAKE_CASE					(       self					:    str							) ->     Any:
						return {
						    "do_resize": self.do_resize,
						    "size": self.size,
						    "do_thumbnail": self.do_thumbnail,
						    "do_align_long_axis": self.do_align_axis,
						    "do_pad": self.do_pad,
						    "do_normalize": self.do_normalize,
						    "image_mean": self.image_mean,
						    "image_std": self.image_std,
						}





@require_torch
@require_vision
class  lowerCamelCase    (__UpperCamelCase      ,unittest.TestCase      ):
			lowerCamelCase__ :		Tuple       		=				DonutImageProcessor if is_vision_available() else None

			def        SCREAMING_SNAKE_CASE					(       self					:    List[Any]							) ->     int:
						SCREAMING_SNAKE_CASE__										=   DonutImageProcessingTester(self							)

			@property
			def        SCREAMING_SNAKE_CASE					(       self					:    Dict							) ->     Union[str, Any]:
						return self.image_processor_tester.prepare_image_processor_dict()

			def        SCREAMING_SNAKE_CASE					(       self					:    Dict							) ->     Any:
						SCREAMING_SNAKE_CASE__										=   self.image_processing_class(**self.image_processor_dict							)
						self.assertTrue(hasattr(__UpperCAmelCase     ,					"""do_resize"""							)							)
						self.assertTrue(hasattr(__UpperCAmelCase     ,					"""size"""							)							)
						self.assertTrue(hasattr(__UpperCAmelCase     ,					"""do_thumbnail"""							)							)
						self.assertTrue(hasattr(__UpperCAmelCase     ,					"""do_align_long_axis"""							)							)
						self.assertTrue(hasattr(__UpperCAmelCase     ,					"""do_pad"""							)							)
						self.assertTrue(hasattr(__UpperCAmelCase     ,					"""do_normalize"""							)							)
						self.assertTrue(hasattr(__UpperCAmelCase     ,					"""image_mean"""							)							)
						self.assertTrue(hasattr(__UpperCAmelCase     ,					"""image_std"""							)							)

			def        SCREAMING_SNAKE_CASE					(       self					:    Tuple							) ->     Union[str, Any]:
						SCREAMING_SNAKE_CASE__										=   self.image_processing_class.from_dict(self.image_processor_dict							)
						self.assertEqual(image_processor.size     ,					{"""height""": 1_8, """width""": 2_0}							)

						SCREAMING_SNAKE_CASE__										=   self.image_processing_class.from_dict(self.image_processor_dict     ,					size=4_2							)
						self.assertEqual(image_processor.size     ,					{"""height""": 4_2, """width""": 4_2}							)

						# Previous config had dimensions in (width, height) order
						SCREAMING_SNAKE_CASE__										=   self.image_processing_class.from_dict(self.image_processor_dict     ,					size=(4_2, 8_4)							)
						self.assertEqual(image_processor.size     ,					{"""height""": 8_4, """width""": 4_2}							)

			def        SCREAMING_SNAKE_CASE					(       self					:    Optional[Any]							) ->     List[str]:
						pass

			@is_flaky()
			def        SCREAMING_SNAKE_CASE					(       self					:    List[str]							) ->     Any:
						# Initialize image_processing
						SCREAMING_SNAKE_CASE__										=   self.image_processing_class(**self.image_processor_dict							)
						# create random PIL images
						SCREAMING_SNAKE_CASE__										=   prepare_image_inputs(self.image_processor_tester     ,					equal_resolution=__UpperCAmelCase							)
						for image in image_inputs:
									self.assertIsInstance(__UpperCAmelCase     ,					Image.Image							)

						# Test not batched input
						SCREAMING_SNAKE_CASE__										=   image_processing(image_inputs[0]     ,					return_tensors="""pt"""							).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,					(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size["""height"""],
						        self.image_processor_tester.size["""width"""],
						    )     ,					)

						# Test batched
						SCREAMING_SNAKE_CASE__										=   image_processing(__UpperCAmelCase     ,					return_tensors="""pt"""							).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,					(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size["""height"""],
						        self.image_processor_tester.size["""width"""],
						    )     ,					)

			@is_flaky()
			def        SCREAMING_SNAKE_CASE					(       self					:    int							) ->     Tuple:
						# Initialize image_processing
						SCREAMING_SNAKE_CASE__										=   self.image_processing_class(**self.image_processor_dict							)
						# create random numpy tensors
						SCREAMING_SNAKE_CASE__										=   prepare_image_inputs(self.image_processor_tester     ,					equal_resolution=__UpperCAmelCase     ,					numpify=__UpperCAmelCase							)
						for image in image_inputs:
									self.assertIsInstance(__UpperCAmelCase     ,					np.ndarray							)

						# Test not batched input
						SCREAMING_SNAKE_CASE__										=   image_processing(image_inputs[0]     ,					return_tensors="""pt"""							).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,					(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size["""height"""],
						        self.image_processor_tester.size["""width"""],
						    )     ,					)

						# Test batched
						SCREAMING_SNAKE_CASE__										=   image_processing(__UpperCAmelCase     ,					return_tensors="""pt"""							).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,					(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size["""height"""],
						        self.image_processor_tester.size["""width"""],
						    )     ,					)





			@is_flaky()
			def        SCREAMING_SNAKE_CASE					(       self					:    Any							) ->     Tuple:
						# Initialize image_processing
						SCREAMING_SNAKE_CASE__										=   self.image_processing_class(**self.image_processor_dict							)
						# create random PyTorch tensors
						SCREAMING_SNAKE_CASE__										=   prepare_image_inputs(self.image_processor_tester     ,					equal_resolution=__UpperCAmelCase     ,					torchify=__UpperCAmelCase							)
						for image in image_inputs:
									self.assertIsInstance(__UpperCAmelCase     ,					torch.Tensor							)

						# Test not batched input
						SCREAMING_SNAKE_CASE__										=   image_processing(image_inputs[0]     ,					return_tensors="""pt"""							).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,					(
						        1,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size["""height"""],
						        self.image_processor_tester.size["""width"""],
						    )     ,					)

						# Test batched
						SCREAMING_SNAKE_CASE__										=   image_processing(__UpperCAmelCase     ,					return_tensors="""pt"""							).pixel_values
						self.assertEqual(
						    encoded_images.shape     ,					(
						        self.image_processor_tester.batch_size,
						        self.image_processor_tester.num_channels,
						        self.image_processor_tester.size["""height"""],
						        self.image_processor_tester.size["""width"""],
						    )     ,					)









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      )      )





