


"""simple docstring"""
from __future__ import annotations

import copy
import inspect
import unittest

import numpy as np

from transformers import is_tf_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from transformers.utils import cached_property

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


if is_tf_available():
				import tensorflow as tf

				from transformers import (
				    TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
				    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
				    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
				    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
				    LayoutLMvaConfig,
				    TFLayoutLMvaForQuestionAnswering,
				    TFLayoutLMvaForSequenceClassification,
				    TFLayoutLMvaForTokenClassification,
				    TFLayoutLMvaModel,
				)

if is_vision_available():
				from PIL import Image

				from transformers import LayoutLMvaImageProcessor





class      __A     :





							'''simple docstring'''

							def __init__(				self							:      int		,       UpperCAmelCase_							:      List[Any]		,       UpperCAmelCase_							:      str=2		,       UpperCAmelCase_							:      Union[str, Any]=3		,       UpperCAmelCase_							:      Union[str, Any]=4		,       UpperCAmelCase_							:      List[str]=2		,       UpperCAmelCase_							:      Dict=7		,       UpperCAmelCase_							:      Tuple=True		,       UpperCAmelCase_							:      Optional[Any]=True		,       UpperCAmelCase_							:      int=True		,       UpperCAmelCase_							:      List[Any]=True		,       UpperCAmelCase_							:      Tuple=99		,       UpperCAmelCase_							:      Optional[int]=36		,       UpperCAmelCase_							:      Tuple=2		,       UpperCAmelCase_							:      Tuple=4		,       UpperCAmelCase_							:      Dict=37		,       UpperCAmelCase_							:      Optional[Any]="gelu"		,       UpperCAmelCase_							:      Tuple=0.1		,       UpperCAmelCase_							:      List[Any]=0.1		,       UpperCAmelCase_							:      Optional[int]=512		,       UpperCAmelCase_							:      Optional[int]=16		,       UpperCAmelCase_							:      int=2		,       UpperCAmelCase_							:      str=0.02		,       UpperCAmelCase_							:      Tuple=6		,       UpperCAmelCase_							:      Tuple=6		,       UpperCAmelCase_							:      List[Any]=3		,       UpperCAmelCase_							:      Union[str, Any]=4		,       UpperCAmelCase_							:      Tuple=None		,       UpperCAmelCase_							:      List[Any]=1_000		,       )					->Dict:



														"""simple docstring"""



														snake_case_           =		parent
														snake_case_           =		batch_size
														snake_case_           =		num_channels
														snake_case_           =		image_size
														snake_case_           =		patch_size
														snake_case_           =		is_training
														snake_case_           =		use_input_mask
														snake_case_           =		use_token_type_ids
														snake_case_           =		use_labels
														snake_case_           =		vocab_size
														snake_case_           =		hidden_size
														snake_case_           =		num_hidden_layers
														snake_case_           =		num_attention_heads
														snake_case_           =		intermediate_size
														snake_case_           =		hidden_act
														snake_case_           =		hidden_dropout_prob
														snake_case_           =		attention_probs_dropout_prob
														snake_case_           =		max_position_embeddings
														snake_case_           =		type_vocab_size
														snake_case_           =		type_sequence_label_size
														snake_case_           =		initializer_range
														snake_case_           =		coordinate_size
														snake_case_           =		shape_size
														snake_case_           =		num_labels
														snake_case_           =		num_choices
														snake_case_           =		scope
														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)
														snake_case_           =		text_seq_length
														snake_case_           =		(image_size // patch_size) ** 2 + 1
														snake_case_           =		self.text_seq_length + self.image_seq_length



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



														"""simple docstring"""



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

														snake_case_           =		ids_tensor([self.batch_size, self.text_seq_length, 4]		,       self.range_bbox       )
														snake_case_           =		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_           =		bbox[i, j, 3]
																																			snake_case_           =		bbox[i, j, 1]
																																			snake_case_           =		tmp_coordinate
																												if bbox[i, j, 2] < bbox[i, j, 0]:
																																			snake_case_           =		bbox[i, j, 2]
																																			snake_case_           =		bbox[i, j, 0]
																																			snake_case_           =		tmp_coordinate
														snake_case_           =		tf.constant(UpperCAmelCase_       )

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

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

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

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

														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 		lowerCAmelCase       (				self							:      int		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      Union[str, Any]		,       UpperCAmelCase_							:      Optional[Any]		,       UpperCAmelCase_							:      Tuple		,       UpperCAmelCase_							:      Tuple		,       UpperCAmelCase_							:      Optional[Any]       )					->Optional[Any]:



														"""simple docstring"""



														snake_case_           =		TFLayoutLMvaModel(config=UpperCAmelCase_       )

														# text + image
														snake_case_           =		model(UpperCAmelCase_		,       pixel_values=UpperCAmelCase_		,       training=UpperCAmelCase_       )
														snake_case_           =		model(
														    UpperCAmelCase_		,       bbox=UpperCAmelCase_		,       pixel_values=UpperCAmelCase_		,       attention_mask=UpperCAmelCase_		,       token_type_ids=UpperCAmelCase_		,       training=UpperCAmelCase_		,       )
														snake_case_           =		model(UpperCAmelCase_		,       bbox=UpperCAmelCase_		,       pixel_values=UpperCAmelCase_		,       training=UpperCAmelCase_       )

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

														# text only
														snake_case_           =		model(UpperCAmelCase_		,       training=UpperCAmelCase_       )
														self.parent.assertEqual(
														    result.last_hidden_state.shape		,       (self.batch_size, self.text_seq_length, self.hidden_size)       )

														# image only
														snake_case_           =		model({"""pixel_values""": pixel_values}		,       training=UpperCAmelCase_       )
														self.parent.assertEqual(
														    result.last_hidden_state.shape		,       (self.batch_size, self.image_seq_length, self.hidden_size)       )



							def 		lowerCAmelCase       (				self							:      Union[str, Any]		,       UpperCAmelCase_							:      List[str]		,       UpperCAmelCase_							:      Optional[int]		,       UpperCAmelCase_							:      Union[str, Any]		,       UpperCAmelCase_							:      List[Any]		,       UpperCAmelCase_							:      List[str]		,       UpperCAmelCase_							:      str		,       UpperCAmelCase_							:      Dict       )					->Optional[int]:



														"""simple docstring"""



														snake_case_           =		self.num_labels
														snake_case_           =		TFLayoutLMvaForSequenceClassification(config=UpperCAmelCase_       )
														snake_case_           =		model(
														    UpperCAmelCase_		,       bbox=UpperCAmelCase_		,       pixel_values=UpperCAmelCase_		,       attention_mask=UpperCAmelCase_		,       token_type_ids=UpperCAmelCase_		,       labels=UpperCAmelCase_		,       training=UpperCAmelCase_		,       )
														self.parent.assertEqual(result.logits.shape		,       (self.batch_size, self.num_labels)       )



							def 		lowerCAmelCase       (				self							:      str		,       UpperCAmelCase_							:      Tuple		,       UpperCAmelCase_							:      str		,       UpperCAmelCase_							:      Tuple		,       UpperCAmelCase_							:      Optional[Any]		,       UpperCAmelCase_							:      str		,       UpperCAmelCase_							:      List[str]		,       UpperCAmelCase_							:      Dict       )					->int:



														"""simple docstring"""



														snake_case_           =		self.num_labels
														snake_case_           =		TFLayoutLMvaForTokenClassification(config=UpperCAmelCase_       )
														snake_case_           =		model(
														    UpperCAmelCase_		,       bbox=UpperCAmelCase_		,       pixel_values=UpperCAmelCase_		,       attention_mask=UpperCAmelCase_		,       token_type_ids=UpperCAmelCase_		,       labels=UpperCAmelCase_		,       training=UpperCAmelCase_		,       )
														self.parent.assertEqual(result.logits.shape		,       (self.batch_size, self.text_seq_length, self.num_labels)       )



							def 		lowerCAmelCase       (				self							:      int		,       UpperCAmelCase_							:      Any		,       UpperCAmelCase_							:      Dict		,       UpperCAmelCase_							:      Tuple		,       UpperCAmelCase_							:      Tuple		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      int       )					->Union[str, Any]:



														"""simple docstring"""



														snake_case_           =		2
														snake_case_           =		TFLayoutLMvaForQuestionAnswering(config=UpperCAmelCase_       )
														snake_case_           =		model(
														    UpperCAmelCase_		,       bbox=UpperCAmelCase_		,       pixel_values=UpperCAmelCase_		,       attention_mask=UpperCAmelCase_		,       token_type_ids=UpperCAmelCase_		,       start_positions=UpperCAmelCase_		,       end_positions=UpperCAmelCase_		,       training=UpperCAmelCase_		,       )
														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							:      Union[str, Any]       )					->str:



														"""simple docstring"""



														snake_case_           =		self.prepare_config_and_inputs()
														((snake_case_)       ,						(snake_case_)       ,						(snake_case_)       ,						(snake_case_)       ,						(snake_case_)       ,						(snake_case_)       ,						(snake_case_)       ,						(snake_case_))           =		config_and_inputs
														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_tf
