


from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers.models.layoutlm.modeling_tf_layoutlm import (
        TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFLayoutLMForMaskedLM,
        TFLayoutLMForQuestionAnswering,
        TFLayoutLMForSequenceClassification,
        TFLayoutLMForTokenClassification,
        TFLayoutLMModel,
    )







class      lowerCAmelCase__       :




     '''simple docstring'''


     def __init__(						self ,						__lowerCamelCase ,						__lowerCamelCase=1_3 ,						__lowerCamelCase=7 ,						__lowerCamelCase=True ,						__lowerCamelCase=True ,						__lowerCamelCase=True ,						__lowerCamelCase=True ,						__lowerCamelCase=9_9 ,						__lowerCamelCase=3_2 ,						__lowerCamelCase=2 ,						__lowerCamelCase=4 ,						__lowerCamelCase=3_7 ,						__lowerCamelCase="gelu" ,						__lowerCamelCase=0.1 ,						__lowerCamelCase=0.1 ,						__lowerCamelCase=5_1_2 ,						__lowerCamelCase=1_6 ,						__lowerCamelCase=2 ,						__lowerCamelCase=0.0_2 ,						__lowerCamelCase=3 ,						__lowerCamelCase=4 ,						__lowerCamelCase=None ,						__lowerCamelCase=1_0_0_0 ,						)			->				Optional[int]:
            _A      :       Tuple				    = parent
            _A      :       Optional[int]				    = batch_size
            _A      :       List[Any]				    = seq_length
            _A      :       Any				    = is_training
            _A      :       Any				    = use_input_mask
            _A      :       Optional[Any]				    = use_token_type_ids
            _A      :       int				    = use_labels
            _A      :       Tuple				    = vocab_size
            _A      :       Union[str, Any]				    = hidden_size
            _A      :       Any				    = num_hidden_layers
            _A      :       Tuple				    = num_attention_heads
            _A      :       Optional[Any]				    = intermediate_size
            _A      :       Optional[Any]				    = hidden_act
            _A      :       Optional[Any]				    = hidden_dropout_prob
            _A      :       Union[str, Any]				    = attention_probs_dropout_prob
            _A      :       Any				    = max_position_embeddings
            _A      :       Union[str, Any]				    = type_vocab_size
            _A      :       str				    = type_sequence_label_size
            _A      :       Tuple				    = initializer_range
            _A      :       List[str]				    = num_labels
            _A      :       int				    = num_choices
            _A      :       List[str]				    = scope
            _A      :       int				    = range_bbox


     def  _lowerCamelCase (						self)			->				Optional[int]:
            _A      :       Tuple				    = ids_tensor([self.batch_size, self.seq_length] ,						self.vocab_size)

            # convert bbox to numpy since TF does not support item assignment
            _A      :       str				    = ids_tensor([self.batch_size, self.seq_length, 4] ,						self.range_bbox).numpy()
            # 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      :       Optional[int]				    = bbox[i, j, 3]
                                 _A      :       Any				    = bbox[i, j, 1]
                                 _A      :       Optional[int]				    = t
                          if bbox[i, j, 2] < bbox[i, j, 0]:
                                 _A      :       List[Any]				    = bbox[i, j, 2]
                                 _A      :       List[str]				    = bbox[i, j, 0]
                                 _A      :       Union[str, Any]				    = t
            _A      :       int				    = tf.convert_to_tensor(__lowerCamelCase)

            _A      :       List[str]				    = None
            if self.use_input_mask:
                   _A      :       int				    = random_attention_mask([self.batch_size, self.seq_length])

            _A      :       Tuple				    = None
            if self.use_token_type_ids:
                   _A      :       Optional[Any]				    = ids_tensor([self.batch_size, self.seq_length] ,						self.type_vocab_size)

            _A      :       Any				    = None
            _A      :       List[str]				    = None
            _A      :       Optional[Any]				    = None
            if self.use_labels:
                   _A      :       Dict				    = ids_tensor([self.batch_size] ,						self.type_sequence_label_size)
                   _A      :       Dict				    = ids_tensor([self.batch_size, self.seq_length] ,						self.num_labels)
                   _A      :       Optional[Any]				    = ids_tensor([self.batch_size] ,						self.num_choices)

            _A      :       Tuple				    = 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 ,						)

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


     def  _lowerCamelCase (						self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase)			->				int:
            _A      :       Optional[int]				    = TFLayoutLMModel(config=__lowerCamelCase)

            _A      :       List[Any]				    = model(__lowerCamelCase ,						__lowerCamelCase ,						attention_mask=__lowerCamelCase ,						token_type_ids=__lowerCamelCase)
            _A      :       int				    = model(__lowerCamelCase ,						__lowerCamelCase ,						token_type_ids=__lowerCamelCase)
            _A      :       Any				    = model(__lowerCamelCase ,						__lowerCamelCase)
            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  _lowerCamelCase (						self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase)			->				Optional[Any]:
            _A      :       Any				    = TFLayoutLMForMaskedLM(config=__lowerCamelCase)

            _A      :       Optional[int]				    = model(__lowerCamelCase ,						__lowerCamelCase ,						attention_mask=__lowerCamelCase ,						token_type_ids=__lowerCamelCase ,						labels=__lowerCamelCase)
            self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.vocab_size))


     def  _lowerCamelCase (						self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase)			->				str:
            _A      :       Tuple				    = self.num_labels
            _A      :       List[str]				    = TFLayoutLMForSequenceClassification(config=__lowerCamelCase)

            _A      :       List[str]				    = model(__lowerCamelCase ,						__lowerCamelCase ,						attention_mask=__lowerCamelCase ,						token_type_ids=__lowerCamelCase)
            self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.num_labels))


     def  _lowerCamelCase (						self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase)			->				List[Any]:
            _A      :       Union[str, Any]				    = self.num_labels
            _A      :       Tuple				    = TFLayoutLMForTokenClassification(config=__lowerCamelCase)

            _A      :       Tuple				    = model(__lowerCamelCase ,						__lowerCamelCase ,						attention_mask=__lowerCamelCase ,						token_type_ids=__lowerCamelCase ,						labels=__lowerCamelCase)
            self.parent.assertEqual(result.logits.shape ,						(self.batch_size, self.seq_length, self.num_labels))


     def  _lowerCamelCase (						self ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase ,						__lowerCamelCase)			->				Tuple:
            _A      :       Optional[int]				    = TFLayoutLMForQuestionAnswering(config=__lowerCamelCase)

            _A      :       Dict				    = model(__lowerCamelCase ,						__lowerCamelCase ,						attention_mask=__lowerCamelCase ,						token_type_ids=__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  _lowerCamelCase (						self)			->				Optional[Any]:
            _A      :       Optional[Any]				    = self.prepare_config_and_inputs()
            (
                (
                _A
            )    ,			(
                _A
            )    ,			(
                _A
            )    ,			(
                _A
            )    ,			(
                _A
            )    ,			(
                _A
            )    ,			(
                _A
            )    ,			(
                _A
            )    ,			
            )      :       Optional[Any]				    = config_and_inputs
            _A      :       str				    = {
                "input_ids": input_ids,
                "bbox": bbox,
                "token_type_ids": token_type_ids,
                "attention_mask": input_mask,
            }
            return config, inputs_dict







@require_tf
class      lowerCAmelCase__       (				a     ,    a     ,    unittest.TestCase):




     '''simple docstring'''
     __SCREAMING_SNAKE_CASE  			= (
         (
             TFLayoutLMModel,
             TFLayoutLMForMaskedLM,
             TFLayoutLMForTokenClassification,
             TFLayoutLMForSequenceClassification,
             TFLayoutLMForQuestionAnswering,
         )
         if is_tf_available()
         else ()
     )
     __SCREAMING_SNAKE_CASE  			= (
         {
             "feature-extraction": TFLayoutLMModel,
             "fill-mask": TFLayoutLMForMaskedLM,
             "text-classification": TFLayoutLMForSequenceClassification,
             "token-classification": TFLayoutLMForTokenClassification,
             "zero-shot": TFLayoutLMForSequenceClassification,
         }
         if is_tf_available()
         else {}
     )
     __SCREAMING_SNAKE_CASE  			= False
     __SCREAMING_SNAKE_CASE  			= True
     __SCREAMING_SNAKE_CASE  			= 10


     def  _lowerCamelCase (						self)			->				int:
            _A      :       Dict				    = TFLayoutLMModelTester(self)
            _A      :       Any				    = ConfigTester(self ,						config_class=__lowerCamelCase ,						hidden_size=3_7)


     def  _lowerCamelCase (						self)			->				Any:
            self.config_tester.run_common_tests()


     def  _lowerCamelCase (						self)			->				Tuple:
            _A      :       List[str]				    = self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*__lowerCamelCase)


     def  _lowerCamelCase (						self)			->				Optional[int]:
            _A      :       Optional[int]				    = self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*__lowerCamelCase)


     def  _lowerCamelCase (						self)			->				Optional[Any]:
            _A      :       Any				    = self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*__lowerCamelCase)


     def  _lowerCamelCase (						self)			->				str:
            _A      :       Optional[int]				    = self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*__lowerCamelCase)


     def  _lowerCamelCase (						self)			->				Tuple:
            _A      :       Union[str, Any]				    = self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*__lowerCamelCase)


     @slow
     def  _lowerCamelCase (						self)			->				Tuple:
            for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   _A      :       Dict				    = TFLayoutLMModel.from_pretrained(__lowerCamelCase)
                   self.assertIsNotNone(__lowerCamelCase)


     @unittest.skip("Onnx compliancy broke with TF 2.10")
     def  _lowerCamelCase (						self)			->				Tuple:
            pass




