




'''simple docstring'''




from __future__ import annotations

import unittest

from transformers import AutoTokenizer, MBartConfig, is_tf_available
from transformers.testing_utils import require_sentencepiece, require_tf, require_tokenizers, slow
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import TFAutoModelForSeqaSeqLM, TFMBartForConditionalGeneration, TFMBartModel






@require_tf
class      UpperCAmelCase_     :


	"""simple docstring"""


	snake_case									=		MBartConfig
	snake_case									=		{}
	snake_case									=		'''gelu'''







	def __init__(						self						, UpperCAmelCase_						, UpperCAmelCase_=13						, UpperCAmelCase_=7						, UpperCAmelCase_=True						, UpperCAmelCase_=False						, UpperCAmelCase_=99						, UpperCAmelCase_=32						, UpperCAmelCase_=2						, UpperCAmelCase_=4						, UpperCAmelCase_=37						, UpperCAmelCase_=0.1						, UpperCAmelCase_=0.1						, UpperCAmelCase_=20						, UpperCAmelCase_=2						, UpperCAmelCase_=1						, UpperCAmelCase_=0						, ):
						snake_case_	=      parent
						snake_case_	=      batch_size
						snake_case_	=      seq_length
						snake_case_	=      is_training
						snake_case_	=      use_labels
						snake_case_	=      vocab_size
						snake_case_	=      hidden_size
						snake_case_	=      num_hidden_layers
						snake_case_	=      num_attention_heads
						snake_case_	=      intermediate_size
						snake_case_	=      hidden_dropout_prob
						snake_case_	=      attention_probs_dropout_prob
						snake_case_	=      max_position_embeddings
						snake_case_	=      eos_token_id
						snake_case_	=      pad_token_id
						snake_case_	=      bos_token_id







	def  _lowercase    (						self				):
						snake_case_	=      ids_tensor([self.batch_size, self.seq_length - 1]						, self.vocab_size				)
						snake_case_	=      tf.expand_dims(tf.constant([self.eos_token_id] * self.batch_size				)						, 1				)
						snake_case_	=      tf.concat([input_ids, eos_tensor]						, axis=1				)

						snake_case_	=      ids_tensor([self.batch_size, self.seq_length]						, self.vocab_size				)

						snake_case_	=      self.config_cls(
						    vocab_size=self.vocab_size						, d_model=self.hidden_size						, encoder_layers=self.num_hidden_layers						, decoder_layers=self.num_hidden_layers						, encoder_attention_heads=self.num_attention_heads						, decoder_attention_heads=self.num_attention_heads						, encoder_ffn_dim=self.intermediate_size						, decoder_ffn_dim=self.intermediate_size						, dropout=self.hidden_dropout_prob						, attention_dropout=self.attention_probs_dropout_prob						, max_position_embeddings=self.max_position_embeddings						, eos_token_ids=[2]						, bos_token_id=self.bos_token_id						, pad_token_id=self.pad_token_id						, decoder_start_token_id=self.pad_token_id						, **self.config_updates						, )
						snake_case_	=      prepare_mbart_inputs_dict(lowerCAmelCase_						, lowerCAmelCase_						, lowerCAmelCase_				)
						return config, inputs_dict







	def  _lowercase    (						self						, UpperCAmelCase_						, UpperCAmelCase_				):
						snake_case_	=      TFMBartModel(config=lowerCAmelCase_				).get_decoder()
						snake_case_	=      inputs_dict["input_ids"]

						snake_case_	=      input_ids[:1, :]
						snake_case_	=      inputs_dict["attention_mask"][:1, :]
						snake_case_	=      inputs_dict["head_mask"]
						snake_case_	=      1

						# first forward pass
						snake_case_	=      model(lowerCAmelCase_						, attention_mask=lowerCAmelCase_						, head_mask=lowerCAmelCase_						, use_cache=lowerCAmelCase_				)

						snake_case_	,					snake_case_	=      outputs.to_tuple()
						snake_case_	=      past_key_values[1]



