
'''simple docstring'''





import collections
import inspect
import unittest

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

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


if is_torch_available():
 import torch
 from torch import nn

 from transformers import NatBackbone, NatForImageClassification, NatModel
 from transformers.models.nat.modeling_nat import NAT_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor


class 			UpperCamelCase__	:






 def __init__(      self	:Tuple						,					_A	:Union[str, Any]						,					_A	:Dict=13						,					_A	:Union[str, Any]=64						,					_A	:List[Any]=4						,					_A	:Union[str, Any]=3						,					_A	:Tuple=16						,					_A	:List[str]=[1, 2, 1]						,					_A	:Union[str, Any]=[2, 4, 8]						,					_A	:Tuple=3						,					_A	:Any=2.0						,					_A	:int=True						,					_A	:int=0.0						,					_A	:int=0.0						,					_A	:int=0.1						,					_A	:List[str]="gelu"						,					_A	:Optional[Any]=True						,					_A	:Any=0.02						,					_A	:List[str]=1E-5						,					_A	:List[Any]=True						,					_A	:Optional[int]=None						,					_A	:Optional[Any]=True						,					_A	:Dict=10						,					_A	:List[str]=["stage1", "stage2"]						,					_A	:Union[str, Any]=[1, 2]						,					)					->      Optional[Any]:







       '''simple docstring'''



       __A													=      parent
       __A													=      batch_size
       __A													=      image_size
       __A													=      patch_size
       __A													=      num_channels
       __A													=      embed_dim
       __A													=      depths
       __A													=      num_heads
       __A													=      kernel_size
       __A													=      mlp_ratio
       __A													=      qkv_bias
       __A													=      hidden_dropout_prob
       __A													=      attention_probs_dropout_prob
       __A													=      drop_path_rate
       __A													=      hidden_act
       __A													=      patch_norm
       __A													=      layer_norm_eps
       __A													=      initializer_range
       __A													=      is_training
       __A													=      scope
       __A													=      use_labels
       __A													=      num_labels
       __A													=      out_features
       __A													=      out_indices






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







       '''simple docstring'''



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

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

       __A													=      self.get_config()

       return config, pixel_values, labels






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







       '''simple docstring'''



       return NatConfig(
           num_labels=self.num_labels						,					image_size=self.image_size						,					patch_size=self.patch_size						,					num_channels=self.num_channels						,					embed_dim=self.embed_dim						,					depths=self.depths						,					num_heads=self.num_heads						,					kernel_size=self.kernel_size						,					mlp_ratio=self.mlp_ratio						,					qkv_bias=self.qkv_bias						,					hidden_dropout_prob=self.hidden_dropout_prob						,					attention_probs_dropout_prob=self.attention_probs_dropout_prob						,					drop_path_rate=self.drop_path_rate						,					hidden_act=self.hidden_act						,					patch_norm=self.patch_norm						,					layer_norm_eps=self.layer_norm_eps						,					initializer_range=self.initializer_range						,					out_features=self.out_features						,					out_indices=self.out_indices						,					)






 def 						lowercase_    (      self	:Tuple						,					_A	:Dict						,					_A	:Dict						,					_A	:Dict      )					->      str:







       '''simple docstring'''



       __A													=      NatModel(config=_A      )
       model.to(_A      )
       model.eval()
       __A													=      model(_A      )

       __A													=      __A													=      (config.image_size // config.patch_size) // (2 ** (len(config.depths      ) - 1))
       __A													=      int(config.embed_dim * 2 ** (len(config.depths      ) - 1)      )

       self.parent.assertEqual(
           result.last_hidden_state.shape						,					(self.batch_size, expected_height, expected_width, expected_dim)      )






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







       '''simple docstring'''



       __A													=      NatForImageClassification(_A      )
       model.to(_A      )
       model.eval()
       __A													=      model(_A						,					labels=_A      )
       self.parent.assertEqual(result.logits.shape						,					(self.batch_size, self.num_labels)      )

       # test greyscale images
       __A													=      1
       __A													=      NatForImageClassification(_A      )
       model.to(_A      )
       model.eval()

       __A													=      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
       __A													=      model(_A      )
       self.parent.assertEqual(result.logits.shape						,					(self.batch_size, self.num_labels)      )






 def 						lowercase_    (      self	:Optional[Any]						,					_A	:int						,					_A	:str						,					_A	:List[Any]      )					->      int:







       '''simple docstring'''



       __A													=      NatBackbone(config=_A      )
       model.to(_A      )
       model.eval()
       __A													=      model(_A      )

       # verify hidden states
       self.parent.assertEqual(len(result.feature_maps      )						,					len(config.out_features      )      )
       self.parent.assertListEqual(list(result.feature_maps[0].shape      )						,					[self.batch_size, model.channels[0], 16, 16]      )

       # verify channels
       self.parent.assertEqual(len(model.channels      )						,					len(config.out_features      )      )

       # verify backbone works with out_features=None
       __A													=      None
       __A													=      NatBackbone(config=_A      )
       model.to(_A      )
       model.eval()
       __A													=      model(_A      )

       # verify feature maps
       self.parent.assertEqual(len(result.feature_maps      )						,					1      )
       self.parent.assertListEqual(list(result.feature_maps[0].shape      )						,					[self.batch_size, model.channels[-1], 4, 4]      )

       # verify channels
       self.parent.assertEqual(len(model.channels      )						,					1      )






 def 						lowercase_    (      self	:str      )					->      Tuple:







       '''simple docstring'''



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


@require_natten
@require_torch
class 			UpperCamelCase__	(     SCREAMING_SNAKE_CASE   ,  SCREAMING_SNAKE_CASE   ,  unittest.TestCase):
 UpperCAmelCase__     :     List[str]    					=       (
     (
         NatModel,
         NatForImageClassification,
         NatBackbone,
     )
     if is_torch_available()
     else ()
 )
 UpperCAmelCase__     :     int    					=       (
     {'feature-extraction': NatModel, 'image-classification': NatForImageClassification}
     if is_torch_available()
     else {}
 )
 UpperCAmelCase__     :     Dict    					=       False

 UpperCAmelCase__     :     int    					=       False
 UpperCAmelCase__     :     str    					=       False
 UpperCAmelCase__     :     List[str]    					=       False
 UpperCAmelCase__     :     List[str]    					=       False






 def 						lowercase_    (      self	:Optional[Any]      )					->      Tuple:







       '''simple docstring'''



       __A													=      NatModelTester(self      )
       __A													=      ConfigTester(self						,					config_class=_A						,					embed_dim=37      )






 def 						lowercase_    (      self	:Any      )					->      Any:







       '''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 						lowercase_    (      self	:Dict      )					->      Optional[int]:







       '''simple docstring'''



       return






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







       '''simple docstring'''



       __A													=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_A      )






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







       '''simple docstring'''



       __A													=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_A      )






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







       '''simple docstring'''



       __A													=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*_A      )






 @unittest.skip(reason='Nat does not use inputs_embeds'      )
 def 						lowercase_    (      self	:int      )					->      Union[str, Any]:







       '''simple docstring'''



       pass






 @unittest.skip(reason='Nat does not use feedforward chunking'      )
 def 						lowercase_    (      self	:Union[str, Any]      )					->      str:







       '''simple docstring'''



       pass






 def 						lowercase_    (      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(_A      )
             self.assertIsInstance(model.get_input_embeddings()						,					(nn.Module)      )
             __A													=      model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(_A						,					nn.Linear      )      )






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







       '''simple docstring'''



       __A						,   __A													=      self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             __A													=      model_class(_A      )
             __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]						,					_A      )






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







       '''simple docstring'''



       self.skipTest('Nat\'s attention operation is handled entirely by NATTEN.'      )






 def 						lowercase_    (      self	:Tuple						,					_A	:Tuple						,					_A	:Dict						,					_A	:Any						,					_A	:List[Any]      )					->      Dict:







       '''simple docstring'''



       __A													=      model_class(_A      )
       model.to(_A      )
       model.eval()

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

       __A													=      outputs.hidden_states

       __A													=      getattr(
           self.model_tester						,					'expected_num_hidden_layers'						,					len(self.model_tester.depths      ) + 1      )
       self.assertEqual(len(_A      )						,					_A      )

       # Nat has a different seq_length
       __A													=      (
           config.patch_size
           if isinstance(config.patch_size						,					collections.abc.Iterable      )
           else (config.patch_size, config.patch_size)
       )

       __A													=      image_size[0] // patch_size[0]
       __A													=      image_size[1] // patch_size[1]

       self.assertListEqual(
           list(hidden_states[0].shape[-3:]      )						,					[height, width, self.model_tester.embed_dim]						,					)

       if model_class.__name__ != "NatBackbone":
             __A													=      outputs.reshaped_hidden_states
             self.assertEqual(len(_A      )						,					_A      )

             __A						,   __A						,   __A						,   __A													=      reshaped_hidden_states[0].shape
             __A													=      (
                 reshaped_hidden_states[0].view(_A						,					_A						,					_A						,					_A      ).permute(0						,					2						,					3						,					1      )
             )
             self.assertListEqual(
                 list(reshaped_hidden_states.shape[-3:]      )						,					[height, width, self.model_tester.embed_dim]						,					)






 def 						lowercase_    (      self	:Tuple      )					->      Dict:







       '''simple docstring'''



       __A						,   __A													=      self.model_tester.prepare_config_and_inputs_for_common()

       __A													=      (
           self.model_tester.image_size
           if isinstance(self.model_tester.image_size						,					collections.abc.Iterable      )
           else (self.model_tester.image_size, self.model_tester.image_size)
       )

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

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

             self.check_hidden_states_output(_A						,					_A						,					_A						,					_A      )






 @slow
 def 						lowercase_    (      self	:Tuple      )					->      List[str]:







       '''simple docstring'''



       for model_name in NAT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             __A													=      NatModel.from_pretrained(_A      )
             self.assertIsNotNone(_A      )






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







       '''simple docstring'''



       __A						,   __A													=      self.model_tester.prepare_config_and_inputs_for_common()

       __A													=      _config_zero_init(_A      )
       for model_class in self.all_model_classes:
             __A													=      model_class(config=_A      )
             for name, param in model.named_parameters():
                   if "embeddings" not in name and param.requires_grad:
                         self.assertIn(
                             ((param.data.mean() * 1E9).round() / 1E9).item()						,					[0.0, 1.0]						,					msg=F'Parameter {name} of model {model_class} seems not properly initialized'						,					)


@require_natten
@require_vision
@require_torch
class 			UpperCamelCase__	(     unittest.TestCase):






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







       '''simple docstring'''



       return AutoImageProcessor.from_pretrained('shi-labs/nat-mini-in1k-224'      ) if is_vision_available() else None






 @slow
 def 						lowercase_    (      self	:str      )					->      Tuple:







       '''simple docstring'''



       __A													=      NatForImageClassification.from_pretrained('shi-labs/nat-mini-in1k-224'      ).to(_A      )
       __A													=      self.default_image_processor

       __A													=      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'      )
       __A													=      image_processor(images=_A						,					return_tensors='pt'      ).to(_A      )

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

       # verify the logits
       __A													=      torch.Size((1, 1_000)      )
       self.assertEqual(outputs.logits.shape						,					_A      )
       __A													=      torch.tensor([0.3_805, -0.8_676, -0.3_912]      ).to(_A      )
       self.assertTrue(torch.allclose(outputs.logits[0, :3]						,					_A						,					atol=1E-4      )      )


@require_torch
@require_natten
class 			UpperCamelCase__	(     unittest.TestCase   ,  SCREAMING_SNAKE_CASE):
 UpperCAmelCase__     :     Any    					=       (NatBackbone,) if is_torch_available() else ()
 UpperCAmelCase__     :     Dict    					=       NatConfig






 def 						lowercase_    (      self	:Tuple      )					->      Optional[Any]:







       '''simple docstring'''



       __A													=      NatModelTester(self      )








'''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	:str						,					_A	:Any						,					_A	:Union[str, Any]=13						,					_A	:List[Any]=7						,					_A	:int=True						,					_A	:Union[str, Any]=True						,					_A	:List[Any]=True						,					_A	:Dict=True						,					_A	:int=99						,					_A	:Union[str, Any]=32						,					_A	:int=5						,					_A	:List[str]=4						,					_A	:Optional[int]=37						,					_A	:List[str]="gelu"						,					_A	:Any=0.1						,					_A	:int=0.1						,					_A	:List[str]=512						,					_A	:Optional[Any]=16						,					_A	:Optional[Any]=2						,					_A	:List[str]=0.02						,					_A	:Any=3						,					_A	:Tuple=None						,					_A	:str=20						,					_A	:List[Any]=30						,					_A	:Dict=2						,					_A	:Union[str, Any]=2						,					_A	:int=10						,					)					->      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 						lowercase_    (      self	:Tuple      )					->      Optional[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 						lowercase_    (      self	:List[Any]      )					->      int:







       '''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 						lowercase_    (      self	:Union[str, Any]						,					_A	:List[str]						,					_A	:str						,					_A	:int						,					_A	:str						,					_A	:Dict						,					_A	:str						,					_A	:Optional[int]						,					_A	:Optional[Any]						,					)					->      Tuple:







       '''simple docstring'''



       __A													=      MarkupLMModel(config=_A      )
       model.to(_A      )
       model.eval()
       print('Configs:'						,					model.config.tag_pad_id						,					model.config.subs_pad_id      )
       __A													=      model(_A						,					attention_mask=_A						,					token_type_ids=_A      )
       __A													=      model(_A						,					token_type_ids=_A      )
       __A													=      model(_A      )
       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 						lowercase_    (      self	:Any						,					_A	:Optional[Any]						,					_A	:Any						,					_A	:Optional[int]						,					_A	:Any						,					_A	:int						,					_A	:List[Any]						,					_A	:Dict						,					_A	:List[str]						,					)					->      Any:







       '''simple docstring'''



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






 def 						lowercase_    (      self	:Any						,					_A	:List[str]						,					_A	:str						,					_A	:str						,					_A	:List[Any]						,					_A	:Optional[Any]						,					_A	:Union[str, Any]						,					_A	:Dict						,					_A	:Union[str, Any]						,					)					->      Dict:







       '''simple docstring'''



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






 def 						lowercase_    (      self	:int						,					_A	:str						,					_A	:Tuple						,					_A	:Any						,					_A	:int						,					_A	:Any						,					_A	:Any						,					_A	:Union[str, Any]						,					_A	:List[Any]						,					)					->      List[str]:







       '''simple docstring'''



       __A													=      MarkupLMForQuestionAnswering(config=_A      )
       model.to(_A      )
       model.eval()
       __A													=      model(
           _A						,					xpath_tags_seq=_A						,					xpath_subs_seq=_A						,					attention_mask=_A						,					token_type_ids=_A						,					start_positions=_A						,					end_positions=_A						,					)
       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	:Dict      )					->      List[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__	(     SCREAMING_SNAKE_CASE   ,  SCREAMING_SNAKE_CASE   ,  unittest.TestCase):
 UpperCAmelCase__     :     List[Any]    					=       (
     (
         MarkupLMModel,
         MarkupLMForSequenceClassification,
         MarkupLMForTokenClassification,
         MarkupLMForQuestionAnswering,
     )
     if is_torch_available()
     else None
 )
 UpperCAmelCase__     :     Tuple    					=       (
     {
         'feature-extraction': MarkupLMModel,
         'question-answering': MarkupLMForQuestionAnswering,
         'text-classification': MarkupLMForSequenceClassification,
         'token-classification': MarkupLMForTokenClassification,
         'zero-shot': MarkupLMForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )






 def 						lowercase_    (      self	:Union[str, Any]						,					_A	:List[str]						,					_A	:Optional[Any]						,					_A	:Dict						,					_A	:Optional[Any]						,					_A	:Optional[int]      )					->      Tuple:







       '''simple docstring'''



       return True






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







       '''simple docstring'''



       __A													=      MarkupLMModelTester(self      )
       __A													=      ConfigTester(self						,					config_class=_A						,					hidden_size=37      )






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







       '''simple docstring'''



       self.config_tester.run_common_tests()






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







       '''simple docstring'''



       __A													=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_A      )






 def 						lowercase_    (      self	:Optional[Any]      )					->      Any:







       '''simple docstring'''



       __A													=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*_A      )






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







       '''simple docstring'''



       __A													=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*_A      )






 def 						lowercase_    (      self	:List[Any]      )					->      Tuple:







       '''simple docstring'''



       __A													=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*_A      )





def 							snake_case				(		)->      str:







      """simple docstring"""
      __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 						lowercase_    (      self	:Optional[int]      )					->      Dict:







       '''simple docstring'''



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

       return MarkupLMProcessor(_A						,					_A      )






 @slow
 def 						lowercase_    (      self	:Any      )					->      str:







       '''simple docstring'''



       __A													=      MarkupLMModel.from_pretrained('microsoft/markuplm-base'      ).to(_A      )

       __A													=      self.default_processor

       __A													=      processor(prepare_html_string()						,					return_tensors='pt'      )
       __A													=      inputs.to(_A      )

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

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

       __A													=      torch.tensor(
           [[0.0_675, -0.0_052, 0.5_001], [-0.2_281, 0.0_802, 0.2_192], [-0.0_583, -0.3_311, 0.1_185]]      ).to(_A      )

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






