






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 			snake_case__   :

       '''simple docstring'''



       def __init__(							self			,						a__			,						a__=13			,						a__=7			,						a__=True			,						a__=True			,						a__=True			,						a__=True			,						a__=99			,						a__=32			,						a__=2			,						a__=4			,						a__=37			,						a__="gelu"			,						a__=0.1			,						a__=0.1			,						a__=5_12			,						a__=16			,						a__=2			,						a__=0.02			,						a__=3			,						a__=4			,						a__=None			,						a__=10_00			,						) ->      Dict:






            '''simple docstring'''





            __snake_case			:Any          =						parent
            __snake_case			:int          =						batch_size
            __snake_case			:Dict          =						seq_length
            __snake_case			:Dict          =						is_training
            __snake_case			:int          =						use_input_mask
            __snake_case			:int          =						use_token_type_ids
            __snake_case			:List[Any]          =						use_labels
            __snake_case			:Dict          =						vocab_size
            __snake_case			:int          =						hidden_size
            __snake_case			:Dict          =						num_hidden_layers
            __snake_case			:List[str]          =						num_attention_heads
            __snake_case			:List[Any]          =						intermediate_size
            __snake_case			:List[str]          =						hidden_act
            __snake_case			:Optional[int]          =						hidden_dropout_prob
            __snake_case			:Any          =						attention_probs_dropout_prob
            __snake_case			:int          =						max_position_embeddings
            __snake_case			:Optional[Any]          =						type_vocab_size
            __snake_case			:Any          =						type_sequence_label_size
            __snake_case			:Dict          =						initializer_range
            __snake_case			:Any          =						num_labels
            __snake_case			:List[str]          =						num_choices
            __snake_case			:List[Any]          =						scope
            __snake_case			:Union[str, Any]          =						range_bbox



       def 					__lowercase						(							self    ) ->      str:






            '''simple docstring'''





            __snake_case			:Optional[int]          =						ids_tensor([self.batch_size, self.seq_length]			,						self.vocab_size    )

            # convert bbox to numpy since TF does not support item assignment
            __snake_case			:int          =						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]:
                           __snake_case			:int          =						bbox[i, j, 3]
                           __snake_case			:Dict          =						bbox[i, j, 1]
                           __snake_case			:Optional[int]          =						t
                      if bbox[i, j, 2] < bbox[i, j, 0]:
                           __snake_case			:List[Any]          =						bbox[i, j, 2]
                           __snake_case			:List[str]          =						bbox[i, j, 0]
                           __snake_case			:List[str]          =						t
            __snake_case			:Optional[Any]          =						tf.convert_to_tensor(a__    )

            __snake_case			:Union[str, Any]          =						None
            if self.use_input_mask:
                 __snake_case			:Optional[int]          =						random_attention_mask([self.batch_size, self.seq_length]    )

            __snake_case			:List[str]          =						None
            if self.use_token_type_ids:
                 __snake_case			:Optional[int]          =						ids_tensor([self.batch_size, self.seq_length]			,						self.type_vocab_size    )

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

            __snake_case			:Optional[Any]          =						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 					__lowercase						(							self			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__    ) ->      str:






            '''simple docstring'''





            __snake_case			:List[Any]          =						TFLayoutLMModel(config=a__    )

            __snake_case			:Dict          =						model(a__			,						a__			,						attention_mask=a__			,						token_type_ids=a__    )
            __snake_case			:Tuple          =						model(a__			,						a__			,						token_type_ids=a__    )
            __snake_case			:Dict          =						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 					__lowercase						(							self			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__    ) ->      int:






            '''simple docstring'''





            __snake_case			:int          =						TFLayoutLMForMaskedLM(config=a__    )

            __snake_case			:Union[str, Any]          =						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 					__lowercase						(							self			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__    ) ->      List[Any]:






            '''simple docstring'''





            __snake_case			:Dict          =						self.num_labels
            __snake_case			:str          =						TFLayoutLMForSequenceClassification(config=a__    )

            __snake_case			:int          =						model(a__			,						a__			,						attention_mask=a__			,						token_type_ids=a__    )
            self.parent.assertEqual(result.logits.shape			,						(self.batch_size, self.num_labels)    )



       def 					__lowercase						(							self			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__    ) ->      int:






            '''simple docstring'''





            __snake_case			:Optional[Any]          =						self.num_labels
            __snake_case			:Union[str, Any]          =						TFLayoutLMForTokenClassification(config=a__    )

            __snake_case			:Union[str, Any]          =						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 					__lowercase						(							self			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__			,						a__    ) ->      str:






            '''simple docstring'''





            __snake_case			:Union[str, Any]          =						TFLayoutLMForQuestionAnswering(config=a__    )

            __snake_case			:Any          =						model(a__			,						a__			,						attention_mask=a__			,						token_type_ids=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    ) ->      Optional[Any]:






            '''simple docstring'''





            __snake_case			:Optional[Any]          =						self.prepare_config_and_inputs()
            (
                (
                __snake_case
            )       , (
                __snake_case
            )       , (
                __snake_case
            )       , (
                __snake_case
            )       , (
                __snake_case
            )       , (
                __snake_case
            )       , (
                __snake_case
            )       , (
                __snake_case
            )       , 
            )			:int          =						config_and_inputs
            __snake_case			:int          =						{
                """input_ids""": input_ids,
                """bbox""": bbox,
                """token_type_ids""": token_type_ids,
                """attention_mask""": input_mask,
            }
            return config, inputs_dict