def      __snake_case       (   lowercase   :							List[Any]			, lowercase   :							Tuple			, lowercase   :							Optional[Any]			, lowercase   :							Optional[int]=None			, lowercase   :							Tuple=None			, lowercase   :							Optional[int]=None			, lowercase   :							List[str]=None			, lowercase   :							Union[str, Any]=None			, ):




					if attention_mask is None:
										snake_case_	=      tf.cast(tf.math.not_equal(_SCREAMING_SNAKE_CASE			, config.pad_token_id  )			, tf.inta  )
					if decoder_attention_mask is None:
										snake_case_	=      tf.concat(
										    [
										        tf.ones(decoder_input_ids[:, :1].shape			, dtype=tf.inta  ),
										        tf.cast(tf.math.not_equal(decoder_input_ids[:, 1:]			, config.pad_token_id  )			, tf.inta  ),
										    ]			, axis=-1			, )
					if head_mask is None:
										snake_case_	=      tf.ones((config.encoder_layers, config.encoder_attention_heads)  )
					if decoder_head_mask is None:
										snake_case_	=      tf.ones((config.decoder_layers, config.decoder_attention_heads)  )
					if cross_attn_head_mask is None:
										snake_case_	=      tf.ones((config.decoder_layers, config.decoder_attention_heads)  )
					return {
					    "input_ids": input_ids,
					    "decoder_input_ids": decoder_input_ids,
					    "attention_mask": attention_mask,
					    "decoder_attention_mask": decoder_attention_mask,
					    "head_mask": head_mask,
					    "decoder_head_mask": decoder_head_mask,
					    "cross_attn_head_mask": cross_attn_head_mask,
					}






@require_tf
class      UpperCAmelCase_     (  a_       ,	a_       ,	unittest.TestCase     ):


	"""simple docstring"""


	snake_case									=		(TFMBartForConditionalGeneration, TFMBartModel) if is_tf_available() else ()
	snake_case									=		(TFMBartForConditionalGeneration,) if is_tf_available() else ()
	snake_case									=		(
	    {
	        '''conversational''': TFMBartForConditionalGeneration,
	        '''feature-extraction''': TFMBartModel,
	        '''summarization''': TFMBartForConditionalGeneration,
	        '''text2text-generation''': TFMBartForConditionalGeneration,
	        '''translation''': TFMBartForConditionalGeneration,
	    }
	    if is_tf_available()
	    else {}
	)
	snake_case									=		True
	snake_case									=		False
	snake_case									=		False







	def  _lowercase    (						self						, UpperCAmelCase_						, UpperCAmelCase_						, UpperCAmelCase_						, UpperCAmelCase_						, UpperCAmelCase_				):
						if pipeline_test_casse_name != "FeatureExtractionPipelineTests":
											# Exception encountered when calling layer '...'
											return True

						return False







	def  _lowercase    (						self				):
						snake_case_	=      TFMBartModelTester(self				)
						snake_case_	=      ConfigTester(self						, config_class=lowerCAmelCase_				)







	def  _lowercase    (						self				):
						self.config_tester.run_common_tests()







	def  _lowercase    (						self				):
						snake_case_	=      self.model_tester.prepare_config_and_inputs_for_common()
						self.model_tester.check_decoder_model_past_large_inputs(*lowerCAmelCase_				)






@require_sentencepiece
@require_tokenizers
@require_tf
class      UpperCAmelCase_     (  unittest.TestCase     ):


	"""simple docstring"""


	snake_case									=		[
	    ''' UN Chief Says There Is No Military Solution in Syria''',
	]
	snake_case									=		[
	    '''Şeful ONU declară că nu există o soluţie militară în Siria''',
	]
	snake_case									=		'''facebook/mbart-large-en-ro'''







	@cached_property
	def  _lowercase    (						self				):
						return AutoTokenizer.from_pretrained(self.model_name				)







	@cached_property
	def  _lowercase    (						self				):
						snake_case_	=      TFAutoModelForSeqaSeqLM.from_pretrained(self.model_name				)
						return model







	def  _lowercase    (						self						, **UpperCAmelCase_				):
						snake_case_	=      self.translate_src_text(**lowerCAmelCase_				)
						self.assertListEqual(self.expected_text						, lowerCAmelCase_				)







	def  _lowercase    (						self						, **UpperCAmelCase_				):
						snake_case_	=      self.tokenizer(self.src_text						, **lowerCAmelCase_						, return_tensors="tf"				)
						snake_case_	=      self.model.generate(
						    model_inputs.input_ids						, attention_mask=model_inputs.attention_mask						, num_beams=2				)
						snake_case_	=      self.tokenizer.batch_decode(lowerCAmelCase_						, skip_special_tokens=lowerCAmelCase_				)
						return generated_words







	@slow
	def  _lowercase    (						self				):
						self._assert_generated_batch_equal_expected()









'''simple docstring'''





import inspect
import unittest

