



import copy
import unittest

from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, 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, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers import (
			    MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
			    MODEL_FOR_QUESTION_ANSWERING_MAPPING,
			    MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
			    MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
			    LayoutLMvaConfig,
			    LayoutLMvaForQuestionAnswering,
			    LayoutLMvaForSequenceClassification,
			    LayoutLMvaForTokenClassification,
			    LayoutLMvaModel,
			)
			from transformers.models.layoutlmva.modeling_layoutlmva import LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
			from PIL import Image

			from transformers import LayoutLMvaImageProcessor

class   UpperCAmelCase_    :

						'''simple docstring'''




						def __init__(       self ,				_A ,				_A=2 ,				_A=3 ,				_A=4 ,				_A=2 ,				_A=7 ,				_A=True ,				_A=True ,				_A=True ,				_A=True ,				_A=99 ,				_A=36 ,				_A=3 ,				_A=4 ,				_A=37 ,				_A="gelu" ,				_A=0.1 ,				_A=0.1 ,				_A=512 ,				_A=16 ,				_A=2 ,				_A=0.0_2 ,				_A=6 ,				_A=6 ,				_A=3 ,				_A=4 ,				_A=None ,				_A=1_000 ,				):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   parent
													__SCREAMING_SNAKE_CASE										=   batch_size
													__SCREAMING_SNAKE_CASE										=   num_channels
													__SCREAMING_SNAKE_CASE										=   image_size
													__SCREAMING_SNAKE_CASE										=   patch_size
													__SCREAMING_SNAKE_CASE										=   text_seq_length
													__SCREAMING_SNAKE_CASE										=   is_training
													__SCREAMING_SNAKE_CASE										=   use_input_mask
													__SCREAMING_SNAKE_CASE										=   use_token_type_ids
													__SCREAMING_SNAKE_CASE										=   use_labels
													__SCREAMING_SNAKE_CASE										=   vocab_size
													__SCREAMING_SNAKE_CASE										=   hidden_size
													__SCREAMING_SNAKE_CASE										=   num_hidden_layers
													__SCREAMING_SNAKE_CASE										=   num_attention_heads
													__SCREAMING_SNAKE_CASE										=   intermediate_size
													__SCREAMING_SNAKE_CASE										=   hidden_act
													__SCREAMING_SNAKE_CASE										=   hidden_dropout_prob
													__SCREAMING_SNAKE_CASE										=   attention_probs_dropout_prob
													__SCREAMING_SNAKE_CASE										=   max_position_embeddings
													__SCREAMING_SNAKE_CASE										=   type_vocab_size
													__SCREAMING_SNAKE_CASE										=   type_sequence_label_size
													__SCREAMING_SNAKE_CASE										=   initializer_range
													__SCREAMING_SNAKE_CASE										=   coordinate_size
													__SCREAMING_SNAKE_CASE										=   shape_size
													__SCREAMING_SNAKE_CASE										=   num_labels
													__SCREAMING_SNAKE_CASE										=   num_choices
													__SCREAMING_SNAKE_CASE										=   scope
													__SCREAMING_SNAKE_CASE										=   range_bbox

													# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
													__SCREAMING_SNAKE_CASE										=   text_seq_length
													__SCREAMING_SNAKE_CASE										=   (image_size // patch_size) ** 2 + 1
													__SCREAMING_SNAKE_CASE										=   self.text_seq_length + self.image_seq_length






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   ids_tensor([self.batch_size, self.text_seq_length] ,				self.vocab_size						)

													__SCREAMING_SNAKE_CASE										=   ids_tensor([self.batch_size, self.text_seq_length, 4] ,				self.range_bbox						)
													# Ensure that bbox is legal
													for i in range(bbox.shape[0]						):
																				for j in range(bbox.shape[1]						):
																											if bbox[i, j, 3] < bbox[i, j, 1]:
																																		__SCREAMING_SNAKE_CASE										=   bbox[i, j, 3]
																																		__SCREAMING_SNAKE_CASE										=   bbox[i, j, 1]
																																		__SCREAMING_SNAKE_CASE										=   t
																											if bbox[i, j, 2] < bbox[i, j, 0]:
																																		__SCREAMING_SNAKE_CASE										=   bbox[i, j, 2]
																																		__SCREAMING_SNAKE_CASE										=   bbox[i, j, 0]
																																		__SCREAMING_SNAKE_CASE										=   t

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

													__SCREAMING_SNAKE_CASE										=   None
													if self.use_input_mask:
																				__SCREAMING_SNAKE_CASE										=   random_attention_mask([self.batch_size, self.text_seq_length]						)

													__SCREAMING_SNAKE_CASE										=   None
													if self.use_token_type_ids:
																				__SCREAMING_SNAKE_CASE										=   ids_tensor([self.batch_size, self.text_seq_length] ,				self.type_vocab_size						)

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

													__SCREAMING_SNAKE_CASE										=   LayoutLMvaConfig(
													    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 ,				coordinate_size=self.coordinate_size ,				shape_size=self.shape_size ,				input_size=self.image_size ,				patch_size=self.patch_size ,				)

													return config, input_ids, bbox, pixel_values, token_type_ids, input_mask, sequence_labels, token_labels






						def 			_A      (       self ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   LayoutLMvaModel(config=_lowerCAmelCase						)
													model.to(_lowerCAmelCase						)
													model.eval()

													# text + image
													__SCREAMING_SNAKE_CASE										=   model(_lowerCAmelCase ,				pixel_values=_lowerCAmelCase						)
													__SCREAMING_SNAKE_CASE										=   model(
													    _lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_lowerCAmelCase ,				attention_mask=_lowerCAmelCase ,				token_type_ids=_lowerCAmelCase						)
													__SCREAMING_SNAKE_CASE										=   model(_lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_lowerCAmelCase ,				token_type_ids=_lowerCAmelCase						)
													__SCREAMING_SNAKE_CASE										=   model(_lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_lowerCAmelCase						)

													self.parent.assertEqual(result.last_hidden_state.shape ,				(self.batch_size, self.seq_length, self.hidden_size)						)

													# text only
													__SCREAMING_SNAKE_CASE										=   model(_lowerCAmelCase						)
													self.parent.assertEqual(
													    result.last_hidden_state.shape ,				(self.batch_size, self.text_seq_length, self.hidden_size)						)

													# image only
													__SCREAMING_SNAKE_CASE										=   model(pixel_values=_lowerCAmelCase						)
													self.parent.assertEqual(
													    result.last_hidden_state.shape ,				(self.batch_size, self.image_seq_length, self.hidden_size)						)






						def 			_A      (       self ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   self.num_labels
													__SCREAMING_SNAKE_CASE										=   LayoutLMvaForSequenceClassification(_lowerCAmelCase						)
													model.to(_lowerCAmelCase						)
													model.eval()
													__SCREAMING_SNAKE_CASE										=   model(
													    _lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_lowerCAmelCase ,				attention_mask=_lowerCAmelCase ,				token_type_ids=_lowerCAmelCase ,				labels=_lowerCAmelCase ,				)
													self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_labels)						)






						def 			_A      (       self ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   self.num_labels
													__SCREAMING_SNAKE_CASE										=   LayoutLMvaForTokenClassification(config=_lowerCAmelCase						)
													model.to(_lowerCAmelCase						)
													model.eval()
													__SCREAMING_SNAKE_CASE										=   model(
													    _lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_lowerCAmelCase ,				attention_mask=_lowerCAmelCase ,				token_type_ids=_lowerCAmelCase ,				labels=_lowerCAmelCase ,				)
													self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.text_seq_length, self.num_labels)						)






						def 			_A      (       self ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A ,				_A						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   LayoutLMvaForQuestionAnswering(config=_lowerCAmelCase						)
													model.to(_lowerCAmelCase						)
													model.eval()
													__SCREAMING_SNAKE_CASE										=   model(
													    _lowerCAmelCase ,				bbox=_lowerCAmelCase ,				pixel_values=_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 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   self.prepare_config_and_inputs()
													(
													    (
													    __SCREAMING_SNAKE_CASE      
													)				,			(
													    __SCREAMING_SNAKE_CASE      
													)				,			(
													    __SCREAMING_SNAKE_CASE      
													)				,			(
													    __SCREAMING_SNAKE_CASE      
													)				,			(
													    __SCREAMING_SNAKE_CASE      
													)				,			(
													    __SCREAMING_SNAKE_CASE      
													)				,			(
													    __SCREAMING_SNAKE_CASE      
													)				,			(
													    __SCREAMING_SNAKE_CASE      
													)				,			      
													)										=   config_and_inputs
													__SCREAMING_SNAKE_CASE										=   {
													    'input_ids': input_ids,
													    'bbox': bbox,
													    'pixel_values': pixel_values,
													    'token_type_ids': token_type_ids,
													    'attention_mask': input_mask,
													}
													return config, inputs_dict







@require_torch
class   UpperCAmelCase_    (  UpperCamelCase_       ,       UpperCamelCase_       ,       unittest.TestCase			):

						'''simple docstring'''




						UpperCamelCase__     :					Optional[int]							    =    False
						UpperCamelCase__     :					Tuple							    =    False
						UpperCamelCase__     :					Dict							    =    False

						UpperCamelCase__     :					Tuple							    =    (
						    (
						        LayoutLMvaModel,
						        LayoutLMvaForSequenceClassification,
						        LayoutLMvaForTokenClassification,
						        LayoutLMvaForQuestionAnswering,
						    )
						    if is_torch_available()
						    else ()
						)
						UpperCamelCase__     :					Union[str, Any]							    =    (
						    {"document-question-answering": LayoutLMvaForQuestionAnswering, "feature-extraction": LayoutLMvaModel}
						    if is_torch_available()
						    else {}
						)






						def 			_A      (       self ,				_A ,				_A ,				_A ,				_A ,				_A						):







													'''simple docstring'''

													return True






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   LayoutLMvaModelTester(self						)
													__SCREAMING_SNAKE_CASE										=   ConfigTester(self ,				config_class=_lowerCAmelCase ,				hidden_size=37						)






						def 			_A      (       self ,				_A ,				_A ,				_A=False						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   copy.deepcopy(_lowerCAmelCase						)
													if model_class in get_values(_lowerCAmelCase						):
																				__SCREAMING_SNAKE_CASE										=   {
																				    k: v.unsqueeze(1						).expand(-1 ,				self.model_tester.num_choices ,				-1						).contiguous()
																				    if isinstance(_lowerCAmelCase ,				torch.Tensor						) and v.ndim > 1
																				    else v
																				    for k, v in inputs_dict.items()
																				}
													if return_labels:
																				if model_class in get_values(_lowerCAmelCase						):
																											__SCREAMING_SNAKE_CASE										=   torch.ones(self.model_tester.batch_size ,				dtype=torch.long ,				device=_lowerCAmelCase						)
																				elif model_class in get_values(_lowerCAmelCase						):
																											__SCREAMING_SNAKE_CASE										=   torch.zeros(
																											    self.model_tester.batch_size ,				dtype=torch.long ,				device=_lowerCAmelCase						)
																											__SCREAMING_SNAKE_CASE										=   torch.zeros(
																											    self.model_tester.batch_size ,				dtype=torch.long ,				device=_lowerCAmelCase						)
																				elif model_class in [
																				    *get_values(_lowerCAmelCase						),
																				]:
																											__SCREAMING_SNAKE_CASE										=   torch.zeros(
																											    self.model_tester.batch_size ,				dtype=torch.long ,				device=_lowerCAmelCase						)
																				elif model_class in [
																				    *get_values(_lowerCAmelCase						),
																				]:
																											__SCREAMING_SNAKE_CASE										=   torch.zeros(
																											    (self.model_tester.batch_size, self.model_tester.text_seq_length) ,				dtype=torch.long ,				device=_lowerCAmelCase ,				)

													return inputs_dict






						def 			_A      (       self						):







													'''simple docstring'''

													self.config_tester.run_common_tests()






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*_lowerCAmelCase						)






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs()
													for type in ["absolute", "relative_key", "relative_key_query"]:
																				__SCREAMING_SNAKE_CASE										=   type
																				self.model_tester.create_and_check_model(*_lowerCAmelCase						)






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_sequence_classification(*_lowerCAmelCase						)






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_token_classification(*_lowerCAmelCase						)






						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_question_answering(*_lowerCAmelCase						)






						@slow
						def 			_A      (       self						):







													'''simple docstring'''

													for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				__SCREAMING_SNAKE_CASE										=   LayoutLMvaModel.from_pretrained(_lowerCAmelCase						)
																				self.assertIsNotNone(_lowerCAmelCase						)







def       __lowercase  (					)							->					Optional[Any]:
							__SCREAMING_SNAKE_CASE										=   Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
							return image

@require_torch
class   UpperCAmelCase_    (  unittest.TestCase			):

						'''simple docstring'''




						@cached_property
						def 			_A      (       self						):







													'''simple docstring'''

													return LayoutLMvaImageProcessor(apply_ocr=_lowerCAmelCase						) if is_vision_available() else None






						@slow
						def 			_A      (       self						):







													'''simple docstring'''

													__SCREAMING_SNAKE_CASE										=   LayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'						).to(_lowerCAmelCase						)

													__SCREAMING_SNAKE_CASE										=   self.default_image_processor
													__SCREAMING_SNAKE_CASE										=   prepare_img()
													__SCREAMING_SNAKE_CASE										=   image_processor(images=_lowerCAmelCase ,				return_tensors='pt'						).pixel_values.to(_lowerCAmelCase						)

													__SCREAMING_SNAKE_CASE										=   torch.tensor([[1, 2]]						)
													__SCREAMING_SNAKE_CASE										=   torch.tensor([[1, 2, 3, 4], [5, 6, 7, 8]]						).unsqueeze(0						)

													# forward pass
													__SCREAMING_SNAKE_CASE										=   model(
													    input_ids=input_ids.to(_lowerCAmelCase						) ,				bbox=bbox.to(_lowerCAmelCase						) ,				pixel_values=pixel_values.to(_lowerCAmelCase						) ,				)

													# verify the logits
													__SCREAMING_SNAKE_CASE										=   torch.Size((1, 199, 768)						)
													self.assertEqual(outputs.last_hidden_state.shape ,				_lowerCAmelCase						)

													__SCREAMING_SNAKE_CASE										=   torch.tensor(
													    [[-0.0_5_2_9, 0.3_6_1_8, 0.1_6_3_2], [-0.1_5_8_7, -0.1_6_6_7, -0.0_4_0_0], [-0.1_5_5_7, -0.1_6_7_1, -0.0_5_0_5]]						).to(_lowerCAmelCase						)

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













'''simple docstring'''


from ...configuration_utils import PretrainedConfig
from ...utils import logging


_SCREAMING_SNAKE_CASE									=				logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE									=				{
    "bigcode/gpt_bigcode-santacoder": "https://huggingface.co/bigcode/gpt_bigcode-santacoder/resolve/main/config.json",
}

class  lowerCAmelCase_		(		__magic_name__		):
 __lowerCamelCase    :				str								=       "gpt_bigcode"
 __lowerCamelCase    :				Optional[int]								=       ["past_key_values"]
 __lowerCamelCase    :				List[str]								=       {
     "hidden_size": "n_embd",
     "max_position_embeddings": "n_positions",
     "num_attention_heads": "n_head",
     "num_hidden_layers": "n_layer",
 }




 def __init__(						self      ,  _lowerCAmelCase=50257      ,  _lowerCAmelCase=1024      ,  _lowerCAmelCase=768      ,  _lowerCAmelCase=12      ,  _lowerCAmelCase=12      ,  _lowerCAmelCase=None      ,  _lowerCAmelCase="gelu_pytorch_tanh"      ,  _lowerCAmelCase=0.1      ,  _lowerCAmelCase=0.1      ,  _lowerCAmelCase=0.1      ,  _lowerCAmelCase=1E-5      ,  _lowerCAmelCase=0.02      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=50256      ,  _lowerCAmelCase=50256      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=True      ,  _lowerCAmelCase=True      ,  **_lowerCAmelCase      ,  )     ->				List[Any]:
     _lowerCAmelCase						      =   vocab_size
     _lowerCAmelCase						      =   n_positions
     _lowerCAmelCase						      =   n_embd
     _lowerCAmelCase						      =   n_layer
     _lowerCAmelCase						      =   n_head
     _lowerCAmelCase						      =   n_inner
     _lowerCAmelCase						      =   activation_function
     _lowerCAmelCase						      =   resid_pdrop
     _lowerCAmelCase						      =   embd_pdrop
     _lowerCAmelCase						      =   attn_pdrop
     _lowerCAmelCase						      =   layer_norm_epsilon
     _lowerCAmelCase						      =   initializer_range
     _lowerCAmelCase						      =   scale_attn_weights
     _lowerCAmelCase						      =   use_cache
     _lowerCAmelCase						      =   attention_softmax_in_fpaa
     _lowerCAmelCase						      =   scale_attention_softmax_in_fpaa
     _lowerCAmelCase						      =   multi_query

     _lowerCAmelCase						      =   bos_token_id
     _lowerCAmelCase						      =   eos_token_id

     super().__init__(bos_token_id=_lowerCAmelCase      ,  eos_token_id=_lowerCAmelCase      ,  **_lowerCAmelCase		)