class      __A     (snake_case__						,		snake_case__						,		unittest.TestCase):





							'''simple docstring'''

							__lowercase:		List[Any]							      =    (
							    (
							        TFLayoutLMvaModel,
							        TFLayoutLMvaForQuestionAnswering,
							        TFLayoutLMvaForSequenceClassification,
							        TFLayoutLMvaForTokenClassification,
							    )
							    if is_tf_available()
							    else ()
							)
							__lowercase:		Optional[int]							      =    (
							    {"""document-question-answering""": TFLayoutLMvaForQuestionAnswering, """feature-extraction""": TFLayoutLMvaModel}
							    if is_tf_available()
							    else {}
							)

							__lowercase:		Any							      =    False
							__lowercase:		List[str]							      =    False
							__lowercase:		Optional[int]							      =    False



							def 		lowerCAmelCase       (				self							:      int		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      Optional[Any]		,       UpperCAmelCase_							:      Dict		,       UpperCAmelCase_							:      Optional[int]		,       UpperCAmelCase_							:      Dict       )					->Optional[int]:



														"""simple docstring"""



														return True



							def 		lowerCAmelCase       (				self							:      Optional[Any]		,       UpperCAmelCase_							:      Optional[Any]		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      List[str]=False       )					->dict:



														"""simple docstring"""



														snake_case_           =		copy.deepcopy(UpperCAmelCase_       )

														if model_class in get_values(UpperCAmelCase_       ):
																					snake_case_           =		{
																					    k: tf.tile(tf.expand_dims(UpperCAmelCase_		,       1       )		,       (1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)       )
																					    if isinstance(UpperCAmelCase_		,       tf.Tensor       ) and v.ndim > 0
																					    else v
																					    for k, v in inputs_dict.items()
																					}

														if return_labels:
																					if model_class in get_values(UpperCAmelCase_       ):
																												snake_case_           =		tf.ones(self.model_tester.batch_size		,       dtype=tf.intaa       )
																					elif model_class in get_values(UpperCAmelCase_       ):
																												snake_case_           =		tf.zeros(self.model_tester.batch_size		,       dtype=tf.intaa       )
																												snake_case_           =		tf.zeros(self.model_tester.batch_size		,       dtype=tf.intaa       )
																					elif model_class in get_values(UpperCAmelCase_       ):
																												snake_case_           =		tf.zeros(self.model_tester.batch_size		,       dtype=tf.intaa       )
																					elif model_class in get_values(UpperCAmelCase_       ):
																												snake_case_           =		tf.zeros(
																												    (self.model_tester.batch_size, self.model_tester.text_seq_length)		,       dtype=tf.intaa       )

														return inputs_dict



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



														"""simple docstring"""



														snake_case_           =		TFLayoutLMvaModelTester(self       )
														snake_case_           =		ConfigTester(self		,       config_class=UpperCAmelCase_		,       hidden_size=37       )



							def 		lowerCAmelCase       (				self							:      str       )					->List[Any]:



														"""simple docstring"""



														self.config_tester.run_common_tests()



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



														"""simple docstring"""



														snake_case_       ,						snake_case_           =		self.model_tester.prepare_config_and_inputs_for_common()
														for model_class in self.all_model_classes:
																					snake_case_           =		model_class(UpperCAmelCase_       )
																					if getattr(UpperCAmelCase_		,       """hf_compute_loss"""		,       UpperCAmelCase_       ):
																												# The number of elements in the loss should be the same as the number of elements in the label
																												snake_case_           =		self._prepare_for_class(inputs_dict.copy()		,       UpperCAmelCase_		,       return_labels=UpperCAmelCase_       )
																												snake_case_           =		prepared_for_class[
																												    sorted(prepared_for_class.keys() - inputs_dict.keys()		,       reverse=UpperCAmelCase_       )[0]
																												]
																												snake_case_           =		added_label.shape.as_list()[:1]

																												# Test that model correctly compute the loss with kwargs
																												snake_case_           =		self._prepare_for_class(inputs_dict.copy()		,       UpperCAmelCase_		,       return_labels=UpperCAmelCase_       )
																												snake_case_           =		prepared_for_class.pop("""input_ids"""       )

																												snake_case_           =		model(UpperCAmelCase_		,       **UpperCAmelCase_       )[0]
																												self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]       )

																												# Test that model correctly compute the loss when we mask some positions
																												snake_case_           =		self._prepare_for_class(inputs_dict.copy()		,       UpperCAmelCase_		,       return_labels=UpperCAmelCase_       )
																												snake_case_           =		prepared_for_class.pop("""input_ids"""       )
																												if "labels" in prepared_for_class:
																																			snake_case_           =		prepared_for_class["""labels"""].numpy()
																																			if len(labels.shape       ) > 1 and labels.shape[1] != 1:
																																										snake_case_           =		-100
																																										snake_case_           =		tf.convert_to_tensor(UpperCAmelCase_       )
																																										snake_case_           =		model(UpperCAmelCase_		,       **UpperCAmelCase_       )[0]
																																										self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]       )
																																										self.assertTrue(not np.any(np.isnan(loss.numpy()       )       )       )

                # Test that model correctly compute the loss with a dict
																												snake_case_           =		self._prepare_for_class(inputs_dict.copy()		,       UpperCAmelCase_		,       return_labels=UpperCAmelCase_       )
																												snake_case_           =		model(UpperCAmelCase_       )[0]
																												self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]       )

																												# Test that model correctly compute the loss with a tuple
																												snake_case_           =		self._prepare_for_class(inputs_dict.copy()		,       UpperCAmelCase_		,       return_labels=UpperCAmelCase_       )

																												# Get keys that were added with the _prepare_for_class function
																												snake_case_           =		prepared_for_class.keys() - inputs_dict.keys()
																												snake_case_           =		inspect.signature(model.call       ).parameters
																												snake_case_           =		list(signature.keys()       )

																												# Create a dictionary holding the location of the tensors in the tuple
																												snake_case_           =		{0: """input_ids"""}
																												for label_key in label_keys:
																																			snake_case_           =		signature_names.index(UpperCAmelCase_       )
																																			snake_case_           =		label_key
																												snake_case_           =		sorted(tuple_index_mapping.items()       )
																												# Initialize a list with their default values, update the values and convert to a tuple
																												snake_case_           =		[]

																												for name in signature_names:
																																			if name != "kwargs":
																																										list_input.append(signature[name].default       )

																												for index, value in sorted_tuple_index_mapping:
																																			snake_case_           =		prepared_for_class[value]

																												snake_case_           =		tuple(UpperCAmelCase_       )

																												# Send to model
																												snake_case_           =		model(tuple_input[:-1]       )[0]

																												self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]       )



							def 		lowerCAmelCase       (				self							:      Any       )					->Dict:



														"""simple docstring"""



														(
														    (
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						
														)           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_       )



							def 		lowerCAmelCase       (				self							:      Tuple       )					->Dict:



														"""simple docstring"""



														(
														    (
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						
														)           =		self.model_tester.prepare_config_and_inputs()
														for type in ["absolute", "relative_key", "relative_key_query"]:
																					snake_case_           =		type
																					self.model_tester.create_and_check_model(UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_       )



							def 		lowerCAmelCase       (				self							:      Optional[int]       )					->int:



														"""simple docstring"""



														(
														    (
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						
														)           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_sequence_classification(
														    UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_       )



							def 		lowerCAmelCase       (				self							:      int       )					->Optional[Any]:



														"""simple docstring"""



														(
														    (
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						
														)           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_token_classification(
														    UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_       )



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



														"""simple docstring"""



														(
														    (
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						(
														    snake_case_
														)       ,						
														)           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_for_question_answering(
														    UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_       )



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



														"""simple docstring"""



														for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																					snake_case_           =		TFLayoutLMvaModel.from_pretrained(UpperCAmelCase_       )
																					self.assertIsNotNone(UpperCAmelCase_       )







def 						_a				(      )    ->				Any:
							snake_case_           =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""				)
							return image





@require_tf
class      __A     (unittest.TestCase):





							'''simple docstring'''

							@cached_property
							def 		lowerCAmelCase       (				self							:      int       )					->Any:



														"""simple docstring"""



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



							@slow
							def 		lowerCAmelCase       (				self							:      List[Any]       )					->List[Any]:



														"""simple docstring"""



														snake_case_           =		TFLayoutLMvaModel.from_pretrained("""microsoft/layoutlmv3-base"""       )

														snake_case_           =		self.default_image_processor
														snake_case_           =		prepare_img()
														snake_case_           =		image_processor(images=UpperCAmelCase_		,       return_tensors="""tf"""       ).pixel_values

														snake_case_           =		tf.constant([[1, 2]]       )
														snake_case_           =		tf.expand_dims(tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]]       )		,       axis=0       )

														# forward pass
														snake_case_           =		model(input_ids=UpperCAmelCase_		,       bbox=UpperCAmelCase_		,       pixel_values=UpperCAmelCase_		,       training=UpperCAmelCase_       )

														# verify the logits
														snake_case_           =		(1, 199, 768)
														self.assertEqual(outputs.last_hidden_state.shape		,       UpperCAmelCase_       )

														snake_case_           =		tf.constant(
														    [[-0.0_529, 0.3_618, 0.1_632], [-0.1_587, -0.1_667, -0.0_400], [-0.1_557, -0.1_671, -0.0_505]]       )

														self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]		,       UpperCAmelCase_		,       atol=1E-4       )       )