from transformers import MobileViTConfig
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 MobileViTForImageClassification, MobileViTForSemanticSegmentation, MobileViTModel
					from transformers.models.mobilevit.modeling_mobilevit import MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
					from PIL import Image

					from transformers import MobileViTImageProcessor
class 						a__					(					a_   ):





			'''simple docstring'''

			def 					lowerCAmelCase     (  self							:			Tuple	)      ->		Optional[int]:
						__A=	self.config_class(**self.inputs_dict	)
						self.parent.assertTrue(hasattr(lowerCAmelCase_			,    'hidden_sizes'	)	)
						self.parent.assertTrue(hasattr(lowerCAmelCase_			,    'neck_hidden_sizes'	)	)
						self.parent.assertTrue(hasattr(lowerCAmelCase_			,    'num_attention_heads'	)	)


class 						a__					:





			'''simple docstring'''

			def __init__(  self							:			str			,    lowerCAmelCase_							:			str			,    lowerCAmelCase_							:			str=13			,    lowerCAmelCase_							:			Dict=32			,    lowerCAmelCase_							:			Tuple=2			,    lowerCAmelCase_							:			List[str]=3			,    lowerCAmelCase_							:			str=640			,    lowerCAmelCase_							:			str=4			,    lowerCAmelCase_							:			Dict="silu"			,    lowerCAmelCase_							:			List[str]=3			,    lowerCAmelCase_							:			str=32			,    lowerCAmelCase_							:			List[Any]=0.1			,    lowerCAmelCase_							:			str=0.1			,    lowerCAmelCase_							:			str=0.1			,    lowerCAmelCase_							:			str=0.02			,    lowerCAmelCase_							:			Optional[int]=True			,    lowerCAmelCase_							:			Optional[int]=True			,    lowerCAmelCase_							:			Any=10			,    lowerCAmelCase_							:			Dict=None			,    )      ->		Optional[Any]:
						__A=	parent
						__A=	batch_size
						__A=	image_size
						__A=	patch_size
						__A=	num_channels
						__A=	last_hidden_size
						__A=	num_attention_heads
						__A=	hidden_act
						__A=	conv_kernel_size
						__A=	output_stride
						__A=	hidden_dropout_prob
						__A=	attention_probs_dropout_prob
						__A=	classifier_dropout_prob
						__A=	use_labels
						__A=	is_training
						__A=	num_labels
						__A=	initializer_range
						__A=	scope
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		Dict:
						__A=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

						__A=	self.get_config()

						return config, pixel_values, labels, pixel_labels
			def 					lowerCAmelCase     (  self							:			List[Any]	)      ->		List[Any]:
						return MobileViTConfig(
						    image_size=self.image_size			,    patch_size=self.patch_size			,    num_channels=self.num_channels			,    num_attention_heads=self.num_attention_heads			,    hidden_act=self.hidden_act			,    conv_kernel_size=self.conv_kernel_size			,    output_stride=self.output_stride			,    hidden_dropout_prob=self.hidden_dropout_prob			,    attention_probs_dropout_prob=self.attention_probs_dropout_prob			,    classifier_dropout_prob=self.classifier_dropout_prob			,    initializer_range=self.initializer_range			,    )
			def 					lowerCAmelCase     (  self							:			Any			,    lowerCAmelCase_							:			List[Any]			,    lowerCAmelCase_							:			Any			,    lowerCAmelCase_							:			Tuple			,    lowerCAmelCase_							:			Optional[Any]	)      ->		Dict:
						__A=	MobileViTModel(config=lowerCAmelCase_	)
						model.to(lowerCAmelCase_	)
						model.eval()
						__A=	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 					lowerCAmelCase     (  self							:			List[str]			,    lowerCAmelCase_							:			List[str]			,    lowerCAmelCase_							:			Optional[int]			,    lowerCAmelCase_							:			List[Any]			,    lowerCAmelCase_							:			Any	)      ->		Optional[Any]:
						__A=	self.num_labels
						__A=	MobileViTForImageClassification(lowerCAmelCase_	)
						model.to(lowerCAmelCase_	)
						model.eval()
						__A=	model(lowerCAmelCase_			,    labels=lowerCAmelCase_	)
						self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.num_labels)	)
			def 					lowerCAmelCase     (  self							:			Optional[int]			,    lowerCAmelCase_							:			Optional[Any]			,    lowerCAmelCase_							:			Optional[Any]			,    lowerCAmelCase_							:			Optional[int]			,    lowerCAmelCase_							:			int	)      ->		int:
						__A=	self.num_labels
						__A=	MobileViTForSemanticSegmentation(lowerCAmelCase_	)
						model.to(lowerCAmelCase_	)
						model.eval()
						__A=	model(lowerCAmelCase_	)
						self.parent.assertEqual(
						    result.logits.shape			,    (
						        self.batch_size,
						        self.num_labels,
						        self.image_size // self.output_stride,
						        self.image_size // self.output_stride,
						    )			,    )
						__A=	model(lowerCAmelCase_			,    labels=lowerCAmelCase_	)
						self.parent.assertEqual(
						    result.logits.shape			,    (
						        self.batch_size,
						        self.num_labels,
						        self.image_size // self.output_stride,
						        self.image_size // self.output_stride,
						    )			,    )

			def 					lowerCAmelCase     (  self							:			Optional[int]	)      ->		Optional[int]:
						__A=	self.prepare_config_and_inputs()
						__A,	__A,	__A,	__A=	config_and_inputs
						__A=	{'pixel_values': pixel_values}
						return config, inputs_dict


