




import unittest

from transformers import LayoutLMConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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 (
     LayoutLMForMaskedLM,
     LayoutLMForQuestionAnswering,
     LayoutLMForSequenceClassification,
     LayoutLMForTokenClassification,
     LayoutLMModel,
 )







class 		__UpperCAmelCase:





     """simple docstring"""



     def __init__(      self :       List[Any]						,				A :       List[str]						,				A :       Union[str, Any]=13						,				A :       str=7						,				A :       Optional[Any]=True						,				A :       Any=True						,				A :       Tuple=True						,				A :       Optional[Any]=True						,				A :       str=99						,				A :       Optional[Any]=32						,				A :       int=5						,				A :       Tuple=4						,				A :       Optional[Any]=37						,				A :       Tuple="gelu"						,				A :       int=0.1						,				A :       Any=0.1						,				A :       int=5_12						,				A :       Dict=16						,				A :       int=2						,				A :       List[Any]=0.0_2						,				A :       Any=3						,				A :       int=4						,				A :       Dict=None						,				A :       int=10_00						,				)			->			Optional[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__      =       num_choices
         a__      =       scope
         a__      =       range_bbox

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






         """simple docstring"""
         a__      =       ids_tensor([self.batch_size, self.seq_length]						,				self.vocab_size    )

         a__      =       ids_tensor([self.batch_size, self.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]:
                     a__      =       bbox[i, j, 3]
                     a__      =       bbox[i, j, 1]
                     a__      =       t
                 if bbox[i, j, 2] < bbox[i, j, 0]:
                     a__      =       bbox[i, j, 2]
                     a__      =       bbox[i, j, 0]
                     a__      =       t

         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
         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__      =       ids_tensor([self.batch_size]						,				self.num_choices    )

         a__      =       self.get_config()

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

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






         """simple docstring"""
         return LayoutLMConfig(
             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						,				)

     def 				__SCREAMING_SNAKE_CASE		(      self :       Optional[int]						,				A :       Any						,				A :       List[str]						,				A :       List[str]						,				A :       Dict						,				A :       Any						,				A :       List[str]						,				A :       str						,				A :       Optional[int]    )			->			Any:






         """simple docstring"""
         a__      =       LayoutLMModel(config=A    )
         model.to(A    )
         model.eval()
         a__      =       model(A						,				A						,				attention_mask=A						,				token_type_ids=A    )
         a__      =       model(A						,				A						,				token_type_ids=A    )
         a__      =       model(A						,				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 				__SCREAMING_SNAKE_CASE		(      self :       Any						,				A :       str						,				A :       Union[str, Any]						,				A :       Dict						,				A :       List[Any]						,				A :       Dict						,				A :       List[str]						,				A :       str						,				A :       Any    )			->			Any:






         """simple docstring"""
         a__      =       LayoutLMForMaskedLM(config=A    )
         model.to(A    )
         model.eval()
         a__      =       model(A						,				A						,				attention_mask=A						,				token_type_ids=A						,				labels=A    )
         self.parent.assertEqual(result.logits.shape						,				(self.batch_size, self.seq_length, self.vocab_size)    )

     def 				__SCREAMING_SNAKE_CASE		(      self :       List[str]						,				A :       Any						,				A :       Optional[int]						,				A :       str						,				A :       str						,				A :       Dict						,				A :       List[str]						,				A :       Optional[Any]						,				A :       Any    )			->			List[str]:






         """simple docstring"""
         a__      =       self.num_labels
         a__      =       LayoutLMForSequenceClassification(A    )
         model.to(A    )
         model.eval()
         a__      =       model(
             A						,				A						,				attention_mask=A						,				token_type_ids=A						,				labels=A    )
         self.parent.assertEqual(result.logits.shape						,				(self.batch_size, self.num_labels)    )

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






         """simple docstring"""
         a__      =       self.num_labels
         a__      =       LayoutLMForTokenClassification(config=A    )
         model.to(A    )
         model.eval()
         a__      =       model(A						,				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 				__SCREAMING_SNAKE_CASE		(      self :       int						,				A :       Optional[int]						,				A :       Tuple						,				A :       Tuple						,				A :       Optional[int]						,				A :       str						,				A :       Union[str, Any]						,				A :       Optional[int]						,				A :       int    )			->			Any:






         """simple docstring"""
         a__      =       LayoutLMForQuestionAnswering(config=A    )
         model.to(A    )
         model.eval()
         a__      =       model(
             A						,				bbox=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 				__SCREAMING_SNAKE_CASE		(      self :       int    )			->			Optional[Any]:






         """simple docstring"""
         a__      =       self.prepare_config_and_inputs()
         (
             a__			
         )      =       config_and_inputs
         a__      =       {
             'input_ids': input_ids,
             'bbox': bbox,
             'token_type_ids': token_type_ids,
             'attention_mask': input_mask,
         }
         return config, inputs_dict







@require_torch
class 		__UpperCAmelCase(		snake_case__       ,	snake_case__       ,	unittest.TestCase ):





     """simple docstring"""



     __UpperCAmelCase	: Optional[Any]						=    (
         (
             LayoutLMModel,
             LayoutLMForMaskedLM,
             LayoutLMForSequenceClassification,
             LayoutLMForTokenClassification,
             LayoutLMForQuestionAnswering,
         )
         if is_torch_available()
         else None
     )
     __UpperCAmelCase	: int						=    (
         {
             'document-question-answering': LayoutLMForQuestionAnswering,
             'feature-extraction': LayoutLMModel,
             'fill-mask': LayoutLMForMaskedLM,
             'text-classification': LayoutLMForSequenceClassification,
             'token-classification': LayoutLMForTokenClassification,
             'zero-shot': LayoutLMForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     __UpperCAmelCase	: Dict						=    True

     def 				__SCREAMING_SNAKE_CASE		(      self :       Dict    )			->			Dict:






         """simple docstring"""
         a__      =       LayoutLMModelTester(self    )
         a__      =       ConfigTester(self						,				config_class=A						,				hidden_size=37    )

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






         """simple docstring"""
         self.config_tester.run_common_tests()

     def 				__SCREAMING_SNAKE_CASE		(      self :       Dict    )			->			int:






         """simple docstring"""
         a__      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A    )

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






         """simple docstring"""
         a__      =       self.model_tester.prepare_config_and_inputs()
         for type in ["absolute", "relative_key", "relative_key_query"]:
             a__      =       type
             self.model_tester.create_and_check_model(*A    )

     def 				__SCREAMING_SNAKE_CASE		(      self :       List[Any]    )			->			Dict:






         """simple docstring"""
         a__      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*A    )

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






         """simple docstring"""
         a__      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_sequence_classification(*A    )

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






         """simple docstring"""
         a__      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_token_classification(*A    )

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






         """simple docstring"""
         a__      =       self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_question_answering(*A    )






     @unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""    )
     def 				__SCREAMING_SNAKE_CASE		(      self :       Tuple    )			->			Optional[int]:






         """simple docstring"""
         pass






def        __lowerCAmelCase ()     ->   List[Any]:
    # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
    # fmt: off
    a__      =       torch.tensor([[101,1_019,1_014,1_016,1_037,12_849,4_747,1_004,14_246,2_278,5_439,4_524,5_002,2_930,2_193,2_930,4_341,3_208,1_005,1_055,2_171,2_848,11_300,3_531,102],[101,4_070,4_034,7_020,1_024,3_058,1_015,1_013,2_861,1_013,6_070,19_274,2_772,6_205,27_814,16_147,16_147,4_343,2_047,10_283,10_969,14_389,1_012,2_338,102]]   ,    device=lowerCAmelCase__		)  # noqa: E231
    a__      =       torch.tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]   ,    device=lowerCAmelCase__		)  # noqa: E231
    a__      =       torch.tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1_000,1_000,1_000,1_000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1_000,1_000,1_000,1_000]]]   ,    device=lowerCAmelCase__		)  # noqa: E231
    a__      =       torch.tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]   ,    device=lowerCAmelCase__		)  # noqa: E231
    # these are sequence labels (i.e. at the token level)
    a__      =       torch.tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]]   ,    device=lowerCAmelCase__		)  # noqa: E231
    # fmt: on

    return input_ids, attention_mask, bbox, token_type_ids, labels