@require_tf
class 			snake_case__   (							lowercase_	,    lowercase_	,    unittest.TestCase):

       '''simple docstring'''
       lowerCamelCase							:				Tuple 				= (
           (
               TFLayoutLMModel,
               TFLayoutLMForMaskedLM,
               TFLayoutLMForTokenClassification,
               TFLayoutLMForSequenceClassification,
               TFLayoutLMForQuestionAnswering,
           )
           if is_tf_available()
           else ()
       )
       lowerCamelCase							:				Any 				= (
           {
               "feature-extraction": TFLayoutLMModel,
               "fill-mask": TFLayoutLMForMaskedLM,
               "text-classification": TFLayoutLMForSequenceClassification,
               "token-classification": TFLayoutLMForTokenClassification,
               "zero-shot": TFLayoutLMForSequenceClassification,
           }
           if is_tf_available()
           else {}
       )
       lowerCamelCase							:				Dict 				= False
       lowerCamelCase							:				Union[str, Any] 				= True
       lowerCamelCase							:				List[Any] 				= 10



       def 					__lowercase						(							self    ) ->      int:






            '''simple docstring'''





            __snake_case			:Tuple          =						TFLayoutLMModelTester(self    )
            __snake_case			:List[Any]          =						ConfigTester(self			,						config_class=a__			,						hidden_size=37    )



       def 					__lowercase						(							self    ) ->      int:






            '''simple docstring'''





            self.config_tester.run_common_tests()



       def 					__lowercase						(							self    ) ->      Any:






            '''simple docstring'''





            __snake_case			:Union[str, Any]          =						self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*a__    )



       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:List[Any]          =						self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_masked_lm(*a__    )



       def 					__lowercase						(							self    ) ->      List[str]:






            '''simple docstring'''





            __snake_case			:Tuple          =						self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_sequence_classification(*a__    )



       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:Optional[int]          =						self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_token_classification(*a__    )



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






            '''simple docstring'''





            __snake_case			:int          =						self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_question_answering(*a__    )



       @slow
       def 					__lowercase						(							self    ) ->      int:






            '''simple docstring'''





            for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __snake_case			:Dict          =						TFLayoutLMModel.from_pretrained(a__    )
                 self.assertIsNotNone(a__    )



       @unittest.skip("""Onnx compliancy broke with TF 2.10"""    )
       def 					__lowercase						(							self    ) ->      Optional[Any]:






            '''simple docstring'''





            pass






