






from ...configuration_utils import PretrainedConfig
from ...utils import is_detectrona_available, logging


__snake_case							 =  logging.get_logger(__name__)

__snake_case							 =  {
    """layoutlmv2-base-uncased""": """https://huggingface.co/microsoft/layoutlmv2-base-uncased/resolve/main/config.json""",
    """layoutlmv2-large-uncased""": """https://huggingface.co/microsoft/layoutlmv2-large-uncased/resolve/main/config.json""",
    # See all LayoutLMv2 models at https://huggingface.co/models?filter=layoutlmv2
}

# soft dependency
if is_detectrona_available():
 import detectrona







class       UpperCAmelCase_						( lowercase			):



      """simple docstring"""
      UpperCamelCase_    : int									='layoutlmv2'
      def __init__(    self   ,    SCREAMING_SNAKE_CASE_=3_0522   ,    SCREAMING_SNAKE_CASE_=768   ,    SCREAMING_SNAKE_CASE_=12   ,    SCREAMING_SNAKE_CASE_=12   ,    SCREAMING_SNAKE_CASE_=3072   ,    SCREAMING_SNAKE_CASE_="gelu"   ,    SCREAMING_SNAKE_CASE_=0.1   ,    SCREAMING_SNAKE_CASE_=0.1   ,    SCREAMING_SNAKE_CASE_=512   ,    SCREAMING_SNAKE_CASE_=2   ,    SCREAMING_SNAKE_CASE_=0.02   ,    SCREAMING_SNAKE_CASE_=1e-12   ,    SCREAMING_SNAKE_CASE_=0   ,    SCREAMING_SNAKE_CASE_=1024   ,    SCREAMING_SNAKE_CASE_=128   ,    SCREAMING_SNAKE_CASE_=32   ,    SCREAMING_SNAKE_CASE_=True   ,    SCREAMING_SNAKE_CASE_=256   ,    SCREAMING_SNAKE_CASE_=64   ,    SCREAMING_SNAKE_CASE_=True   ,    SCREAMING_SNAKE_CASE_=[7, 7, 256]   ,    SCREAMING_SNAKE_CASE_=128   ,    SCREAMING_SNAKE_CASE_=128   ,    SCREAMING_SNAKE_CASE_=True   ,    SCREAMING_SNAKE_CASE_=True   ,    SCREAMING_SNAKE_CASE_=False   ,    SCREAMING_SNAKE_CASE_=None   ,    **SCREAMING_SNAKE_CASE_   ,    )    ->				Optional[Any]:
          super().__init__(
              vocab_size=SCREAMING_SNAKE_CASE_   ,    hidden_size=SCREAMING_SNAKE_CASE_   ,    num_hidden_layers=SCREAMING_SNAKE_CASE_   ,    num_attention_heads=SCREAMING_SNAKE_CASE_   ,    intermediate_size=SCREAMING_SNAKE_CASE_   ,    hidden_act=SCREAMING_SNAKE_CASE_   ,    hidden_dropout_prob=SCREAMING_SNAKE_CASE_   ,    attention_probs_dropout_prob=SCREAMING_SNAKE_CASE_   ,    max_position_embeddings=SCREAMING_SNAKE_CASE_   ,    type_vocab_size=SCREAMING_SNAKE_CASE_   ,    initializer_range=SCREAMING_SNAKE_CASE_   ,    layer_norm_eps=SCREAMING_SNAKE_CASE_   ,    pad_token_id=SCREAMING_SNAKE_CASE_   ,    **SCREAMING_SNAKE_CASE_   ,    )
          UpperCamelCase	:List[str]     							=       max_ad_position_embeddings
          UpperCamelCase	:str     							=       max_rel_pos
          UpperCamelCase	:Dict     							=       rel_pos_bins
          UpperCamelCase	:str     							=       fast_qkv
          UpperCamelCase	:int     							=       max_rel_ad_pos
          UpperCamelCase	:int     							=       rel_ad_pos_bins
          UpperCamelCase	:str     							=       convert_sync_batchnorm
          UpperCamelCase	:List[str]     							=       image_feature_pool_shape
          UpperCamelCase	:List[Any]     							=       coordinate_size
          UpperCamelCase	:Union[str, Any]     							=       shape_size
          UpperCamelCase	:List[Any]     							=       has_relative_attention_bias
          UpperCamelCase	:Optional[Any]     							=       has_spatial_attention_bias
          UpperCamelCase	:Optional[int]     							=       has_visual_segment_embedding
          UpperCamelCase	:Dict     							=       (
              detectrona_config_args if detectrona_config_args is not None else self.get_default_detectrona_config()
          )
      @classmethod
      def    UpperCAmelCase						(    self			)    ->				Optional[int]:
          return {
              "MODEL.MASK_ON": True,
              "MODEL.PIXEL_STD": [57.375, 57.120, 58.395],
              "MODEL.BACKBONE.NAME": "build_resnet_fpn_backbone",
              "MODEL.FPN.IN_FEATURES": ["res2", "res3", "res4", "res5"],
              "MODEL.ANCHOR_GENERATOR.SIZES": [[32], [64], [128], [256], [512]],
              "MODEL.RPN.IN_FEATURES": ["p2", "p3", "p4", "p5", "p6"],
              "MODEL.RPN.PRE_NMS_TOPK_TRAIN": 2000,
              "MODEL.RPN.PRE_NMS_TOPK_TEST": 1000,
              "MODEL.RPN.POST_NMS_TOPK_TRAIN": 1000,
              "MODEL.POST_NMS_TOPK_TEST": 1000,
              "MODEL.ROI_HEADS.NAME": "StandardROIHeads",
              "MODEL.ROI_HEADS.NUM_CLASSES": 5,
              "MODEL.ROI_HEADS.IN_FEATURES": ["p2", "p3", "p4", "p5"],
              "MODEL.ROI_BOX_HEAD.NAME": "FastRCNNConvFCHead",
              "MODEL.ROI_BOX_HEAD.NUM_FC": 2,
              "MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION": 14,
              "MODEL.ROI_MASK_HEAD.NAME": "MaskRCNNConvUpsampleHead",
              "MODEL.ROI_MASK_HEAD.NUM_CONV": 4,
              "MODEL.ROI_MASK_HEAD.POOLER_RESOLUTION": 7,
              "MODEL.RESNETS.DEPTH": 101,
              "MODEL.RESNETS.SIZES": [[32], [64], [128], [256], [512]],
              "MODEL.RESNETS.ASPECT_RATIOS": [[0.5, 1.0, 2.0]],
              "MODEL.RESNETS.OUT_FEATURES": ["res2", "res3", "res4", "res5"],
              "MODEL.RESNETS.NUM_GROUPS": 32,
              "MODEL.RESNETS.WIDTH_PER_GROUP": 8,
              "MODEL.RESNETS.STRIDE_IN_1X1": False,
          }




      def    UpperCAmelCase						(    self			)    ->				str:
          UpperCamelCase	:List[str]     							=       detectrona.config.get_cfg()
          for k, v in self.detectrona_config_args.items():
              UpperCamelCase	:Union[str, Any]     							=       k.split('''.'''			)
              UpperCamelCase	:Optional[Any]     							=       detectrona_config
              for attribute in attributes[:-1]:
                  UpperCamelCase	:List[Any]     							=       getattr(SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_			)
              setattr(SCREAMING_SNAKE_CASE_   ,    attributes[-1]   ,    SCREAMING_SNAKE_CASE_			)

          return detectrona_config