@require_torch
class 		__UpperCAmelCase(		unittest.TestCase ):





     """simple docstring"""



     @slow
     def 				__SCREAMING_SNAKE_CASE		(      self :       Optional[Any]    )			->			int:






         """simple docstring"""
         a__      =       LayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""    ).to(A    )

         a__      =       prepare_layoutlm_batch_inputs()

         # forward pass
         a__      =       model(input_ids=A						,				bbox=A						,				attention_mask=A						,				token_type_ids=A    )

         # test the sequence output on [0, :3, :3]
         a__      =       torch.tensor(
             [[0.1_7_8_5, -0.1_9_4_7, -0.0_4_2_5], [-0.3_2_5_4, -0.2_8_0_7, 0.2_5_5_3], [-0.5_3_9_1, -0.3_3_2_2, 0.3_3_6_4]]						,				device=A						,				)

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

         # test the pooled output on [1, :3]
         a__      =       torch.tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2]						,				device=A    )

         self.assertTrue(torch.allclose(outputs.pooler_output[1, :3]						,				A						,				atol=1E-3    )    )

     @slow
     def 				__SCREAMING_SNAKE_CASE		(      self :       Union[str, Any]    )			->			Optional[int]:






         """simple docstring"""
         # initialize model with randomly initialized sequence classification head
         a__      =       LayoutLMForSequenceClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""						,				num_labels=2    ).to(
             A    )

         a__      =       prepare_layoutlm_batch_inputs()

         # forward pass
         a__      =       model(
             input_ids=A						,				bbox=A						,				attention_mask=A						,				token_type_ids=A						,				labels=torch.tensor([1, 1]						,				device=A    )						,				)

         # test whether we get a loss as a scalar
         a__      =       outputs.loss
         a__      =       torch.Size([]    )
         self.assertEqual(loss.shape						,				A    )

         # test the shape of the logits
         a__      =       outputs.logits
         a__      =       torch.Size((2, 2)    )
         self.assertEqual(logits.shape						,				A    )

     @slow
     def 				__SCREAMING_SNAKE_CASE		(      self :       Optional[Any]    )			->			Dict:






         """simple docstring"""
         # initialize model with randomly initialized token classification head
         a__      =       LayoutLMForTokenClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""						,				num_labels=13    ).to(
             A    )

         a__      =       prepare_layoutlm_batch_inputs()

         # forward pass
         a__      =       model(
             input_ids=A						,				bbox=A						,				attention_mask=A						,				token_type_ids=A						,				labels=A    )

         # test the loss calculation to be around 2.65
         # expected_loss = torch.tensor(2.65, device=torch_device)

         # The loss is currently somewhat random and can vary between 0.1-0.3 atol.
         # self.assertTrue(torch.allclose(outputs.loss, expected_loss, atol=0.1))

         # test the shape of the logits
         a__      =       outputs.logits
         a__      =       torch.Size((2, 25, 13)    )
         self.assertEqual(logits.shape						,				A    )






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






         """simple docstring"""
         # initialize model with randomly initialized token classification head
         a__      =       LayoutLMForQuestionAnswering.from_pretrained("""microsoft/layoutlm-base-uncased"""    ).to(A    )

         a__      =       prepare_layoutlm_batch_inputs()

         # forward pass
         a__      =       model(input_ids=A						,				bbox=A						,				attention_mask=A						,				token_type_ids=A    )

         # test the shape of the logits
         a__      =       torch.Size((2, 25)    )
         self.assertEqual(outputs.start_logits.shape						,				A    )
         self.assertEqual(outputs.end_logits.shape						,				A    )












