



"""simple docstring"""







import unittest

from transformers import MarkupLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device
from transformers.utils import cached_property

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 (
							    MarkupLMForQuestionAnswering,
							    MarkupLMForSequenceClassification,
							    MarkupLMForTokenClassification,
							    MarkupLMModel,
							)

# TODO check dependencies
from transformers import MarkupLMFeatureExtractor, MarkupLMProcessor, MarkupLMTokenizer






class   UpperCAmelCase__		:



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






									'''simple docstring'''

									A    =       parent
									A    =       batch_size
									A    =       seq_length
									A    =       is_training
									A    =       use_input_mask
									A    =       use_token_type_ids
									A    =       use_labels
									A    =       vocab_size
									A    =       hidden_size
									A    =       num_hidden_layers
									A    =       num_attention_heads
									A    =       intermediate_size
									A    =       hidden_act
									A    =       hidden_dropout_prob
									A    =       attention_probs_dropout_prob
									A    =       max_position_embeddings
									A    =       type_vocab_size
									A    =       type_sequence_label_size
									A    =       initializer_range
									A    =       num_labels
									A    =       scope
									A    =       max_xpath_tag_unit_embeddings
									A    =       max_xpath_subs_unit_embeddings
									A    =       tag_pad_id
									A    =       subs_pad_id
									A    =       max_depth



		def        A_		(			self	:     Optional[int]					)      ->    int:






									'''simple docstring'''

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

									A    =       ids_tensor(
									    [self.batch_size, self.seq_length, self.max_depth]   ,				self.max_xpath_tag_unit_embeddings					)

									A    =       ids_tensor(
									    [self.batch_size, self.seq_length, self.max_depth]   ,				self.max_xpath_subs_unit_embeddings					)

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

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

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

									A    =       self.get_config()

									return (
									    config,
									    input_ids,
									    xpath_tags_seq,
									    xpath_subs_seq,
									    token_type_ids,
									    input_mask,
									    sequence_labels,
									    token_labels,
									)



		def        A_		(			self	:     Tuple					)      ->    Dict:






									'''simple docstring'''

									return MarkupLMConfig(
									    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   ,				max_xpath_tag_unit_embeddings=self.max_xpath_tag_unit_embeddings   ,				max_xpath_subs_unit_embeddings=self.max_xpath_subs_unit_embeddings   ,				tag_pad_id=self.tag_pad_id   ,				subs_pad_id=self.subs_pad_id   ,				max_depth=self.max_depth   ,				)



		def        A_		(			self	:     Tuple   ,				snake_case	:     Any   ,				snake_case	:     Optional[Any]   ,				snake_case	:     Tuple   ,				snake_case	:     List[str]   ,				snake_case	:     Optional[Any]   ,				snake_case	:     List[str]   ,				snake_case	:     List[Any]   ,				snake_case	:     Union[str, Any]   ,				)      ->    Dict:






									'''simple docstring'''

									A    =       MarkupLMModel(config=snake_case					)
									model.to(snake_case					)
									model.eval()
									print('Configs:'   ,				model.config.tag_pad_id   ,				model.config.subs_pad_id					)
									A    =       model(snake_case   ,				attention_mask=snake_case   ,				token_type_ids=snake_case					)
									A    =       model(snake_case   ,				token_type_ids=snake_case					)
									A    =       model(snake_case					)
									self.parent.assertEqual(result.last_hidden_state.shape   ,				(self.batch_size, self.seq_length, self.hidden_size)					)
									self.parent.assertEqual(result.pooler_output.shape   ,				(self.batch_size, self.hidden_size)					)



		def        A_		(			self	:     List[Any]   ,				snake_case	:     List[Any]   ,				snake_case	:     Optional[int]   ,				snake_case	:     str   ,				snake_case	:     str   ,				snake_case	:     Dict   ,				snake_case	:     int   ,				snake_case	:     str   ,				snake_case	:     Tuple   ,				)      ->    List[str]:






									'''simple docstring'''

									A    =       self.num_labels
									A    =       MarkupLMForSequenceClassification(snake_case					)
									model.to(snake_case					)
									model.eval()
									A    =       model(
									    snake_case   ,				xpath_tags_seq=snake_case   ,				xpath_subs_seq=snake_case   ,				attention_mask=snake_case   ,				token_type_ids=snake_case   ,				labels=snake_case   ,				)
									self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.num_labels)					)



		def        A_		(			self	:     Dict   ,				snake_case	:     Tuple   ,				snake_case	:     str   ,				snake_case	:     int   ,				snake_case	:     Optional[int]   ,				snake_case	:     Optional[int]   ,				snake_case	:     int   ,				snake_case	:     Union[str, Any]   ,				snake_case	:     Optional[int]   ,				)      ->    Any:






									'''simple docstring'''

									A    =       self.num_labels
									A    =       MarkupLMForTokenClassification(config=snake_case					)
									model.to(snake_case					)
									model.eval()
									A    =       model(
									    snake_case   ,				xpath_tags_seq=snake_case   ,				xpath_subs_seq=snake_case   ,				attention_mask=snake_case   ,				token_type_ids=snake_case   ,				labels=snake_case   ,				)
									self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.seq_length, self.num_labels)					)



		def        A_		(			self	:     str   ,				snake_case	:     Optional[Any]   ,				snake_case	:     Dict   ,				snake_case	:     str   ,				snake_case	:     str   ,				snake_case	:     Tuple   ,				snake_case	:     Tuple   ,				snake_case	:     List[Any]   ,				snake_case	:     int   ,				)      ->    List[Any]:






									'''simple docstring'''

									A    =       MarkupLMForQuestionAnswering(config=snake_case					)
									model.to(snake_case					)
									model.eval()
									A    =       model(
									    snake_case   ,				xpath_tags_seq=snake_case   ,				xpath_subs_seq=snake_case   ,				attention_mask=snake_case   ,				token_type_ids=snake_case   ,				start_positions=snake_case   ,				end_positions=snake_case   ,				)
									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					)      ->    str:






									'''simple docstring'''

									A    =       self.prepare_config_and_inputs()
									(
									    (
									    A
									)   ,	(
									    A
									)   ,	(
									    A
									)   ,	(
									    A
									)   ,	(
									    A
									)   ,	(
									    A
									)   ,	(
									    A
									)   ,	(
									    A
									)   ,	
									)    =       config_and_inputs
									A    =       {
									    'input_ids': input_ids,
									    'xpath_tags_seq': xpath_tags_seq,
									    'xpath_subs_seq': xpath_subs_seq,
									    'token_type_ids': token_type_ids,
									    'attention_mask': input_mask,
									}
									return config, inputs_dict