def   UpperCamelCase  (       ):




     '''simple docstring'''






     __snake_case			:Optional[Any]          =						tf.convert_to_tensor([[101,1019,1014,1016,1037,1_2849,4747,1004,1_4246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,1_1300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,1_9274,2772,6205,2_7814,1_6147,1_6147,4343,2047,1_0283,1_0969,1_4389,1012,2338,102]]  )  # noqa: E231
     __snake_case			:Dict          =						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
     __snake_case			: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
     __snake_case			:Union[str, 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)
     __snake_case			:Union[str, Any]          =						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 			snake_case__   (							unittest.TestCase):

       '''simple docstring'''



       @slow
       def 					__lowercase						(							self    ) ->      Union[str, Any]:






            '''simple docstring'''





            __snake_case			:List[str]          =						TFLayoutLMModel.from_pretrained("""microsoft/layoutlm-base-uncased"""    )

            __snake_case       , __snake_case       , __snake_case       , __snake_case       , __snake_case			:str          =						prepare_layoutlm_batch_inputs()

            # forward pass
            __snake_case			:str          =						model(input_ids=a__			,						bbox=a__			,						attention_mask=a__			,						token_type_ids=a__    )

            # test the sequence output on [0, :3, :3]
            __snake_case			:str          =						tf.convert_to_tensor(
                [[0.17_85, -0.19_47, -0.04_25], [-0.32_54, -0.28_07, 0.25_53], [-0.53_91, -0.33_22, 0.33_64]]			,						)

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

            # test the pooled output on [1, :3]
            __snake_case			:Optional[Any]          =						tf.convert_to_tensor([-0.65_80, -0.02_14, 0.85_52]    )

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



       @slow
       def 					__lowercase						(							self    ) ->      int:






            '''simple docstring'''





            __snake_case			:List[Any]          =						TFLayoutLMForSequenceClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""			,						num_labels=2    )

            __snake_case       , __snake_case       , __snake_case       , __snake_case       , __snake_case			:List[Any]          =						prepare_layoutlm_batch_inputs()

            # forward pass
            __snake_case			:int          =						model(
                input_ids=a__			,						bbox=a__			,						attention_mask=a__			,						token_type_ids=a__			,						labels=tf.convert_to_tensor([1, 1]    )			,						)

            # test whether we get a loss as a scalar
            __snake_case			:Optional[int]          =						outputs.loss
            __snake_case			:List[Any]          =						(2,)
            self.assertEqual(loss.shape			,						a__    )

            # test the shape of the logits
            __snake_case			:List[str]          =						outputs.logits
            __snake_case			:str          =						(2, 2)
            self.assertEqual(logits.shape			,						a__    )



       @slow
       def 					__lowercase						(							self    ) ->      Dict:






            '''simple docstring'''





            __snake_case			:Dict          =						TFLayoutLMForTokenClassification.from_pretrained("""microsoft/layoutlm-base-uncased"""			,						num_labels=13    )

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

            # forward pass
            __snake_case			:Dict          =						model(
                input_ids=a__			,						bbox=a__			,						attention_mask=a__			,						token_type_ids=a__			,						labels=a__    )

            # test the shape of the logits
            __snake_case			:List[str]          =						outputs.logits
            __snake_case			:Optional[Any]          =						tf.convert_to_tensor((2, 25, 13)    )
            self.assertEqual(logits.shape			,						a__    )



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






            '''simple docstring'''





            __snake_case			:int          =						TFLayoutLMForQuestionAnswering.from_pretrained("""microsoft/layoutlm-base-uncased"""    )

            __snake_case       , __snake_case       , __snake_case       , __snake_case       , __snake_case			:str          =						prepare_layoutlm_batch_inputs()

            # forward pass
            __snake_case			:List[str]          =						model(input_ids=a__			,						bbox=a__			,						attention_mask=a__			,						token_type_ids=a__    )

            # test the shape of the logits
            __snake_case			:str          =						tf.convert_to_tensor((2, 25)    )
            self.assertEqual(outputs.start_logits.shape			,						a__    )
            self.assertEqual(outputs.end_logits.shape			,						a__    )










# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

import torch

from ..models.auto import AutoModelForVisualQuestionAnswering, AutoProcessor
from ..utils import requires_backends
from .base import PipelineTool


if TYPE_CHECKING:
     from PIL import Image




class 			snake_case__   (							lowercase_):

       '''simple docstring'''
       lowerCamelCase							:				Tuple 				= "dandelin/vilt-b32-finetuned-vqa"
       lowerCamelCase							:				List[str] 				= (
           "This is a tool that answers a question about an image. It takes an input named `image` which should be the "
           "image containing the information, as well as a `question` which should be the question in English. It "
           "returns a text that is the answer to the question."
       )
       lowerCamelCase							:				Optional[Any] 				= "image_qa"
       lowerCamelCase							:				str 				= AutoProcessor
       lowerCamelCase							:				Union[str, Any] 				= AutoModelForVisualQuestionAnswering

       lowerCamelCase							:				Any 				= ["image", "text"]
       lowerCamelCase							:				Dict 				= ["text"]



       def __init__(							self			,						*a__			,						**a__    ) ->      Any:






            '''simple docstring'''





            requires_backends(self			,						["""vision"""]    )
            super().__init__(*a__			,						**a__    )



       def 					__lowercase						(							self			,						a__			,						a__    ) ->      int:






            '''simple docstring'''





            return self.pre_processor(a__			,						a__			,						return_tensors="""pt"""    )



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






            '''simple docstring'''





            with torch.no_grad():
                 return self.model(**a__    ).logits



       def 					__lowercase						(							self			,						a__    ) ->      Tuple:






            '''simple docstring'''





            __snake_case			:str          =						outputs.argmax(-1    ).item()
            return self.model.config.idalabel[idx]