@require_torch
class 						a__					(					a_      ,  a_      ,  unittest.TestCase   ):





			'''simple docstring'''

			A						:				Union[str, Any]					      =			(
			    (MobileViTModel, MobileViTForImageClassification, MobileViTForSemanticSegmentation)
			    if is_torch_available()
			    else ()
			)
			A						:				Any					      =			(
			    {
			        '''feature-extraction''': MobileViTModel,
			        '''image-classification''': MobileViTForImageClassification,
			        '''image-segmentation''': MobileViTForSemanticSegmentation,
			    }
			    if is_torch_available()
			    else {}
			)

			A						:				int					      =			False
			A						:				Dict					      =			False
			A						:				Dict					      =			False
			A						:				str					      =			False
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		Union[str, Any]:
						__A=	MobileViTModelTester(self	)
						__A=	MobileViTConfigTester(self			,    config_class=lowerCAmelCase_			,    has_text_modality=lowerCAmelCase_	)
			def 					lowerCAmelCase     (  self							:			Any	)      ->		str:
						self.config_tester.run_common_tests()
			@unittest.skip(reason='MobileViT does not use inputs_embeds'	)
			def 					lowerCAmelCase     (  self							:			int	)      ->		Any:
						pass
			@unittest.skip(reason='MobileViT does not support input and output embeddings'	)
			def 					lowerCAmelCase     (  self							:			List[str]	)      ->		List[Any]:
						pass
			@unittest.skip(reason='MobileViT does not output attentions'	)
			def 					lowerCAmelCase     (  self							:			List[str]	)      ->		Optional[int]:
						pass
			def 					lowerCAmelCase     (  self							:			Optional[int]	)      ->		Optional[Any]:
						__A,	__A=	self.model_tester.prepare_config_and_inputs_for_common()

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

									__A=	['pixel_values']
									self.assertListEqual(arg_names[:1]			,    lowerCAmelCase_	)
			@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'	)
			def 					lowerCAmelCase     (  self							:			str	)      ->		int:
						pass
			def 					lowerCAmelCase     (  self							:			str	)      ->		Any:
						__A=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*lowerCAmelCase_	)
			def 					lowerCAmelCase     (  self							:			Optional[Any]	)      ->		str:
						def check_hidden_states_output(lowerCAmelCase_							:			Optional[int]			,    lowerCAmelCase_							:			int			,    lowerCAmelCase_							:			List[str]	):
									__A=	model_class(lowerCAmelCase_	)
									model.to(lowerCAmelCase_	)
									model.eval()

									with torch.no_grad():
												__A=	model(**self._prepare_for_class(lowerCAmelCase_			,    lowerCAmelCase_	)	)

									__A=	outputs.hidden_states

									__A=	5
									self.assertEqual(len(lowerCAmelCase_	)			,    lowerCAmelCase_	)

									# MobileViT's feature maps are of shape (batch_size, num_channels, height, width)
									# with the width and height being successively divided by 2.
									__A=	2
									for i in range(len(lowerCAmelCase_	)	):
												self.assertListEqual(
												    list(hidden_states[i].shape[-2:]	)			,    [self.model_tester.image_size // divisor, self.model_tester.image_size // divisor]			,    )
												divisor *= 2

									self.assertEqual(self.model_tester.output_stride			,    divisor // 2	)

						__A,	__A=	self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									__A=	True
									check_hidden_states_output(lowerCAmelCase_			,    lowerCAmelCase_			,    lowerCAmelCase_	)

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

									check_hidden_states_output(lowerCAmelCase_			,    lowerCAmelCase_			,    lowerCAmelCase_	)
			def 					lowerCAmelCase     (  self							:			Tuple	)      ->		Optional[Any]:
						__A=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase_	)
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		Union[str, Any]:
						__A=	self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_semantic_segmentation(*lowerCAmelCase_	)

			@slow
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		Optional[Any]:
						for model_name in MOBILEVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									__A=	MobileViTModel.from_pretrained(lowerCAmelCase_	)
									self.assertIsNotNone(lowerCAmelCase_	)






def 						UpperCAmelCase__(				):






			"""simple docstring"""




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






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





			'''simple docstring'''

			@cached_property
			def 					lowerCAmelCase     (  self							:			Optional[Any]	)      ->		Tuple:
						return MobileViTImageProcessor.from_pretrained('apple/mobilevit-xx-small'	) if is_vision_available() else None
			@slow
			def 					lowerCAmelCase     (  self							:			int	)      ->		str:
						__A=	MobileViTForImageClassification.from_pretrained('apple/mobilevit-xx-small'	).to(lowerCAmelCase_	)

						__A=	self.default_image_processor
						__A=	prepare_img()
						__A=	image_processor(images=lowerCAmelCase_			,    return_tensors='pt'	).to(lowerCAmelCase_	)

						# forward pass
						with torch.no_grad():
									__A=	model(**lowerCAmelCase_	)

						# verify the logits
						__A=	torch.Size((1, 1_000)	)
						self.assertEqual(outputs.logits.shape			,    lowerCAmelCase_	)

						__A=	torch.tensor([-1.93_64, -1.23_27, -0.46_53]	).to(lowerCAmelCase_	)

						self.assertTrue(torch.allclose(outputs.logits[0, :3]			,    lowerCAmelCase_			,    atol=1E-4	)	)
			@slow
			def 					lowerCAmelCase     (  self							:			Union[str, Any]	)      ->		List[str]:
						__A=	MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small'	)
						__A=	model.to(lowerCAmelCase_	)

						__A=	MobileViTImageProcessor.from_pretrained('apple/deeplabv3-mobilevit-xx-small'	)

						__A=	prepare_img()
						__A=	image_processor(images=lowerCAmelCase_			,    return_tensors='pt'	).to(lowerCAmelCase_	)

						# forward pass
						with torch.no_grad():
									__A=	model(**lowerCAmelCase_	)
						__A=	outputs.logits

						# verify the logits
						__A=	torch.Size((1, 21, 32, 32)	)
						self.assertEqual(logits.shape			,    lowerCAmelCase_	)

						__A=	torch.tensor(
						    [
						        [[6.97_13, 6.97_86, 7.24_22], [7.28_93, 7.28_25, 7.44_46], [7.65_80, 7.87_97, 7.94_20]],
						        [[-10.68_69, -10.32_50, -10.34_71], [-10.42_28, -9.98_68, -9.71_32], [-11.04_05, -11.02_21, -10.73_18]],
						        [[-3.30_89, -2.85_39, -2.67_40], [-3.27_06, -2.56_21, -2.51_08], [-3.25_34, -2.66_15, -2.66_51]],
						    ]			,    device=lowerCAmelCase_			,    )

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

			@slow
			def 					lowerCAmelCase     (  self							:			Tuple	)      ->		str:
						__A=	MobileViTForSemanticSegmentation.from_pretrained('apple/deeplabv3-mobilevit-xx-small'	)
						__A=	model.to(lowerCAmelCase_	)

						__A=	MobileViTImageProcessor.from_pretrained('apple/deeplabv3-mobilevit-xx-small'	)

						__A=	prepare_img()
						__A=	image_processor(images=lowerCAmelCase_			,    return_tensors='pt'	).to(lowerCAmelCase_	)

						# forward pass
						with torch.no_grad():
									__A=	model(**lowerCAmelCase_	)

						__A=	outputs.logits.detach().cpu()

						__A=	image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase_			,    target_sizes=[(50, 60)]	)
						__A=	torch.Size((50, 60)	)
						self.assertEqual(segmentation[0].shape			,    lowerCAmelCase_	)

						__A=	image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase_	)
						__A=	torch.Size((32, 32)	)
						self.assertEqual(segmentation[0].shape			,    lowerCAmelCase_	)