@require_torch
class   UpperCAmelCase__		(   UpperCamelCase ,UpperCamelCase ,unittest.TestCase  ):
		lowerCAmelCase_							:						int							=  (
		    (
		        MarkupLMModel,
		        MarkupLMForSequenceClassification,
		        MarkupLMForTokenClassification,
		        MarkupLMForQuestionAnswering,
		    )
		    if is_torch_available()
		    else None
		)
		lowerCAmelCase_							:						Tuple							=  (
		    {
		        """feature-extraction""": MarkupLMModel,
		        """question-answering""": MarkupLMForQuestionAnswering,
		        """text-classification""": MarkupLMForSequenceClassification,
		        """token-classification""": MarkupLMForTokenClassification,
		        """zero-shot""": MarkupLMForSequenceClassification,
		    }
		    if is_torch_available()
		    else {}
		)



		def        A_		(			self	:     Union[str, Any]   ,				snake_case	:     List[str]   ,				snake_case	:     List[str]   ,				snake_case	:     str   ,				snake_case	:     Tuple   ,				snake_case	:     Tuple					)      ->    Optional[Any]:






									'''simple docstring'''

									return True



		def        A_		(			self	:     Dict					)      ->    Dict:






									'''simple docstring'''

									A    =       MarkupLMModelTester(self					)
									A    =       ConfigTester(self   ,				config_class=snake_case   ,				hidden_size=37					)



		def        A_		(			self	:     Union[str, Any]					)      ->    List[str]:






									'''simple docstring'''

									self.config_tester.run_common_tests()



		def        A_		(			self	:     Dict					)      ->    Optional[Any]:






									'''simple docstring'''

									A    =       self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*snake_case					)



		def        A_		(			self	:     Optional[int]					)      ->    Union[str, Any]:






									'''simple docstring'''

									A    =       self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_sequence_classification(*snake_case					)



		def        A_		(			self	:     Dict					)      ->    Any:






									'''simple docstring'''

									A    =       self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_token_classification(*snake_case					)



		def        A_		(			self	:     Dict					)      ->    List[str]:






									'''simple docstring'''

									A    =       self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_question_answering(*snake_case					)



