






import unittest

from transformers import DebertaVaConfig, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    DebertaVaForMaskedLM,
							    DebertaVaForMultipleChoice,
							    DebertaVaForQuestionAnswering,
							    DebertaVaForSequenceClassification,
							    DebertaVaForTokenClassification,
							    DebertaVaModel,
							)
							from transformers.models.deberta_va.modeling_deberta_va import DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST
class       _UpperCAmelCase					(       A__	):

				"""simple docstring"""




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

								'''simple docstring'''
								lowercase__    =			parent
								lowercase__    =			batch_size
								lowercase__    =			seq_length
								lowercase__    =			is_training
								lowercase__    =			use_input_mask
								lowercase__    =			use_token_type_ids
								lowercase__    =			use_labels
								lowercase__    =			vocab_size
								lowercase__    =			hidden_size
								lowercase__    =			num_hidden_layers
								lowercase__    =			num_attention_heads
								lowercase__    =			intermediate_size
								lowercase__    =			hidden_act
								lowercase__    =			hidden_dropout_prob
								lowercase__    =			attention_probs_dropout_prob
								lowercase__    =			max_position_embeddings
								lowercase__    =			type_vocab_size
								lowercase__    =			type_sequence_label_size
								lowercase__    =			initializer_range
								lowercase__    =			num_labels
								lowercase__    =			num_choices
								lowercase__    =			relative_attention
								lowercase__    =			position_biased_input
								lowercase__    =			pos_att_type
								lowercase__    =			scope




				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								lowercase__    =			ids_tensor([self.batch_size, self.seq_length],  self.vocab_size  )

								lowercase__    =			None
								if self.use_input_mask:
												lowercase__    =			ids_tensor([self.batch_size, self.seq_length],  vocab_size=2  )

								lowercase__    =			None
								if self.use_token_type_ids:
												lowercase__    =			ids_tensor([self.batch_size, self.seq_length],  self.type_vocab_size  )

								lowercase__    =			None
								lowercase__    =			None
								lowercase__    =			None
								if self.use_labels:
												lowercase__    =			ids_tensor([self.batch_size],  self.type_sequence_label_size  )
												lowercase__    =			ids_tensor([self.batch_size, self.seq_length],  self.num_labels  )
												lowercase__    =			ids_tensor([self.batch_size],  self.num_choices  )

								lowercase__    =			self.get_config()

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




				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								return DebertaVaConfig(
								    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,  hidden_dropout_prob=self.hidden_dropout_prob,  attention_probs_dropout_prob=self.attention_probs_dropout_prob,  max_position_embeddings=self.max_position_embeddings,  type_vocab_size=self.type_vocab_size,  initializer_range=self.initializer_range,  relative_attention=self.relative_attention,  position_biased_input=self.position_biased_input,  pos_att_type=self.pos_att_type,  )




				def 				lowercase__   (     self						:    Optional[int],  lowerCamelCase						:    int  ):

								'''simple docstring'''
								self.parent.assertListEqual(list(result.loss.size()  ),  []  )




				def 				lowercase__   (     self						:    Optional[int],  lowerCamelCase						:    Optional[Any],  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    Tuple,  lowerCamelCase						:    int,  lowerCamelCase						:    Optional[Any],  lowerCamelCase						:    Optional[Any],  lowerCamelCase						:    Optional[Any]  ):

								'''simple docstring'''
								lowercase__    =			DebertaVaModel(config=lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase,  attention_mask=lowerCamelCase,  token_type_ids=lowerCamelCase  )[0]
								lowercase__    =			model(lowerCamelCase,  token_type_ids=lowerCamelCase  )[0]
								lowercase__    =			model(lowerCamelCase  )[0]

								self.parent.assertListEqual(list(sequence_output.size()  ),  [self.batch_size, self.seq_length, self.hidden_size]  )




				def 				lowercase__   (     self						:    List[str],  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    int,  lowerCamelCase						:    int,  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    List[str],  lowerCamelCase						:    Any,  lowerCamelCase						:    Optional[int]  ):

								'''simple docstring'''
								lowercase__    =			DebertaVaForMaskedLM(config=lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase,  attention_mask=lowerCamelCase,  token_type_ids=lowerCamelCase,  labels=lowerCamelCase  )

								self.parent.assertEqual(result.logits.shape,  (self.batch_size, self.seq_length, self.vocab_size)  )




				def 				lowercase__   (     self						:    Union[str, Any],  lowerCamelCase						:    List[str],  lowerCamelCase						:    Tuple,  lowerCamelCase						:    Any,  lowerCamelCase						:    Tuple,  lowerCamelCase						:    Dict,  lowerCamelCase						:    Optional[Any],  lowerCamelCase						:    Union[str, Any]  ):

								'''simple docstring'''
								lowercase__    =			self.num_labels
								lowercase__    =			DebertaVaForSequenceClassification(lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase,  attention_mask=lowerCamelCase,  token_type_ids=lowerCamelCase,  labels=lowerCamelCase  )
								self.parent.assertListEqual(list(result.logits.size()  ),  [self.batch_size, self.num_labels]  )
								self.check_loss_output(lowerCamelCase  )




				def 				lowercase__   (     self						:    Dict,  lowerCamelCase						:    List[str],  lowerCamelCase						:    List[str],  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    int,  lowerCamelCase						:    List[str],  lowerCamelCase						:    Any,  lowerCamelCase						:    int  ):

								'''simple docstring'''
								lowercase__    =			self.num_labels
								lowercase__    =			DebertaVaForTokenClassification(config=lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase,  attention_mask=lowerCamelCase,  token_type_ids=lowerCamelCase,  labels=lowerCamelCase  )
								self.parent.assertEqual(result.logits.shape,  (self.batch_size, self.seq_length, self.num_labels)  )




				def 				lowercase__   (     self						:    str,  lowerCamelCase						:    Optional[Any],  lowerCamelCase						:    Union[str, Any],  lowerCamelCase						:    Union[str, Any],  lowerCamelCase						:    str,  lowerCamelCase						:    List[Any],  lowerCamelCase						:    List[Any],  lowerCamelCase						:    Union[str, Any]  ):

								'''simple docstring'''
								lowercase__    =			DebertaVaForQuestionAnswering(config=lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(
								    lowerCamelCase,  attention_mask=lowerCamelCase,  token_type_ids=lowerCamelCase,  start_positions=lowerCamelCase,  end_positions=lowerCamelCase,  )
								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 				lowercase__   (     self						:    Optional[Any],  lowerCamelCase						:    Dict,  lowerCamelCase						:    Dict,  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    Optional[Any],  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    Dict,  lowerCamelCase						:    Union[str, Any]  ):

								'''simple docstring'''
								lowercase__    =			DebertaVaForMultipleChoice(config=lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			input_ids.unsqueeze(1  ).expand(-1,  self.num_choices,  -1  ).contiguous()
								lowercase__    =			token_type_ids.unsqueeze(1  ).expand(-1,  self.num_choices,  -1  ).contiguous()
								lowercase__    =			input_mask.unsqueeze(1  ).expand(-1,  self.num_choices,  -1  ).contiguous()
								lowercase__    =			model(
								    lowerCamelCase,  attention_mask=lowerCamelCase,  token_type_ids=lowerCamelCase,  labels=lowerCamelCase,  )
								self.parent.assertEqual(result.logits.shape,  (self.batch_size, self.num_choices)  )




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__    =			self.prepare_config_and_inputs()
								(
								    (
								    lowercase__
								) ,						(
								    lowercase__
								) ,						(
								    lowercase__
								) ,						(
								    lowercase__
								) ,						(
								    lowercase__
								) ,						(
								    lowercase__
								) ,						(
								    lowercase__
								) ,						
								)    =			config_and_inputs
								lowercase__    =			{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
								return config, inputs_dict



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

				"""simple docstring"""




				lowercase__											=       (
				    (
				        DebertaVaModel,
				        DebertaVaForMaskedLM,
				        DebertaVaForSequenceClassification,
				        DebertaVaForTokenClassification,
				        DebertaVaForQuestionAnswering,
				        DebertaVaForMultipleChoice,
				    )
				    if is_torch_available()
				    else ()
				)
				lowercase__											=       (
				    {
				        """feature-extraction""": DebertaVaModel,
				        """fill-mask""": DebertaVaForMaskedLM,
				        """question-answering""": DebertaVaForQuestionAnswering,
				        """text-classification""": DebertaVaForSequenceClassification,
				        """token-classification""": DebertaVaForTokenClassification,
				        """zero-shot""": DebertaVaForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)

				lowercase__											=       True
				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__    =			DebertaVaModelTester(self  )
								lowercase__    =			ConfigTester(self,  config_class=lowerCamelCase,  hidden_size=37  )




				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								self.config_tester.run_common_tests()




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_model(*lowerCamelCase  )




				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_for_sequence_classification(*lowerCamelCase  )




				def 				lowercase__   (     self						:    Any  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_for_masked_lm(*lowerCamelCase  )




				def 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_for_question_answering(*lowerCamelCase  )




				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_for_token_classification(*lowerCamelCase  )




				def 				lowercase__   (     self						:    Optional[Any]  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_for_multiple_choice(*lowerCamelCase  )




				@slow
				def 				lowercase__   (     self						:    str  ):

								'''simple docstring'''
								for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowercase__    =			DebertaVaModel.from_pretrained(lowerCamelCase  )
												self.assertIsNotNone(lowerCamelCase  )



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

				"""simple docstring"""




				@unittest.skip(reason='''Model not available yet'''  )
				def 				lowercase__   (     self						:    Union[str, Any]  ):

								'''simple docstring'''
								pass




				@slow
				def 				lowercase__   (     self						:    List[Any]  ):

								'''simple docstring'''
								lowercase__    =			DebertaVaModel.from_pretrained('''microsoft/deberta-v2-xlarge'''  )

								lowercase__    =			torch.tensor([[0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]]  )
								lowercase__    =			torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
								with torch.no_grad():
												lowercase__    =			model(lowerCamelCase,  attention_mask=lowerCamelCase  )[0]
								# compare the actual values for a slice.
								lowercase__    =			torch.tensor(
								    [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]]  )
								self.assertTrue(torch.allclose(output[:, 1:4, 1:4],  lowerCamelCase,  atol=1E-4  ),  F"""{output[:, 1:4, 1:4]}"""  )












import inspect
import unittest

from transformers import MobileNetVaConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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 MobileNetVaForImageClassification, MobileNetVaModel
							from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import MobileNetVaImageProcessor
class       _UpperCAmelCase					(       A__	):

				"""simple docstring"""




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__    =			self.config_class(**self.inputs_dict  )
								self.parent.assertTrue(hasattr(lowerCamelCase,  '''tf_padding'''  )  )
								self.parent.assertTrue(hasattr(lowerCamelCase,  '''depth_multiplier'''  )  )



class       _UpperCAmelCase					:

				"""simple docstring"""




				def __init__(     self						:    List[str],  lowerCamelCase						:    List[str],  lowerCamelCase						:    Optional[Any]=13,  lowerCamelCase						:    List[str]=3,  lowerCamelCase						:    List[str]=32,  lowerCamelCase						:    Union[str, Any]=0.25,  lowerCamelCase						:    int=8,  lowerCamelCase						:    Dict=True,  lowerCamelCase						:    Optional[int]=1_024,  lowerCamelCase						:    List[str]=32,  lowerCamelCase						:    Optional[int]="relu6",  lowerCamelCase						:    Optional[int]=0.1,  lowerCamelCase						:    Optional[Any]=0.02,  lowerCamelCase						:    List[Any]=True,  lowerCamelCase						:    Any=True,  lowerCamelCase						:    Dict=10,  lowerCamelCase						:    Optional[int]=None,  ):

								'''simple docstring'''
								lowercase__    =			parent
								lowercase__    =			batch_size
								lowercase__    =			num_channels
								lowercase__    =			image_size
								lowercase__    =			depth_multiplier
								lowercase__    =			min_depth
								lowercase__    =			tf_padding
								lowercase__    =			int(last_hidden_size * depth_multiplier  )
								lowercase__    =			output_stride
								lowercase__    =			hidden_act
								lowercase__    =			classifier_dropout_prob
								lowercase__    =			use_labels
								lowercase__    =			is_training
								lowercase__    =			num_labels
								lowercase__    =			initializer_range
								lowercase__    =			scope




				def 				lowercase__   (     self						:    Any  ):

								'''simple docstring'''
								lowercase__    =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

								lowercase__    =			self.get_config()

								return config, pixel_values, labels, pixel_labels




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								return MobileNetVaConfig(
								    num_channels=self.num_channels,  image_size=self.image_size,  depth_multiplier=self.depth_multiplier,  min_depth=self.min_depth,  tf_padding=self.tf_padding,  hidden_act=self.hidden_act,  classifier_dropout_prob=self.classifier_dropout_prob,  initializer_range=self.initializer_range,  )




				def 				lowercase__   (     self						:    List[str],  lowerCamelCase						:    List[str],  lowerCamelCase						:    Union[str, Any],  lowerCamelCase						:    Tuple,  lowerCamelCase						:    Tuple  ):

								'''simple docstring'''
								lowercase__    =			MobileNetVaModel(config=lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase  )
								self.parent.assertEqual(
								    result.last_hidden_state.shape,  (
								        self.batch_size,
								        self.last_hidden_size,
								        self.image_size // self.output_stride,
								        self.image_size // self.output_stride,
								    ),  )




				def 				lowercase__   (     self						:    str,  lowerCamelCase						:    str,  lowerCamelCase						:    List[str],  lowerCamelCase						:    List[Any],  lowerCamelCase						:    str  ):

								'''simple docstring'''
								lowercase__    =			self.num_labels
								lowercase__    =			MobileNetVaForImageClassification(lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase,  labels=lowerCamelCase  )
								self.parent.assertEqual(result.logits.shape,  (self.batch_size, self.num_labels)  )




				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								lowercase__    =			self.prepare_config_and_inputs()
								lowercase__ ,						lowercase__ ,						lowercase__ ,						lowercase__    =			config_and_inputs
								lowercase__    =			{'''pixel_values''': pixel_values}
								return config, inputs_dict



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

				"""simple docstring"""




				lowercase__											=       (MobileNetVaModel, MobileNetVaForImageClassification) if is_torch_available() else ()
				lowercase__											=       (
				    {"""feature-extraction""": MobileNetVaModel, """image-classification""": MobileNetVaForImageClassification}
				    if is_torch_available()
				    else {}
				)

				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__    =			MobileNetVaModelTester(self  )
								lowercase__    =			MobileNetVaConfigTester(self,  config_class=lowerCamelCase,  has_text_modality=lowerCamelCase  )




				def 				lowercase__   (     self						:    Any  ):

								'''simple docstring'''
								self.config_tester.run_common_tests()




				@unittest.skip(reason='''MobileNetV1 does not use inputs_embeds'''  )
				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								pass




				@unittest.skip(reason='''MobileNetV1 does not support input and output embeddings'''  )
				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								pass




				@unittest.skip(reason='''MobileNetV1 does not output attentions'''  )
				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								pass




				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()

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

												lowercase__    =			['''pixel_values''']
												self.assertListEqual(arg_names[:1],  lowerCamelCase  )




				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCamelCase  )




				def 				lowercase__   (     self						:    List[Any]  ):

								'''simple docstring'''
								def check_hidden_states_output(lowerCamelCase						:    str,  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    List[str]  ):
												lowercase__    =			model_class(lowerCamelCase  )
												model.to(lowerCamelCase  )
												model.eval()

												with torch.no_grad():
																lowercase__    =			model(**self._prepare_for_class(lowerCamelCase,  lowerCamelCase  )  )

												lowercase__    =			outputs.hidden_states

												lowercase__    =			26
												self.assertEqual(len(lowerCamelCase  ),  lowerCamelCase  )

								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
												lowercase__    =			True
												check_hidden_states_output(lowerCamelCase,  lowerCamelCase,  lowerCamelCase  )

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												lowercase__    =			True

												check_hidden_states_output(lowerCamelCase,  lowerCamelCase,  lowerCamelCase  )




				def 				lowercase__   (     self						:    Any  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*lowerCamelCase  )




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

								'''simple docstring'''
								for model_name in MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowercase__    =			MobileNetVaModel.from_pretrained(lowerCamelCase  )
												self.assertIsNotNone(lowerCamelCase  )






def   a			(						):






				'''simple docstring'''
				lowercase__    =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
				return image




@require_torch
@require_vision
class       _UpperCAmelCase					(       unittest.TestCase	):

				"""simple docstring"""




				@cached_property
				def 				lowercase__   (     self						:    str  ):

								'''simple docstring'''
								return (
								    MobileNetVaImageProcessor.from_pretrained('''google/mobilenet_v1_1.0_224'''  ) if is_vision_available() else None
								)




				@slow
				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			MobileNetVaForImageClassification.from_pretrained('''google/mobilenet_v1_1.0_224'''  ).to(lowerCamelCase  )

								lowercase__    =			self.default_image_processor
								lowercase__    =			prepare_img()
								lowercase__    =			image_processor(images=lowerCamelCase,  return_tensors='''pt'''  ).to(lowerCamelCase  )

								# forward pass
								with torch.no_grad():
												lowercase__    =			model(**lowerCamelCase  )

								# verify the logits
								lowercase__    =			torch.Size((1, 1_001)  )
								self.assertEqual(outputs.logits.shape,  lowerCamelCase  )

								lowercase__    =			torch.tensor([-4.1739, -1.1233, 3.1205]  ).to(lowerCamelCase  )

								self.assertTrue(torch.allclose(outputs.logits[0, :3],  lowerCamelCase,  atol=1E-4  )  )