def 							_UpperCAmelCase				():
       # Here we prepare a batch of 2 sequences to test a LayoutLM forward pass on:
       # fmt: off
       _A      :       List[Any]				    = tf.convert_to_tensor([[101,1019,1014,1016,1037,12849,4747,1004,14246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,11300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,19274,2772,6205,27814,16147,16147,4343,2047,10283,10969,14389,1012,2338,102]]						)  # noqa: E231
       _A      :       Optional[int]				    = tf.convert_to_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],]						)  # noqa: E231
       _A      :       Tuple				    = tf.convert_to_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],[1000,1000,1000,1000]],[[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],[1000,1000,1000,1000]]]						)  # noqa: E231
       _A      :       Any				    = tf.convert_to_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]]						)  # noqa: E231
       # these are sequence labels (i.e. at the token level)
       _A      :       int				    = tf.convert_to_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]]						)  # noqa: E231
       # fmt: on

       return input_ids, attention_mask, bbox, token_type_ids, labels







@require_tf
class      lowerCAmelCase__       (				unittest.TestCase):




     '''simple docstring'''


     @slow
     def  _lowerCamelCase (						self)			->				str:
            _A      :       Any				    = TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased")

            _A    ,			_A    ,			_A    ,			_A    ,			_A      :       str				    = prepare_layoutlm_batch_inputs()

            # forward pass
            _A      :       Dict				    = model(input_ids=__lowerCamelCase ,						bbox=__lowerCamelCase ,						attention_mask=__lowerCamelCase ,						token_type_ids=__lowerCamelCase)

            # test the sequence output on [0, :3, :3]
            _A      :       Tuple				    = tf.convert_to_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]] ,						)

            self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3] ,						__lowerCamelCase ,						atol=1e-3))

            # test the pooled output on [1, :3]
            _A      :       int				    = tf.convert_to_tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2])

            self.assertTrue(np.allclose(outputs.pooler_output[1, :3] ,						__lowerCamelCase ,						atol=1e-3))


     @slow
     def  _lowerCamelCase (						self)			->				Union[str, Any]:
            # initialize model with randomly initialized sequence classification head
            _A      :       str				    = TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased" ,						num_labels=2)

            _A    ,			_A    ,			_A    ,			_A    ,			_A      :       Union[str, Any]				    = prepare_layoutlm_batch_inputs()

            # forward pass
            _A      :       List[Any]				    = model(
                input_ids=__lowerCamelCase ,						bbox=__lowerCamelCase ,						attention_mask=__lowerCamelCase ,						token_type_ids=__lowerCamelCase ,						labels=tf.convert_to_tensor([1, 1]) ,						)

            # test whether we get a loss as a scalar
            _A      :       List[Any]				    = outputs.loss
            _A      :       Dict				    = (2,)
            self.assertEqual(loss.shape ,						__lowerCamelCase)

            # test the shape of the logits
            _A      :       Any				    = outputs.logits
            _A      :       Tuple				    = (2, 2)
            self.assertEqual(logits.shape ,						__lowerCamelCase)


     @slow
     def  _lowerCamelCase (						self)			->				Any:
            # initialize model with randomly initialized token classification head
            _A      :       Dict				    = TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased" ,						num_labels=1_3)

            _A    ,			_A    ,			_A    ,			_A    ,			_A      :       Union[str, Any]				    = prepare_layoutlm_batch_inputs()

            # forward pass
            _A      :       Optional[Any]				    = model(
                input_ids=__lowerCamelCase ,						bbox=__lowerCamelCase ,						attention_mask=__lowerCamelCase ,						token_type_ids=__lowerCamelCase ,						labels=__lowerCamelCase)

            # test the shape of the logits
            _A      :       Any				    = outputs.logits
            _A      :       Optional[int]				    = tf.convert_to_tensor((2, 2_5, 1_3))
            self.assertEqual(logits.shape ,						__lowerCamelCase)


     @slow
     def  _lowerCamelCase (						self)			->				List[Any]:
            # initialize model with randomly initialized token classification head
            _A      :       str				    = TFLayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased")

            _A    ,			_A    ,			_A    ,			_A    ,			_A      :       List[str]				    = prepare_layoutlm_batch_inputs()

            # forward pass
            _A      :       Union[str, Any]				    = model(input_ids=__lowerCamelCase ,						bbox=__lowerCamelCase ,						attention_mask=__lowerCamelCase ,						token_type_ids=__lowerCamelCase)

            # test the shape of the logits
            _A      :       int				    = tf.convert_to_tensor((2, 2_5))
            self.assertEqual(outputs.start_logits.shape ,						__lowerCamelCase)
            self.assertEqual(outputs.end_logits.shape ,						__lowerCamelCase)




