
import unittest

from transformers import 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, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       RemBertConfig,
       RemBertForCausalLM,
       RemBertForMaskedLM,
       RemBertForMultipleChoice,
       RemBertForQuestionAnswering,
       RemBertForSequenceClassification,
       RemBertForTokenClassification,
       RemBertModel,
   )
   from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST





class   __UpperCamelCase				:






     """simple docstring"""







     def __init__(							self    :    Optional[int]      ,		_A    :    str      ,		_A    :    List[Any]=13      ,		_A    :    int=7      ,		_A    :    Optional[Any]=True      ,		_A    :    Optional[Any]=True      ,		_A    :    Optional[int]=True      ,		_A    :    str=True      ,		_A    :    int=99      ,		_A    :    Dict=32      ,		_A    :    Dict=18      ,		_A    :    Any=43      ,		_A    :    Dict=5      ,		_A    :    Any=4      ,		_A    :    Optional[Any]=37      ,		_A    :    int="gelu"      ,		_A    :    Optional[int]=0.1      ,		_A    :    Union[str, Any]=0.1      ,		_A    :    Union[str, Any]=512      ,		_A    :    Dict=16      ,		_A    :    List[Any]=2      ,		_A    :    str=0.02      ,		_A    :    str=3      ,		_A    :    Tuple=4      ,		_A    :    Optional[Any]=None      ,		):







       """simple docstring"""




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



     def 				UpperCAmelCase__    (							self    :    Optional[int]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						ids_tensor([self.batch_size, self.seq_length]      ,		self.vocab_size				)

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

       __SCREAMING_SNAKE_CASE     :					Tuple			=						None
       if self.use_token_type_ids:
         __SCREAMING_SNAKE_CASE     :					List[str]			=						ids_tensor([self.batch_size, self.seq_length]      ,		self.type_vocab_size				)

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

       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						RemBertConfig(
           vocab_size=self.vocab_size      ,		hidden_size=self.hidden_size      ,		input_embedding_size=self.input_embedding_size      ,		output_embedding_size=self.output_embedding_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      ,		is_decoder=_A      ,		initializer_range=self.initializer_range      ,		)

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



     def 				UpperCAmelCase__    (							self    :    Union[str, Any]				):







       """simple docstring"""




       (
           __SCREAMING_SNAKE_CASE						
       )     :					Union[str, Any]			=						self.prepare_config_and_inputs()

       __SCREAMING_SNAKE_CASE     :					List[Any]			=						True
       __SCREAMING_SNAKE_CASE     :					Dict			=						floats_tensor([self.batch_size, self.seq_length, self.hidden_size]				)
       __SCREAMING_SNAKE_CASE     :					Tuple			=						ids_tensor([self.batch_size, self.seq_length]      ,		vocab_size=2				)

       return (
           config,
           input_ids,
           token_type_ids,
           input_mask,
           sequence_labels,
           token_labels,
           choice_labels,
           encoder_hidden_states,
           encoder_attention_mask,
       )



     def 				UpperCAmelCase__    (							self    :    Optional[Any]      ,		_A    :    Optional[int]      ,		_A    :    Union[str, Any]      ,		_A    :    Optional[Any]      ,		_A    :    Optional[int]      ,		_A    :    List[Any]      ,		_A    :    Optional[int]      ,		_A    :    int				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					int			=						RemBertModel(config=_A				)
       model.to(_A				)
       model.eval()
       __SCREAMING_SNAKE_CASE     :					Any			=						model(_A      ,		attention_mask=_A      ,		token_type_ids=_A				)
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						model(_A      ,		token_type_ids=_A				)
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						model(_A				)
       self.parent.assertEqual(result.last_hidden_state.shape      ,		(self.batch_size, self.seq_length, self.hidden_size)				)



     def 				UpperCAmelCase__    (							self    :    int      ,		_A    :    Union[str, Any]      ,		_A    :    Optional[Any]      ,		_A    :    List[Any]      ,		_A    :    int      ,		_A    :    Dict      ,		_A    :    Dict      ,		_A    :    Union[str, Any]      ,		_A    :    Optional[int]      ,		_A    :    Dict      ,		):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					int			=						True
       __SCREAMING_SNAKE_CASE     :					Tuple			=						RemBertModel(_A				)
       model.to(_A				)
       model.eval()
       __SCREAMING_SNAKE_CASE     :					Any			=						model(
           _A      ,		attention_mask=_A      ,		token_type_ids=_A      ,		encoder_hidden_states=_A      ,		encoder_attention_mask=_A      ,		)
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						model(
           _A      ,		attention_mask=_A      ,		token_type_ids=_A      ,		encoder_hidden_states=_A      ,		)
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						model(_A      ,		attention_mask=_A      ,		token_type_ids=_A				)
       self.parent.assertEqual(result.last_hidden_state.shape      ,		(self.batch_size, self.seq_length, self.hidden_size)				)



     def 				UpperCAmelCase__    (							self    :    Dict      ,		_A    :    str      ,		_A    :    str      ,		_A    :    str      ,		_A    :    Union[str, Any]      ,		_A    :    List[str]      ,		_A    :    str      ,		_A    :    List[str]      ,		_A    :    Optional[Any]      ,		_A    :    str      ,		):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					str			=						RemBertForCausalLM(config=_A				)
       model.to(_A				)
       model.eval()
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						model(_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 				UpperCAmelCase__    (							self    :    str      ,		_A    :    Optional[Any]      ,		_A    :    Union[str, Any]      ,		_A    :    int      ,		_A    :    Any      ,		_A    :    Optional[Any]      ,		_A    :    Any      ,		_A    :    Dict				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					str			=						RemBertForMaskedLM(config=_A				)
       model.to(_A				)
       model.eval()
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						model(_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 				UpperCAmelCase__    (							self    :    Union[str, Any]      ,		_A    :    List[str]      ,		_A    :    str      ,		_A    :    List[str]      ,		_A    :    Tuple      ,		_A    :    Optional[Any]      ,		_A    :    Dict      ,		_A    :    Optional[Any]      ,		_A    :    str      ,		_A    :    Optional[int]      ,		):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					List[str]			=						True
       __SCREAMING_SNAKE_CASE     :					List[Any]			=						True
       __SCREAMING_SNAKE_CASE     :					Tuple			=						RemBertForCausalLM(config=_A				)
       model.to(_A				)
       model.eval()

       # first forward pass
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						model(
           _A      ,		attention_mask=_A      ,		encoder_hidden_states=_A      ,		encoder_attention_mask=_A      ,		use_cache=_A      ,		)
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						outputs.past_key_values

       # create hypothetical multiple next token and extent to next_input_ids
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						ids_tensor((self.batch_size, 3)      ,		config.vocab_size				)
       __SCREAMING_SNAKE_CASE     :					List[Any]			=						ids_tensor((self.batch_size, 3)      ,		vocab_size=2				)

       # append to next input_ids and
       __SCREAMING_SNAKE_CASE     :					List[Any]			=						torch.cat([input_ids, next_tokens]      ,		dim=-1				)
       __SCREAMING_SNAKE_CASE     :					str			=						torch.cat([input_mask, next_mask]      ,		dim=-1				)

       __SCREAMING_SNAKE_CASE     :					int			=						model(
           _A      ,		attention_mask=_A      ,		encoder_hidden_states=_A      ,		encoder_attention_mask=_A      ,		output_hidden_states=_A      ,		)['''hidden_states'''][0]
       __SCREAMING_SNAKE_CASE     :					Any			=						model(
           _A      ,		attention_mask=_A      ,		encoder_hidden_states=_A      ,		encoder_attention_mask=_A      ,		past_key_values=_A      ,		output_hidden_states=_A      ,		)['''hidden_states'''][0]

       # select random slice
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						ids_tensor((1,)      ,		output_from_past.shape[-1]				).item()
       __SCREAMING_SNAKE_CASE     :					Tuple			=						output_from_no_past[:, -3:, random_slice_idx].detach()
       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						output_from_past[:, :, random_slice_idx].detach()

       self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]				)

       # test that outputs are equal for slice
       self.parent.assertTrue(torch.allclose(_A      ,		_A      ,		atol=1e-3				)				)



     def 				UpperCAmelCase__    (							self    :    Optional[int]      ,		_A    :    Any      ,		_A    :    Any      ,		_A    :    Tuple      ,		_A    :    Optional[Any]      ,		_A    :    Optional[int]      ,		_A    :    Union[str, Any]      ,		_A    :    Union[str, Any]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Tuple			=						RemBertForQuestionAnswering(config=_A				)
       model.to(_A				)
       model.eval()
       __SCREAMING_SNAKE_CASE     :					Any			=						model(
           _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 				UpperCAmelCase__    (							self    :    Optional[Any]      ,		_A    :    Union[str, Any]      ,		_A    :    List[Any]      ,		_A    :    Optional[Any]      ,		_A    :    List[str]      ,		_A    :    Tuple      ,		_A    :    List[Any]      ,		_A    :    int				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					List[Any]			=						self.num_labels
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						RemBertForSequenceClassification(_A				)
       model.to(_A				)
       model.eval()
       __SCREAMING_SNAKE_CASE     :					Tuple			=						model(_A      ,		attention_mask=_A      ,		token_type_ids=_A      ,		labels=_A				)
       self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.num_labels)				)



     def 				UpperCAmelCase__    (							self    :    Optional[Any]      ,		_A    :    Any      ,		_A    :    str      ,		_A    :    Tuple      ,		_A    :    int      ,		_A    :    Optional[Any]      ,		_A    :    Dict      ,		_A    :    Optional[Any]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						self.num_labels
       __SCREAMING_SNAKE_CASE     :					Dict			=						RemBertForTokenClassification(config=_A				)
       model.to(_A				)
       model.eval()
       __SCREAMING_SNAKE_CASE     :					List[Any]			=						model(_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 				UpperCAmelCase__    (							self    :    List[str]      ,		_A    :    Tuple      ,		_A    :    Union[str, Any]      ,		_A    :    Dict      ,		_A    :    Optional[int]      ,		_A    :    List[str]      ,		_A    :    Tuple      ,		_A    :    str				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Dict			=						self.num_choices
       __SCREAMING_SNAKE_CASE     :					str			=						RemBertForMultipleChoice(config=_A				)
       model.to(_A				)
       model.eval()
       __SCREAMING_SNAKE_CASE     :					Dict			=						input_ids.unsqueeze(1				).expand(-1      ,		self.num_choices      ,		-1				).contiguous()
       __SCREAMING_SNAKE_CASE     :					int			=						token_type_ids.unsqueeze(1				).expand(-1      ,		self.num_choices      ,		-1				).contiguous()
       __SCREAMING_SNAKE_CASE     :					str			=						input_mask.unsqueeze(1				).expand(-1      ,		self.num_choices      ,		-1				).contiguous()
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						model(
           _A      ,		attention_mask=_A      ,		token_type_ids=_A      ,		labels=_A      ,		)
       self.parent.assertEqual(result.logits.shape      ,		(self.batch_size, self.num_choices)				)




     def 				UpperCAmelCase__    (							self    :    Tuple				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Dict			=						self.prepare_config_and_inputs()
       (
           __SCREAMING_SNAKE_CASE						
       )     :					Dict			=						config_and_inputs
       __SCREAMING_SNAKE_CASE     :					List[Any]			=						{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
       return config, inputs_dict






@require_torch
class   __UpperCamelCase				(    lowerCAmelCase__				,		lowerCAmelCase__				,		unittest.TestCase   ):






     """simple docstring"""







     lowerCAmelCase_     =	(
         (
             RemBertModel,
             RemBertForMaskedLM,
             RemBertForCausalLM,
             RemBertForMultipleChoice,
             RemBertForQuestionAnswering,
             RemBertForSequenceClassification,
             RemBertForTokenClassification,
         )
         if is_torch_available()
         else ()
     )
     lowerCAmelCase_     =	(RemBertForCausalLM,) if is_torch_available() else ()
     lowerCAmelCase_     =	(
         {
             '''feature-extraction''': RemBertModel,
             '''fill-mask''': RemBertForMaskedLM,
             '''question-answering''': RemBertForQuestionAnswering,
             '''text-classification''': RemBertForSequenceClassification,
             '''text-generation''': RemBertForCausalLM,
             '''token-classification''': RemBertForTokenClassification,
             '''zero-shot''': RemBertForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )



     def 				UpperCAmelCase__    (							self    :    Optional[int]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					List[str]			=						RemBertModelTester(self				)
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						ConfigTester(self      ,		config_class=_A      ,		hidden_size=37				)



     def 				UpperCAmelCase__    (							self    :    Any				):







       """simple docstring"""




       self.config_tester.run_common_tests()



     def 				UpperCAmelCase__    (							self    :    str				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					List[str]			=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_A				)



     def 				UpperCAmelCase__    (							self    :    Tuple				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					List[Any]			=						self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
         __SCREAMING_SNAKE_CASE     :					int			=						type
         self.model_tester.create_and_check_model(*_A				)



     def 				UpperCAmelCase__    (							self    :    Union[str, Any]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					List[str]			=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*_A				)



     def 				UpperCAmelCase__    (							self    :    Any				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*_A				)



     def 				UpperCAmelCase__    (							self    :    Union[str, Any]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					List[Any]			=						self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_decoder_model_past_large_inputs(*_A				)



     def 				UpperCAmelCase__    (							self    :    Tuple				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					List[str]			=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*_A				)



     def 				UpperCAmelCase__    (							self    :    Optional[Any]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*_A				)



     def 				UpperCAmelCase__    (							self    :    Tuple				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					List[str]			=						self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_token_classification(*_A				)



     def 				UpperCAmelCase__    (							self    :    Union[str, Any]				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						self.model_tester.prepare_config_and_inputs_for_decoder()
       self.model_tester.create_and_check_model_as_decoder(*_A				)



     def 				UpperCAmelCase__    (							self    :    Optional[int]				):







       """simple docstring"""




       (
           __SCREAMING_SNAKE_CASE						
       )     :					List[str]			=						self.model_tester.prepare_config_and_inputs_for_decoder()

       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						None

       self.model_tester.create_and_check_model_as_decoder(
           _A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		_A      ,		)




     @slow
     def 				UpperCAmelCase__    (							self    :    str				):







       """simple docstring"""




       for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __SCREAMING_SNAKE_CASE     :					str			=						RemBertModel.from_pretrained(_A				)
         self.assertIsNotNone(_A				)






@require_torch
class   __UpperCamelCase				(    unittest.TestCase   ):






     """simple docstring"""







     @slow
     def 				UpperCAmelCase__    (							self    :    str				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Any			=						RemBertModel.from_pretrained('''google/rembert'''				)
       __SCREAMING_SNAKE_CASE     :					int			=						torch.tensor([[312, 5_6498, 313, 2125, 313]]				)
       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						torch.tensor([[0, 0, 0, 1, 1]]				)
       with torch.no_grad():
         __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						model(_A      ,		token_type_ids=_A      ,		output_hidden_states=_A				)

       __SCREAMING_SNAKE_CASE     :					List[str]			=						1152

       __SCREAMING_SNAKE_CASE     :					Tuple			=						torch.Size((1, 5, hidden_size)				)
       self.assertEqual(output['''last_hidden_state'''].shape      ,		_A				)

       __SCREAMING_SNAKE_CASE     :					List[Any]			=						torch.tensor(
           [
               [
                   [0.07_54, -0.20_22, 0.19_04],
                   [-0.33_54, -0.36_92, -0.47_91],
                   [-0.23_14, -0.67_29, -0.07_49],
                   [-0.03_96, -0.31_05, -0.42_34],
                   [-0.15_71, -0.05_25, 0.53_53],
               ]
           ]				)

       # Running on the original tf implementation gives slightly different results here.
       # Not clear why this variations is present
       # TODO: Find reason for discrepancy
       # expected_original_implementation = [[
       #     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
       #     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
       #     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
       #     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
       #     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
       # ]]

       self.assertTrue(torch.allclose(output['''last_hidden_state'''][:, :, :3]      ,		_A      ,		atol=1e-4				)				)




import warnings
from typing import List, Optional, Union

from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding, PaddingStrategy, PreTokenizedInput, TextInput, TruncationStrategy
from ...utils import TensorType





class   __UpperCamelCase				(    lowerCAmelCase__   ):






     """simple docstring"""







     lowerCAmelCase_     =	['''image_processor''', '''tokenizer''']
     lowerCAmelCase_     =	'''LayoutLMv2ImageProcessor'''
     lowerCAmelCase_     =	('''LayoutLMv2Tokenizer''', '''LayoutLMv2TokenizerFast''')



     def __init__(							self    :    Optional[Any]      ,		_A    :    List[Any]=None      ,		_A    :    List[str]=None      ,		**_A    :    int				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Optional[int]			=						None
       if "feature_extractor" in kwargs:
         warnings.warn(
             '''The `feature_extractor` argument is deprecated and will be removed in v5, use `image_processor`'''
             ''' instead.'''      ,		_A      ,		)
         __SCREAMING_SNAKE_CASE     :					Tuple			=						kwargs.pop('''feature_extractor'''				)

       __SCREAMING_SNAKE_CASE     :					List[str]			=						image_processor if image_processor is not None else feature_extractor
       if image_processor is None:
         raise ValueError('''You need to specify an `image_processor`.'''				)
       if tokenizer is None:
         raise ValueError('''You need to specify a `tokenizer`.'''				)

       super().__init__(_A      ,		_A				)



     def __call__(							self    :    Optional[int]      ,		_A    :    Tuple      ,		_A    :    Union[TextInput, PreTokenizedInput, List[TextInput], List[PreTokenizedInput]] = None      ,		_A    :    Optional[Union[PreTokenizedInput, List[PreTokenizedInput]]] = None      ,		_A    :    Union[List[List[int]], List[List[List[int]]]] = None      ,		_A    :    Optional[Union[List[int], List[List[int]]]] = None      ,		_A    :    bool = True      ,		_A    :    Union[bool, str, PaddingStrategy] = False      ,		_A    :    Union[bool, str, TruncationStrategy] = False      ,		_A    :    Optional[int] = None      ,		_A    :    int = 0      ,		_A    :    Optional[int] = None      ,		_A    :    Optional[bool] = None      ,		_A    :    Optional[bool] = None      ,		_A    :    bool = False      ,		_A    :    bool = False      ,		_A    :    bool = False      ,		_A    :    bool = False      ,		_A    :    bool = True      ,		_A    :    Optional[Union[str, TensorType]] = None      ,		**_A    :    Tuple      ,		):







       """simple docstring"""




       if self.image_processor.apply_ocr and (boxes is not None):
         raise ValueError(
             '''You cannot provide bounding boxes if you initialized the image processor with apply_ocr set to True.'''				)

       if self.image_processor.apply_ocr and (word_labels is not None):
         raise ValueError(
             '''You cannot provide word labels if you initialized the image processor with apply_ocr set to True.'''				)

       if return_overflowing_tokens is True and return_offsets_mapping is False:
         raise ValueError('''You cannot return overflowing tokens without returning the offsets mapping.'''				)

       # first, apply the image processor
       __SCREAMING_SNAKE_CASE     :					Optional[Any]			=						self.image_processor(images=_A      ,		return_tensors=_A				)

       # second, apply the tokenizer
       if text is not None and self.image_processor.apply_ocr and text_pair is None:
         if isinstance(_A      ,		_A				):
           __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						[text]  # add batch dimension (as the image processor always adds a batch dimension)
         __SCREAMING_SNAKE_CASE     :					Tuple			=						features['''words''']

       __SCREAMING_SNAKE_CASE     :					str			=						self.tokenizer(
           text=text if text is not None else features['''words''']      ,		text_pair=text_pair if text_pair is not None else None      ,		boxes=boxes if boxes is not None else features['''boxes''']      ,		word_labels=_A      ,		add_special_tokens=_A      ,		padding=_A      ,		truncation=_A      ,		max_length=_A      ,		stride=_A      ,		pad_to_multiple_of=_A      ,		return_token_type_ids=_A      ,		return_attention_mask=_A      ,		return_overflowing_tokens=_A      ,		return_special_tokens_mask=_A      ,		return_offsets_mapping=_A      ,		return_length=_A      ,		verbose=_A      ,		return_tensors=_A      ,		**_A      ,		)

       # add pixel values
       __SCREAMING_SNAKE_CASE     :					str			=						features.pop('''pixel_values'''				)
       if return_overflowing_tokens is True:
         __SCREAMING_SNAKE_CASE     :					str			=						self.get_overflowing_images(_A      ,		encoded_inputs['''overflow_to_sample_mapping''']				)
       __SCREAMING_SNAKE_CASE     :					List[str]			=						images

       return encoded_inputs



     def 				UpperCAmelCase__    (							self    :    List[str]      ,		_A    :    List[Any]      ,		_A    :    Dict				):







       """simple docstring"""




       __SCREAMING_SNAKE_CASE     :					Union[str, Any]			=						[]
       for sample_idx in overflow_to_sample_mapping:
         images_with_overflow.append(images[sample_idx]				)

       if len(_A				) != len(_A				):
         raise ValueError(
             '''Expected length of images to be the same as the length of `overflow_to_sample_mapping`, but got'''
             F''' {len(_A				)} and {len(_A				)}'''				)

       return images_with_overflow



     def 				UpperCAmelCase__    (							self    :    int      ,		*_A    :    Dict      ,		**_A    :    Optional[Any]				):







       """simple docstring"""




       return self.tokenizer.batch_decode(*_A      ,		**_A				)



     def 				UpperCAmelCase__    (							self    :    Union[str, Any]      ,		*_A    :    Union[str, Any]      ,		**_A    :    List[str]				):







       """simple docstring"""




       return self.tokenizer.decode(*_A      ,		**_A				)



     @property
     def 				UpperCAmelCase__    (							self    :    Optional[int]				):







       """simple docstring"""




       return ["input_ids", "bbox", "token_type_ids", "attention_mask", "image"]



     @property
     def 				UpperCAmelCase__    (							self    :    List[str]				):







       """simple docstring"""




       warnings.warn(
           '''`feature_extractor_class` is deprecated and will be removed in v5. Use `image_processor_class` instead.'''      ,		_A      ,		)
       return self.image_processor_class




     @property
     def 				UpperCAmelCase__    (							self    :    List[str]				):







       """simple docstring"""




       warnings.warn(
           '''`feature_extractor` is deprecated and will be removed in v5. Use `image_processor` instead.'''      ,		_A      ,		)
       return self.image_processor
