




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__a							     =					{
    'configuration_bloom': ['BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP', 'BloomConfig', 'BloomOnnxConfig'],
}
try:
     if not is_tokenizers_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __a							     =					['BloomTokenizerFast']

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     __a							     =					[
         'BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST',
         'BloomForCausalLM',
         'BloomModel',
         'BloomPreTrainedModel',
         'BloomForSequenceClassification',
         'BloomForTokenClassification',
         'BloomForQuestionAnswering',
     ]

if TYPE_CHECKING:
     from .configuration_bloom import BLOOM_PRETRAINED_CONFIG_ARCHIVE_MAP, BloomConfig, BloomOnnxConfig

     try:
          if not is_tokenizers_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .tokenization_bloom_fast import BloomTokenizerFast

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_bloom import (
              BLOOM_PRETRAINED_MODEL_ARCHIVE_LIST,
              BloomForCausalLM,
              BloomForQuestionAnswering,
              BloomForSequenceClassification,
              BloomForTokenClassification,
              BloomModel,
              BloomPreTrainedModel,
          )

else:
     import sys

     __a							     =					_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
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        lowerCamelCase__				:





			def __init__(       self	:	str  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	str=2  ,  lowercase__	:	Union[str, Any]=3  ,  lowercase__	:	Dict=4  ,  lowercase__	:	Any=2  ,  lowercase__	:	Any=7  ,  lowercase__	:	Dict=True  ,  lowercase__	:	Any=True  ,  lowercase__	:	Optional[int]=True  ,  lowercase__	:	str=True  ,  lowercase__	:	Optional[Any]=99  ,  lowercase__	:	int=36  ,  lowercase__	:	Union[str, Any]=3  ,  lowercase__	:	List[Any]=4  ,  lowercase__	:	List[str]=37  ,  lowercase__	:	Optional[Any]="gelu"  ,  lowercase__	:	Optional[int]=0.1  ,  lowercase__	:	List[Any]=0.1  ,  lowercase__	:	Tuple=5_12  ,  lowercase__	:	Optional[Any]=16  ,  lowercase__	:	Tuple=2  ,  lowercase__	:	Optional[int]=0.0_2  ,  lowercase__	:	List[str]=6  ,  lowercase__	:	List[Any]=6  ,  lowercase__	:	Optional[int]=3  ,  lowercase__	:	Optional[Any]=4  ,  lowercase__	:	Optional[Any]=None  ,  lowercase__	:	Optional[Any]=10_00  ,  ):
										_lowerCAmelCase							=							parent
										_lowerCAmelCase							=							batch_size
										_lowerCAmelCase							=							num_channels
										_lowerCAmelCase							=							image_size
										_lowerCAmelCase							=							patch_size
										_lowerCAmelCase							=							text_seq_length
										_lowerCAmelCase							=							is_training
										_lowerCAmelCase							=							use_input_mask
										_lowerCAmelCase							=							use_token_type_ids
										_lowerCAmelCase							=							use_labels
										_lowerCAmelCase							=							vocab_size
										_lowerCAmelCase							=							hidden_size
										_lowerCAmelCase							=							num_hidden_layers
										_lowerCAmelCase							=							num_attention_heads
										_lowerCAmelCase							=							intermediate_size
										_lowerCAmelCase							=							hidden_act
										_lowerCAmelCase							=							hidden_dropout_prob
										_lowerCAmelCase							=							attention_probs_dropout_prob
										_lowerCAmelCase							=							max_position_embeddings
										_lowerCAmelCase							=							type_vocab_size
										_lowerCAmelCase							=							type_sequence_label_size
										_lowerCAmelCase							=							initializer_range
										_lowerCAmelCase							=							coordinate_size
										_lowerCAmelCase							=							shape_size
										_lowerCAmelCase							=							num_labels
										_lowerCAmelCase							=							num_choices
										_lowerCAmelCase							=							scope
										_lowerCAmelCase							=							range_bbox

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





			def   SCREAMING_SNAKE_CASE__     (       self	:	int						):
										_lowerCAmelCase							=							ids_tensor([self.batch_size, self.text_seq_length]  ,  self.vocab_size						)

										_lowerCAmelCase							=							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]:
																															_lowerCAmelCase							=							bbox[i, j, 3]
																															_lowerCAmelCase							=							bbox[i, j, 1]
																															_lowerCAmelCase							=							t
																								if bbox[i, j, 2] < bbox[i, j, 0]:
																															_lowerCAmelCase							=							bbox[i, j, 2]
																															_lowerCAmelCase							=							bbox[i, j, 0]
																															_lowerCAmelCase							=							t

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

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

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

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

										_lowerCAmelCase							=							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   SCREAMING_SNAKE_CASE__     (       self	:	Tuple  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	str  ,  lowercase__	:	Tuple  ,  lowercase__	:	str  ,  lowercase__	:	Optional[Any]						):
										_lowerCAmelCase							=							LayoutLMvaModel(config=lowercase__						)
										model.to(lowercase__						)
										model.eval()

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

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

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

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





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[Any]  ,  lowercase__	:	List[str]  ,  lowercase__	:	Tuple  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	Tuple  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	List[Any]  ,  lowercase__	:	List[Any]  ,  lowercase__	:	int						):
										_lowerCAmelCase							=							self.num_labels
										_lowerCAmelCase							=							LayoutLMvaForSequenceClassification(lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(
										    lowercase__  ,  bbox=lowercase__  ,  pixel_values=lowercase__  ,  attention_mask=lowercase__  ,  token_type_ids=lowercase__  ,  labels=lowercase__  ,  )
										self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.num_labels)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	int  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	Dict  ,  lowercase__	:	List[Any]  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	Tuple  ,  lowercase__	:	Tuple  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	int						):
										_lowerCAmelCase							=							self.num_labels
										_lowerCAmelCase							=							LayoutLMvaForTokenClassification(config=lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(
										    lowercase__  ,  bbox=lowercase__  ,  pixel_values=lowercase__  ,  attention_mask=lowercase__  ,  token_type_ids=lowercase__  ,  labels=lowercase__  ,  )
										self.parent.assertEqual(result.logits.shape  ,  (self.batch_size, self.text_seq_length, self.num_labels)						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Any  ,  lowercase__	:	Optional[int]  ,  lowercase__	:	List[Any]  ,  lowercase__	:	List[str]  ,  lowercase__	:	str  ,  lowercase__	:	Optional[Any]  ,  lowercase__	:	List[Any]  ,  lowercase__	:	List[str]  ,  lowercase__	:	Union[str, Any]						):
										_lowerCAmelCase							=							LayoutLMvaForQuestionAnswering(config=lowercase__						)
										model.to(lowercase__						)
										model.eval()
										_lowerCAmelCase							=							model(
										    lowercase__  ,  bbox=lowercase__  ,  pixel_values=lowercase__  ,  attention_mask=lowercase__  ,  token_type_ids=lowercase__  ,  start_positions=lowercase__  ,  end_positions=lowercase__  ,  )
										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   SCREAMING_SNAKE_CASE__     (       self	:	List[Any]						):
										_lowerCAmelCase							=							self.prepare_config_and_inputs()
										(
										    (
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		(
										    _lowerCAmelCase
										)			,		
										)							=							config_and_inputs
										_lowerCAmelCase							=							{
										    '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        lowerCamelCase__				(   UpperCAmelCase       ,UpperCAmelCase       ,unittest.TestCase				):
			UpperCamelCase__    							=False
			UpperCamelCase__    							=False
			UpperCamelCase__    							=False

			UpperCamelCase__    							=(
			    (
			        LayoutLMvaModel,
			        LayoutLMvaForSequenceClassification,
			        LayoutLMvaForTokenClassification,
			        LayoutLMvaForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			UpperCamelCase__    							=(
			    {"document-question-answering": LayoutLMvaForQuestionAnswering, "feature-extraction": LayoutLMvaModel}
			    if is_torch_available()
			    else {}
			)





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[Any]  ,  lowercase__	:	List[Any]  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	Any  ,  lowercase__	:	Union[str, Any]  ,  lowercase__	:	Optional[Any]						):
										# `DocumentQuestionAnsweringPipeline` is expected to work with this model, but it combines the text and visual
										# embedding along the sequence dimension (dim 1), which causes an error during post-processing as `p_mask` has
										# the sequence dimension of the text embedding only.
										# (see the line `embedding_output = torch.cat([embedding_output, visual_embeddings], dim=1)`)
										return True





			def   SCREAMING_SNAKE_CASE__     (       self	:	Dict						):
										_lowerCAmelCase							=							LayoutLMvaModelTester(self						)
										_lowerCAmelCase							=							ConfigTester(self  ,  config_class=lowercase__  ,  hidden_size=37						)





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

										return inputs_dict





			def   SCREAMING_SNAKE_CASE__     (       self	:	List[str]						):
										self.config_tester.run_common_tests()





			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]						):
										_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
																	_lowerCAmelCase							=							type
																	self.model_tester.create_and_check_model(*lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	str						):
										_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	Any						):
										_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*lowercase__						)





			def   SCREAMING_SNAKE_CASE__     (       self	:	int						):
										_lowerCAmelCase							=							self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*lowercase__						)





			@slow
			def   SCREAMING_SNAKE_CASE__     (       self	:	Any						):
										for model_name in LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	_lowerCAmelCase							=							LayoutLMvaModel.from_pretrained(lowercase__						)
																	self.assertIsNotNone(lowercase__						)







def _lowerCamelCase  (		):
							_lowerCAmelCase							=							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'  )
							return image



@require_torch
class        lowerCamelCase__				(   unittest.TestCase				):





			@cached_property
			def   SCREAMING_SNAKE_CASE__     (       self	:	Optional[int]						):
										return LayoutLMvaImageProcessor(apply_ocr=lowercase__						) if is_vision_available() else None





			@slow
			def   SCREAMING_SNAKE_CASE__     (       self	:	Tuple						):
										_lowerCAmelCase							=							LayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'						).to(lowercase__						)

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

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

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

										# verify the logits
										_lowerCAmelCase							=							torch.Size((1, 1_99, 7_68)						)
										self.assertEqual(outputs.last_hidden_state.shape  ,  lowercase__						)

										_lowerCAmelCase							=							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(lowercase__						)

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