import unittest

import torch

from diffusers import VQModel
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()







class      lowerCAmelCase__       (				a     ,    a     ,    unittest.TestCase):




     '''simple docstring'''
     __SCREAMING_SNAKE_CASE  			= VQModel
     __SCREAMING_SNAKE_CASE  			= "sample"


     @property
     def  _lowerCamelCase (						self ,						__lowerCamelCase=(3_2, 3_2))			->				Optional[Any]:
            _A      :       Optional[int]				    = 4
            _A      :       Tuple				    = 3

            _A      :       List[Any]				    = floats_tensor((batch_size, num_channels) + sizes).to(__lowerCamelCase)

            return {"sample": image}


     @property
     def  _lowerCamelCase (						self)			->				int:
            return (3, 3_2, 3_2)


     @property
     def  _lowerCamelCase (						self)			->				List[Any]:
            return (3, 3_2, 3_2)


     def  _lowerCamelCase (						self)			->				Union[str, Any]:
            _A      :       List[Any]				    = {
                "block_out_channels": [3_2, 6_4],
                "in_channels": 3,
                "out_channels": 3,
                "down_block_types": ["DownEncoderBlock2D", "DownEncoderBlock2D"],
                "up_block_types": ["UpDecoderBlock2D", "UpDecoderBlock2D"],
                "latent_channels": 3,
            }
            _A      :       int				    = self.dummy_input
            return init_dict, inputs_dict


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


     def  _lowerCamelCase (						self)			->				Any:
            pass


     def  _lowerCamelCase (						self)			->				Any:
            _A    ,			_A      :       List[Any]				    = VQModel.from_pretrained("fusing/vqgan-dummy" ,						output_loading_info=__lowerCamelCase)
            self.assertIsNotNone(__lowerCamelCase)
            self.assertEqual(len(loading_info["missing_keys"]) ,						0)

            model.to(__lowerCamelCase)
            _A      :       str				    = model(**self.dummy_input)

            assert image is not None, "Make sure output is not None"


     def  _lowerCamelCase (						self)			->				Union[str, Any]:
            _A      :       Optional[Any]				    = VQModel.from_pretrained("fusing/vqgan-dummy")
            model.to(__lowerCamelCase).eval()

            torch.manual_seed(0)
            if torch.cuda.is_available():
                   torch.cuda.manual_seed_all(0)

            _A      :       Tuple				    = torch.randn(1 ,						model.config.in_channels ,						model.config.sample_size ,						model.config.sample_size)
            _A      :       Optional[int]				    = image.to(__lowerCamelCase)
            with torch.no_grad():
                   _A      :       List[str]				    = model(__lowerCamelCase).sample

            _A      :       int				    = output[0, -1, -3:, -3:].flatten().cpu()
            # fmt: off
            _A      :       Optional[Any]				    = torch.tensor([-0.0_1_5_3, -0.4_0_4_4, -0.1_8_8_0, -0.5_1_6_1, -0.2_4_1_8, -0.4_0_7_2, -0.1_6_1_2, -0.0_6_3_3, -0.0_1_4_3])
            # fmt: on
            self.assertTrue(torch.allclose(__lowerCamelCase ,						__lowerCamelCase ,						atol=1e-3))