"""simple docstring"""
from __future__ import annotations

from collections import deque





class      __A     :





							'''simple docstring'''

							def __init__(				self							:      List[Any]		,       UpperCAmelCase_							:      list[str]       )					->List[Any]:



														"""simple docstring"""



														snake_case_           =		[]
														self.adlist.append(
														    {"""value""": """""", """next_states""": [], """fail_state""": 0, """output""": []}       )

														for keyword in keywords:
																					self.add_keyword(UpperCAmelCase_       )
														self.set_fail_transitions()



							def 		lowerCAmelCase       (				self							:      int		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      str       )					->int | None:



														"""simple docstring"""



														for state in self.adlist[current_state]["next_states"]:
																					if char == self.adlist[state]["value"]:
																												return state
														return None



							def 		lowerCAmelCase       (				self							:      int		,       UpperCAmelCase_							:      str       )					->None:



														"""simple docstring"""



														snake_case_           =		0
														for character in keyword:
																					snake_case_           =		self.find_next_state(UpperCAmelCase_		,       UpperCAmelCase_       )
																					if next_state is None:
																												self.adlist.append(
																												    {
																												        """value""": character,
																												        """next_states""": [],
																												        """fail_state""": 0,
																												        """output""": [],
																												    }       )
																												self.adlist[current_state]["next_states"].append(len(self.adlist       ) - 1       )
																												snake_case_           =		len(self.adlist       ) - 1
																					else:
																												snake_case_           =		next_state
														self.adlist[current_state]["output"].append(UpperCAmelCase_       )



							def 		lowerCAmelCase       (				self							:      Optional[Any]       )					->None:



														"""simple docstring"""



														snake_case_           =		deque()
														for node in self.adlist[0]["next_states"]:
																					q.append(UpperCAmelCase_       )
																					snake_case_           =		0
														while q:
																					snake_case_           =		q.popleft()
																					for child in self.adlist[r]["next_states"]:
																												q.append(UpperCAmelCase_       )
																												snake_case_           =		self.adlist[r]["""fail_state"""]
																												while (
																												    self.find_next_state(UpperCAmelCase_		,       self.adlist[child]["""value"""]       ) is None
																												    and state != 0
																												):
																																			snake_case_           =		self.adlist[state]["""fail_state"""]
																												snake_case_           =		self.find_next_state(
																												    UpperCAmelCase_		,       self.adlist[child]["""value"""]       )
																												if self.adlist[child]["fail_state"] is None:
																																			snake_case_           =		0
																												snake_case_           =		(
																												    self.adlist[child]["""output"""]
																												    + self.adlist[self.adlist[child]["""fail_state"""]]["""output"""]
																												)



							def 		lowerCAmelCase       (				self							:      Union[str, Any]		,       UpperCAmelCase_							:      str       )					->dict[str, list[int]]:



														"""simple docstring"""



														snake_case_           =		{}  # returns a dict with keywords and list of its occurrences
														snake_case_           =		0
														for i in range(len(UpperCAmelCase_       )       ):
																					while (
																					    self.find_next_state(UpperCAmelCase_		,       string[i]       ) is None
																					    and current_state != 0
																					):
																												snake_case_           =		self.adlist[current_state]["""fail_state"""]
																					snake_case_           =		self.find_next_state(UpperCAmelCase_		,       string[i]       )
																					if next_state is None:
																												snake_case_           =		0
																					else:
																												snake_case_           =		next_state
																												for key in self.adlist[current_state]["output"]:
																																			if key not in result:
																																										snake_case_           =		[]
																																			result[key].append(i - len(UpperCAmelCase_       ) + 1       )
														return result


if __name__ == "__main__":
				import doctest

				doctest.testmod()