from transformers import (
    DPRContextEncoderTokenizer,
    DPRContextEncoderTokenizerFast,
    DPRQuestionEncoderTokenizer,
    DPRQuestionEncoderTokenizerFast,
    DPRReaderOutput,
    DPRReaderTokenizer,
    DPRReaderTokenizerFast,
)
from transformers.testing_utils import require_tokenizers, slow
from transformers.tokenization_utils_base import BatchEncoding

from ..bert.test_tokenization_bert import BertTokenizationTest







@require_tokenizers
class       UpperCAmelCase_						( lowercase			):



      """simple docstring"""
      UpperCamelCase_    : Optional[int]									=DPRContextEncoderTokenizer
      UpperCamelCase_    : Any									=DPRContextEncoderTokenizerFast
      UpperCamelCase_    : Optional[int]									=True







@require_tokenizers
class       UpperCAmelCase_						( lowercase			):



      """simple docstring"""
      UpperCamelCase_    : Tuple									=DPRQuestionEncoderTokenizer
      UpperCamelCase_    : Union[str, Any]									=DPRQuestionEncoderTokenizerFast
      UpperCamelCase_    : Any									=True







@require_tokenizers
class       UpperCAmelCase_						( lowercase			):



      """simple docstring"""
      UpperCamelCase_    : Tuple									=DPRReaderTokenizer
      UpperCamelCase_    : List[Any]									=DPRReaderTokenizerFast
      UpperCamelCase_    : Union[str, Any]									=True
      @slow
      def    UpperCAmelCase						(    self			)    ->				Dict:
          UpperCamelCase	:Optional[int]     							=       self.tokenizer_class.from_pretrained('''bert-base-uncased'''			)

          UpperCamelCase	:Optional[Any]     							=       tokenizer.encode('''question sequence'''   ,    add_special_tokens=SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:Optional[Any]     							=       tokenizer.encode('''title sequence'''   ,    add_special_tokens=SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:List[str]     							=       tokenizer.encode('''text sequence ''' * 4   ,    add_special_tokens=SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:Optional[int]     							=       [[101] + text_a + [102] + text_a + [102] + text_a]
          UpperCamelCase	:Tuple     							=       BatchEncoding({'''input_ids''': input_ids}			)

          UpperCamelCase	:Dict     							=       [[0] * len(input_ids[0]			)]
          UpperCamelCase	:List[Any]     							=       [[0] * len(input_ids[0]			)]
          UpperCamelCase	:Tuple     							=       [0]
          UpperCamelCase	:Union[str, Any]     							=       DPRReaderOutput(SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_			)

          UpperCamelCase							,       UpperCamelCase	:Union[str, Any]     							=       8, 9
          UpperCamelCase	:Any     							=       10
          UpperCamelCase	:Optional[Any]     							=       10
          UpperCamelCase	:Optional[int]     							=       tokenizer.decode_best_spans(SCREAMING_SNAKE_CASE_   ,    SCREAMING_SNAKE_CASE_			)
          self.assertEqual(predicted_spans[0].start_index   ,    SCREAMING_SNAKE_CASE_			)
          self.assertEqual(predicted_spans[0].end_index   ,    SCREAMING_SNAKE_CASE_			)
          self.assertEqual(predicted_spans[0].doc_id   ,    0			)




      @slow
      def    UpperCAmelCase						(    self			)    ->				Any:
          UpperCamelCase	:List[str]     							=       self.tokenizer_class.from_pretrained('''bert-base-uncased'''			)

          UpperCamelCase	:Any     							=       tokenizer.encode('''question sequence'''   ,    add_special_tokens=SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:str     							=       tokenizer.encode('''title sequence'''   ,    add_special_tokens=SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:Union[str, Any]     							=       tokenizer.encode('''text sequence'''   ,    add_special_tokens=SCREAMING_SNAKE_CASE_			)
          UpperCamelCase	:List[Any]     							=       [101] + text_a + [102] + text_a + [102] + text_a
          UpperCamelCase	:Any     							=       tokenizer(questions=['''question sequence''']   ,    titles=['''title sequence''']   ,    texts=['''text sequence''']			)
          self.assertIn('''input_ids'''   ,    SCREAMING_SNAKE_CASE_			)
          self.assertIn('''attention_mask'''   ,    SCREAMING_SNAKE_CASE_			)
          self.assertListEqual(encoded_input['''input_ids'''][0]   ,    SCREAMING_SNAKE_CASE_			)