from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


SCREAMING_SNAKE_CASE_						:					str			   =       {
    '''configuration_wav2vec2_conformer''': [
        '''WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''Wav2Vec2ConformerConfig''',
    ],
}


try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 SCREAMING_SNAKE_CASE_						:					Optional[int]			   =       [
     '''WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST''',
     '''Wav2Vec2ConformerForAudioFrameClassification''',
     '''Wav2Vec2ConformerForCTC''',
     '''Wav2Vec2ConformerForPreTraining''',
     '''Wav2Vec2ConformerForSequenceClassification''',
     '''Wav2Vec2ConformerForXVector''',
     '''Wav2Vec2ConformerModel''',
     '''Wav2Vec2ConformerPreTrainedModel''',
 ]

if TYPE_CHECKING:
 from .configuration_wavaveca_conformer import (
     WAV2VEC2_CONFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
     WavaVecaConformerConfig,
 )

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_wavaveca_conformer import (
      WAV2VEC2_CONFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
      WavaVecaConformerForAudioFrameClassification,
      WavaVecaConformerForCTC,
      WavaVecaConformerForPreTraining,
      WavaVecaConformerForSequenceClassification,
      WavaVecaConformerForXVector,
      WavaVecaConformerModel,
      WavaVecaConformerPreTrainedModel,
  )

else:
 import sys

 SCREAMING_SNAKE_CASE_						:					Optional[int]			   =       _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)