def 	lowerCAmelCase__      (  )			->				Union[str, Any]:
							A    =       '\n    <!DOCTYPE html>\n    <html>\n    <head>\n    <title>Page Title</title>\n    </head>\n    <body>\n\n    <h1>This is a Heading</h1>\n    <p>This is a paragraph.</p>\n\n    </body>\n    </html>\n    '

							return html_string






@require_torch
class   UpperCAmelCase__		(   unittest.TestCase  ):



		@cached_property
		def        A_		(			self	:     Optional[int]					)      ->    Optional[int]:






									'''simple docstring'''

									A    =       MarkupLMFeatureExtractor()
									A    =       MarkupLMTokenizer.from_pretrained('microsoft/markuplm-base'					)

									return MarkupLMProcessor(snake_case   ,				snake_case					)



		@slow
		def        A_		(			self	:     List[str]					)      ->    Dict:






									'''simple docstring'''

									A    =       MarkupLMModel.from_pretrained('microsoft/markuplm-base'					).to(snake_case					)

									A    =       self.default_processor

									A    =       processor(prepare_html_string()   ,				return_tensors='pt'					)
									A    =       inputs.to(snake_case					)

									# forward pass
									with torch.no_grad():
																A    =       model(**snake_case					)

									# verify the last hidden states
									A    =       torch.Size([1, 14, 768]					)
									self.assertEqual(outputs.last_hidden_state.shape   ,				snake_case					)

									A    =       torch.tensor(
									    [[0.0675, -0.0052, 0.5001], [-0.2281, 0.0802, 0.2192], [-0.0583, -0.3311, 0.1185]]					).to(snake_case					)

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








"""simple docstring"""







import inspect
import unittest

from transformers import ResNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
							import jax
							import jax.numpy as jnp

							from transformers.models.resnet.modeling_flax_resnet import FlaxResNetForImageClassification, FlaxResNetModel

if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor






class   UpperCAmelCase__		(   unittest.TestCase  ):



		def __init__(			self	:     Dict   ,				snake_case	:     Dict   ,				snake_case	:     Optional[Any]=3   ,				snake_case	:     Union[str, Any]=32   ,				snake_case	:     int=3   ,				snake_case	:     Any=10   ,				snake_case	:     int=[10, 20, 30, 40]   ,				snake_case	:     List[Any]=[1, 1, 2, 1]   ,				snake_case	:     List[str]=True   ,				snake_case	:     Any=True   ,				snake_case	:     str="relu"   ,				snake_case	:     List[str]=3   ,				snake_case	:     List[str]=None   ,				)      ->    int:






									'''simple docstring'''

									A    =       parent
									A    =       batch_size
									A    =       image_size
									A    =       num_channels
									A    =       embeddings_size
									A    =       hidden_sizes
									A    =       depths
									A    =       is_training
									A    =       use_labels
									A    =       hidden_act
									A    =       num_labels
									A    =       scope
									A    =       len(snake_case					)



		def        A_		(			self	:     Optional[int]					)      ->    Any:






									'''simple docstring'''

									A    =       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

									A    =       self.get_config()

									return config, pixel_values



		def        A_		(			self	:     int					)      ->    List[Any]:






									'''simple docstring'''

									return ResNetConfig(
									    num_channels=self.num_channels   ,				embeddings_size=self.embeddings_size   ,				hidden_sizes=self.hidden_sizes   ,				depths=self.depths   ,				hidden_act=self.hidden_act   ,				num_labels=self.num_labels   ,				image_size=self.image_size   ,				)



		def        A_		(			self	:     Optional[Any]   ,				snake_case	:     str   ,				snake_case	:     Any					)      ->    int:






									'''simple docstring'''

									A    =       FlaxResNetModel(config=snake_case					)
									A    =       model(snake_case					)

									# Output shape (b, c, h, w)
									self.parent.assertEqual(
									    result.last_hidden_state.shape   ,				(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)   ,				)



		def        A_		(			self	:     Dict   ,				snake_case	:     Tuple   ,				snake_case	:     Optional[Any]					)      ->    Tuple:






									'''simple docstring'''

									A    =       self.num_labels
									A    =       FlaxResNetForImageClassification(config=snake_case					)
									A    =       model(snake_case					)
									self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.num_labels)					)



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






									'''simple docstring'''

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






@require_flax
class   UpperCAmelCase__		(   UpperCamelCase ,unittest.TestCase  ):
		lowerCAmelCase_							:						List[str]							=  (FlaxResNetModel, FlaxResNetForImageClassification) if is_flax_available() else ()

		lowerCAmelCase_							:						Tuple							=  False
		lowerCAmelCase_							:						List[str]							=  False
		lowerCAmelCase_							:						List[str]							=  False



		def        A_		(			self	:     Optional[Any]					)      ->    None:






									'''simple docstring'''

									A    =       FlaxResNetModelTester(self					)
									A    =       ConfigTester(self   ,				config_class=snake_case   ,				has_text_modality=snake_case					)



		def        A_		(			self	:     List[str]					)      ->    Dict:






									'''simple docstring'''

									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	:     Dict					)      ->    List[Any]:






									'''simple docstring'''

									return



		def        A_		(			self	:     str					)      ->    List[str]:






									'''simple docstring'''

									A    =       self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_model(*snake_case					)



		def        A_		(			self	:     Optional[int]					)      ->    List[str]:






									'''simple docstring'''

									A    =       self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_for_image_classification(*snake_case					)



		@unittest.skip(reason='ResNet does not use inputs_embeds'					)
		def        A_		(			self	:     Tuple					)      ->    str:






									'''simple docstring'''

									pass



		@unittest.skip(reason='ResNet does not support input and output embeddings'					)
		def        A_		(			self	:     Tuple					)      ->    Any:






									'''simple docstring'''

									pass



		def        A_		(			self	:     Optional[Any]					)      ->    int:






									'''simple docstring'''

									A   ,	A    =       self.model_tester.prepare_config_and_inputs_for_common()

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

																A    =       ['pixel_values']
																self.assertListEqual(arg_names[:1]   ,				snake_case					)



		def        A_		(			self	:     Any					)      ->    Tuple:






									'''simple docstring'''

									def check_hidden_states_output(snake_case	:     Tuple   ,				snake_case	:     Union[str, Any]   ,				snake_case	:     Optional[int]					):
																A    =       model_class(snake_case					)

																A    =       model(**self._prepare_for_class(snake_case   ,				snake_case					)					)

																A    =       outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																A    =       self.model_tester.num_stages
																self.assertEqual(len(snake_case					)   ,				expected_num_stages + 1					)



		@unittest.skip(reason='ResNet does not use feedforward chunking'					)
		def        A_		(			self	:     Optional[int]					)      ->    List[Any]:






									'''simple docstring'''

									pass



		def        A_		(			self	:     Union[str, Any]					)      ->    Union[str, Any]:






									'''simple docstring'''

									A   ,	A    =       self.model_tester.prepare_config_and_inputs_for_common()

									for model_class in self.all_model_classes:
																with self.subTest(model_class.__name__					):
																							A    =       self._prepare_for_class(snake_case   ,				snake_case					)
																							A    =       model_class(snake_case					)

																							@jax.jit
																							def model_jitted(snake_case	:     Any   ,				**snake_case	:     int					):
																														return model(pixel_values=snake_case   ,				**snake_case					)

																							with self.subTest('JIT Enabled'					):
																														A    =       model_jitted(**snake_case					).to_tuple()

																							with self.subTest('JIT Disabled'					):
																														with jax.disable_jit():
																																					A    =       model_jitted(**snake_case					).to_tuple()

																							self.assertEqual(len(snake_case					)   ,				len(snake_case					)					)
																							for jitted_output, output in zip(snake_case   ,				snake_case					):
																														self.assertEqual(jitted_output.shape   ,				output.shape					)



def 	lowerCAmelCase__      (  )			->				int:
							A    =       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'      )
							return image






@require_flax
class   UpperCAmelCase__		(   unittest.TestCase  ):



		@cached_property
		def        A_		(			self	:     Union[str, Any]					)      ->    int:






									'''simple docstring'''

									return AutoImageProcessor.from_pretrained('microsoft/resnet-50'					) if is_vision_available() else None



		@slow
		def        A_		(			self	:     Any					)      ->    Tuple:






									'''simple docstring'''

									A    =       FlaxResNetForImageClassification.from_pretrained('microsoft/resnet-50'					)

									A    =       self.default_image_processor
									A    =       prepare_img()
									A    =       image_processor(images=snake_case   ,				return_tensors='np'					)

									A    =       model(**snake_case					)

									# verify the logits
									A    =       (1, 1_000)
									self.assertEqual(outputs.logits.shape   ,				snake_case					)

									A    =       jnp.array([-11.1069, -9.7877, -8.3777]					)

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



