






import functools
import operator

from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCamelCase        =				logging.get_logger(__name__)

UpperCamelCase        =				{
    "asapp/sew-d-tiny-100k": "https://huggingface.co/asapp/sew-d-tiny-100k/resolve/main/config.json",
    # See all SEW-D models at https://huggingface.co/models?filter=sew-d
}

class        lowerCAmelCase_				(      lowercase	):







				"""simple docstring"""




				_snake_case				:   Tuple        =			"""sew-d"""







				def __init__( self     :Optional[Any]  ,     lowerCamelCase__     :int=32  ,     lowerCamelCase__     :Optional[Any]=7_68  ,     lowerCamelCase__     :Optional[Any]=12  ,     lowerCamelCase__     :Dict=12  ,     lowerCamelCase__     :Any=30_72  ,     lowerCamelCase__     :Optional[Any]=2  ,     lowerCamelCase__     :Tuple=5_12  ,     lowerCamelCase__     :Optional[Any]=2_56  ,     lowerCamelCase__     :int=True  ,     lowerCamelCase__     :List[Any]=True  ,     lowerCamelCase__     :int=("p2c", "c2p")  ,     lowerCamelCase__     :List[str]="layer_norm"  ,     lowerCamelCase__     :int="gelu_python"  ,     lowerCamelCase__     :Tuple=0.1  ,     lowerCamelCase__     :List[str]=0.1  ,     lowerCamelCase__     :Optional[int]=0.1  ,     lowerCamelCase__     :int=0.0  ,     lowerCamelCase__     :Optional[int]=0.1  ,     lowerCamelCase__     :List[Any]=0.02  ,     lowerCamelCase__     :str=1e-7  ,     lowerCamelCase__     :List[Any]=1e-5  ,     lowerCamelCase__     :Tuple="group"  ,     lowerCamelCase__     :List[Any]="gelu"  ,     lowerCamelCase__     :List[Any]=(64, 1_28, 1_28, 1_28, 1_28, 2_56, 2_56, 2_56, 2_56, 5_12, 5_12, 5_12, 5_12)  ,     lowerCamelCase__     :Any=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)  ,     lowerCamelCase__     :Dict=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1)  ,     lowerCamelCase__     :Union[str, Any]=False  ,     lowerCamelCase__     :Any=1_28  ,     lowerCamelCase__     :Any=16  ,     lowerCamelCase__     :List[Any]=True  ,     lowerCamelCase__     :Optional[Any]=0.05  ,     lowerCamelCase__     :List[Any]=10  ,     lowerCamelCase__     :Union[str, Any]=2  ,     lowerCamelCase__     :int=0.0  ,     lowerCamelCase__     :str=10  ,     lowerCamelCase__     :Any=0  ,     lowerCamelCase__     :str="mean"  ,     lowerCamelCase__     :Union[str, Any]=False  ,     lowerCamelCase__     :Optional[Any]=False  ,     lowerCamelCase__     :Dict=2_56  ,     lowerCamelCase__     :str=0  ,     lowerCamelCase__     :Union[str, Any]=1  ,     lowerCamelCase__     :Any=2  ,     **lowerCamelCase__     :str  ,     ):
					super().__init__(**lowerCamelCase__  ,     pad_token_id=lowerCamelCase__  ,     bos_token_id=lowerCamelCase__  ,     eos_token_id=lowerCamelCase__     )
					UpperCamelCase__ :Optional[int]						=      hidden_size
					UpperCamelCase__ :Optional[Any]						=      feat_extract_norm
					UpperCamelCase__ :Any						=      feat_extract_activation
					UpperCamelCase__ :Any						=      list(lowerCamelCase__     )
					UpperCamelCase__ :Optional[Any]						=      list(lowerCamelCase__     )
					UpperCamelCase__ :Any						=      list(lowerCamelCase__     )
					UpperCamelCase__ :str						=      conv_bias
					UpperCamelCase__ :Any						=      num_conv_pos_embeddings
					UpperCamelCase__ :List[str]						=      num_conv_pos_embedding_groups
					UpperCamelCase__ :List[Any]						=      len(self.conv_dim     )
					UpperCamelCase__ :Union[str, Any]						=      num_hidden_layers
					UpperCamelCase__ :Dict						=      intermediate_size
					UpperCamelCase__ :str						=      squeeze_factor
					UpperCamelCase__ :Optional[Any]						=      max_position_embeddings
					UpperCamelCase__ :Tuple						=      position_buckets
					UpperCamelCase__ :int						=      share_att_key
					UpperCamelCase__ :str						=      relative_attention
					UpperCamelCase__ :List[str]						=      norm_rel_ebd
					UpperCamelCase__ :Any						=      list(lowerCamelCase__     )
					UpperCamelCase__ :Optional[Any]						=      hidden_act
					UpperCamelCase__ :List[Any]						=      num_attention_heads
					UpperCamelCase__ :Tuple						=      hidden_dropout
					UpperCamelCase__ :int						=      attention_dropout
					UpperCamelCase__ :List[str]						=      activation_dropout
					UpperCamelCase__ :Optional[int]						=      feat_proj_dropout
					UpperCamelCase__ :int						=      final_dropout
					UpperCamelCase__ :Optional[int]						=      layer_norm_eps
					UpperCamelCase__ :str						=      feature_layer_norm_eps
					UpperCamelCase__ :Union[str, Any]						=      initializer_range
					UpperCamelCase__ :int						=      vocab_size

					if (
					    (len(self.conv_stride     ) != self.num_feat_extract_layers)
					    or (len(self.conv_kernel     ) != self.num_feat_extract_layers)
					    or (len(self.conv_dim     ) != self.num_feat_extract_layers)
					):
						raise ValueError(
						    """Configuration for convolutional layers is incorrect."""
						    """It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,"""
						    f"""but is `len(config.conv_dim) = {len(self.conv_dim     )}`, `len(config.conv_stride)"""
						    f"""= {len(self.conv_stride     )}`, `len(config.conv_kernel) = {len(self.conv_kernel     )}`."""     )

					# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
					UpperCamelCase__ :int						=      apply_spec_augment
					UpperCamelCase__ :int						=      mask_time_prob
					UpperCamelCase__ :List[Any]						=      mask_time_length
					UpperCamelCase__ :List[str]						=      mask_time_min_masks
					UpperCamelCase__ :int						=      mask_feature_prob
					UpperCamelCase__ :Optional[int]						=      mask_feature_length
					UpperCamelCase__ :str						=      mask_feature_min_masks

					# ctc loss
					UpperCamelCase__ :str						=      ctc_loss_reduction
					UpperCamelCase__ :Optional[int]						=      ctc_zero_infinity

					# sequence classification
					UpperCamelCase__ :str						=      use_weighted_layer_sum
					UpperCamelCase__ :int						=      classifier_proj_size







				@property
				def 				__a   ( self     :List[Any]     ):
					return functools.reduce(operator.mul  ,     self.conv_stride  ,     1     )

import collections
from typing import List, Optional, Union

from ...tokenization_utils_base import BatchEncoding
from ...utils import TensorType, add_end_docstrings, add_start_docstrings, logging
from ..bert.tokenization_bert_fast import BertTokenizerFast
from .tokenization_dpr import DPRContextEncoderTokenizer, DPRQuestionEncoderTokenizer, DPRReaderTokenizer


__lowerCAmelCase     :	Optional[Any]       			=  logging.get_logger(__name__)

__lowerCAmelCase     :	List[str]       			=  {'vocab_file': 'vocab.txt', 'tokenizer_file': 'tokenizer.json'}

__lowerCAmelCase     :	int       			=  {
    'vocab_file': {
        'facebook/dpr-ctx_encoder-single-nq-base': (
            'https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/vocab.txt'
        ),
        'facebook/dpr-ctx_encoder-multiset-base': (
            'https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'facebook/dpr-ctx_encoder-single-nq-base': (
            'https://huggingface.co/facebook/dpr-ctx_encoder-single-nq-base/resolve/main/tokenizer.json'
        ),
        'facebook/dpr-ctx_encoder-multiset-base': (
            'https://huggingface.co/facebook/dpr-ctx_encoder-multiset-base/resolve/main/tokenizer.json'
        ),
    },
}
__lowerCAmelCase     :	Any       			=  {
    'vocab_file': {
        'facebook/dpr-question_encoder-single-nq-base': (
            'https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/vocab.txt'
        ),
        'facebook/dpr-question_encoder-multiset-base': (
            'https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'facebook/dpr-question_encoder-single-nq-base': (
            'https://huggingface.co/facebook/dpr-question_encoder-single-nq-base/resolve/main/tokenizer.json'
        ),
        'facebook/dpr-question_encoder-multiset-base': (
            'https://huggingface.co/facebook/dpr-question_encoder-multiset-base/resolve/main/tokenizer.json'
        ),
    },
}
__lowerCAmelCase     :	List[Any]       			=  {
    'vocab_file': {
        'facebook/dpr-reader-single-nq-base': (
            'https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/vocab.txt'
        ),
        'facebook/dpr-reader-multiset-base': (
            'https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/vocab.txt'
        ),
    },
    'tokenizer_file': {
        'facebook/dpr-reader-single-nq-base': (
            'https://huggingface.co/facebook/dpr-reader-single-nq-base/resolve/main/tokenizer.json'
        ),
        'facebook/dpr-reader-multiset-base': (
            'https://huggingface.co/facebook/dpr-reader-multiset-base/resolve/main/tokenizer.json'
        ),
    },
}

__lowerCAmelCase     :	Any       			=  {
    'facebook/dpr-ctx_encoder-single-nq-base': 512,
    'facebook/dpr-ctx_encoder-multiset-base': 512,
}
__lowerCAmelCase     :	Optional[int]       			=  {
    'facebook/dpr-question_encoder-single-nq-base': 512,
    'facebook/dpr-question_encoder-multiset-base': 512,
}
__lowerCAmelCase     :	Optional[int]       			=  {
    'facebook/dpr-reader-single-nq-base': 512,
    'facebook/dpr-reader-multiset-base': 512,
}


__lowerCAmelCase     :	List[str]       			=  {
    'facebook/dpr-ctx_encoder-single-nq-base': {'do_lower_case': True},
    'facebook/dpr-ctx_encoder-multiset-base': {'do_lower_case': True},
}
__lowerCAmelCase     :	str       			=  {
    'facebook/dpr-question_encoder-single-nq-base': {'do_lower_case': True},
    'facebook/dpr-question_encoder-multiset-base': {'do_lower_case': True},
}
__lowerCAmelCase     :	Dict       			=  {
    'facebook/dpr-reader-single-nq-base': {'do_lower_case': True},
    'facebook/dpr-reader-multiset-base': {'do_lower_case': True},
}




class 			UpperCAmelCase_     (					_A	):


  '''simple docstring'''







  a__       			=						VOCAB_FILES_NAMES
  a__       			=						CONTEXT_ENCODER_PRETRAINED_VOCAB_FILES_MAP
  a__       			=						CONTEXT_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  a__       			=						CONTEXT_ENCODER_PRETRAINED_INIT_CONFIGURATION
  a__       			=						DPRContextEncoderTokenizer







class 			UpperCAmelCase_     (					_A	):


  '''simple docstring'''







  a__       			=						VOCAB_FILES_NAMES
  a__       			=						QUESTION_ENCODER_PRETRAINED_VOCAB_FILES_MAP
  a__       			=						QUESTION_ENCODER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  a__       			=						QUESTION_ENCODER_PRETRAINED_INIT_CONFIGURATION
  a__       			=						DPRQuestionEncoderTokenizer







__lowerCAmelCase     :	Optional[int]       			=  collections.namedtuple(
    'DPRSpanPrediction', ['span_score', 'relevance_score', 'doc_id', 'start_index', 'end_index', 'text']
)

__lowerCAmelCase     :	Union[str, Any]       			=  collections.namedtuple('DPRReaderOutput', ['start_logits', 'end_logits', 'relevance_logits'])


__lowerCAmelCase     :	str       			=  R'\n    Return a dictionary with the token ids of the input strings and other information to give to `.decode_best_spans`.\n    It converts the strings of a question and different passages (title and text) in a sequence of IDs (integers),\n    using the tokenizer and vocabulary. The resulting `input_ids` is a matrix of size `(n_passages, sequence_length)`\n    with the format:\n\n    [CLS] <question token ids> [SEP] <titles ids> [SEP] <texts ids>\n\n    Args:\n        questions (`str` or `List[str]`):\n            The questions to be encoded. You can specify one question for many passages. In this case, the question\n            will be duplicated like `[questions] * n_passages`. Otherwise you have to specify as many questions as in\n            `titles` or `texts`.\n        titles (`str` or `List[str]`):\n            The passages titles to be encoded. This can be a string or a list of strings if there are several passages.\n        texts (`str` or `List[str]`):\n            The passages texts to be encoded. This can be a string or a list of strings if there are several passages.\n        padding (`bool`, `str` or [`~utils.PaddingStrategy`], *optional*, defaults to `False`):\n            Activates and controls padding. Accepts the following values:\n\n            - `True` or `\'longest\'`: Pad to the longest sequence in the batch (or no padding if only a single sequence\n              if provided).\n            - `\'max_length\'`: Pad to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided.\n            - `False` or `\'do_not_pad\'` (default): No padding (i.e., can output a batch with sequences of different\n              lengths).\n        truncation (`bool`, `str` or [`~tokenization_utils_base.TruncationStrategy`], *optional*, defaults to `False`):\n            Activates and controls truncation. Accepts the following values:\n\n            - `True` or `\'longest_first\'`: Truncate to a maximum length specified with the argument `max_length` or to\n              the maximum acceptable input length for the model if that argument is not provided. This will truncate\n              token by token, removing a token from the longest sequence in the pair if a pair of sequences (or a batch\n              of pairs) is provided.\n            - `\'only_first\'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided. This will only truncate the first\n              sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n            - `\'only_second\'`: Truncate to a maximum length specified with the argument `max_length` or to the maximum\n              acceptable input length for the model if that argument is not provided. This will only truncate the\n              second sequence of a pair if a pair of sequences (or a batch of pairs) is provided.\n            - `False` or `\'do_not_truncate\'` (default): No truncation (i.e., can output batch with sequence lengths\n              greater than the model maximum admissible input size).\n        max_length (`int`, *optional*):\n                Controls the maximum length to use by one of the truncation/padding parameters.\n\n                If left unset or set to `None`, this will use the predefined model maximum length if a maximum length\n                is required by one of the truncation/padding parameters. If the model has no specific maximum input\n                length (like XLNet) truncation/padding to a maximum length will be deactivated.\n        return_tensors (`str` or [`~utils.TensorType`], *optional*):\n                If set, will return tensors instead of list of python integers. Acceptable values are:\n\n                - `\'tf\'`: Return TensorFlow `tf.constant` objects.\n                - `\'pt\'`: Return PyTorch `torch.Tensor` objects.\n                - `\'np\'`: Return Numpy `np.ndarray` objects.\n        return_attention_mask (`bool`, *optional*):\n            Whether or not to return the attention mask. If not set, will return the attention mask according to the\n            specific tokenizer\'s default, defined by the `return_outputs` attribute.\n\n            [What are attention masks?](../glossary#attention-mask)\n\n    Return:\n        `Dict[str, List[List[int]]]`: A dictionary with the following keys:\n\n        - `input_ids`: List of token ids to be fed to a model.\n        - `attention_mask`: List of indices specifying which tokens should be attended to by the model.\n    '




@add_start_docstrings(_A	)
class 			UpperCAmelCase_     :


  '''simple docstring'''







  def __call__(					self     :					Tuple     ,				UpperCamelCase__     :					List[str]     ,				UpperCamelCase__     :					Optional[str] = None     ,				UpperCamelCase__     :					Optional[str] = None     ,				UpperCamelCase__     :					Union[bool, str] = False     ,				UpperCamelCase__     :					Union[bool, str] = False     ,				UpperCamelCase__     :					Optional[int] = None     ,				UpperCamelCase__     :					Optional[Union[str, TensorType]] = None     ,				UpperCamelCase__     :					Optional[bool] = None     ,				**UpperCamelCase__     :					List[str]     ,				)     ->      BatchEncoding:







    """simple docstring"""






    if titles is None and texts is None:
      return super().__call__(
          UpperCamelCase__     ,				padding=UpperCamelCase__     ,				truncation=UpperCamelCase__     ,				max_length=UpperCamelCase__     ,				return_tensors=UpperCamelCase__     ,				return_attention_mask=UpperCamelCase__     ,				**UpperCamelCase__     ,				)
    elif titles is None or texts is None:
      __magic_name__								=			titles if texts is None else texts
      return super().__call__(
          UpperCamelCase__     ,				UpperCamelCase__     ,				padding=UpperCamelCase__     ,				truncation=UpperCamelCase__     ,				max_length=UpperCamelCase__     ,				return_tensors=UpperCamelCase__     ,				return_attention_mask=UpperCamelCase__     ,				**UpperCamelCase__     ,				)
    __magic_name__								=			titles if not isinstance(UpperCamelCase__     ,				UpperCamelCase__       ) else [titles]
    __magic_name__								=			texts if not isinstance(UpperCamelCase__     ,				UpperCamelCase__       ) else [texts]
    __magic_name__								=			len(UpperCamelCase__       )
    __magic_name__								=			questions if not isinstance(UpperCamelCase__     ,				UpperCamelCase__       ) else [questions] * n_passages
    assert len(UpperCamelCase__       ) == len(
        UpperCamelCase__       ), F'''There should be as many titles than texts but got {len(UpperCamelCase__       )} titles and {len(UpperCamelCase__       )} texts.'''
    __magic_name__								=			super().__call__(UpperCamelCase__     ,				UpperCamelCase__     ,				padding=UpperCamelCase__     ,				truncation=UpperCamelCase__       )["""input_ids"""]
    __magic_name__								=			super().__call__(UpperCamelCase__     ,				add_special_tokens=UpperCamelCase__     ,				padding=UpperCamelCase__     ,				truncation=UpperCamelCase__       )["""input_ids"""]
    __magic_name__								=			{
        """input_ids""": [
            (encoded_question_and_title + encoded_text)[:max_length]
            if max_length is not None and truncation
            else encoded_question_and_title + encoded_text
            for encoded_question_and_title, encoded_text in zip(UpperCamelCase__     ,				UpperCamelCase__       )
        ]
    }
    if return_attention_mask is not False:
      __magic_name__								=			[]
      for input_ids in encoded_inputs["input_ids"]:
        attention_mask.append([int(input_id != self.pad_token_id       ) for input_id in input_ids]       )
      __magic_name__								=			attention_mask
    return self.pad(UpperCamelCase__     ,				padding=UpperCamelCase__     ,				max_length=UpperCamelCase__     ,				return_tensors=UpperCamelCase__       )
  def 				_lowercase				(					self     :					List[Any]     ,				UpperCamelCase__     :					BatchEncoding     ,				UpperCamelCase__     :					DPRReaderOutput     ,				UpperCamelCase__     :					int = 16     ,				UpperCamelCase__     :					int = 64     ,				UpperCamelCase__     :					int = 4     ,				)     ->      List[DPRSpanPrediction]:







    """simple docstring"""






    __magic_name__								=			reader_input["""input_ids"""]
    __magic_name__	,       __magic_name__	,       __magic_name__								=			reader_output[:3]
    __magic_name__								=			len(UpperCamelCase__       )
    __magic_name__								=			sorted(range(UpperCamelCase__       )     ,				reverse=UpperCamelCase__     ,				key=relevance_logits.__getitem__       )
    __magic_name__								=			[]
    for doc_id in sorted_docs:
      __magic_name__								=			list(input_ids[doc_id]       )
      # assuming question & title information is at the beginning of the sequence
      __magic_name__								=			sequence_ids.index(self.sep_token_id     ,				2       ) + 1  # second sep id
      if sequence_ids[-1] == self.pad_token_id:
        __magic_name__								=			sequence_ids.index(self.pad_token_id       )
      else:
        __magic_name__								=			len(UpperCamelCase__       )

      __magic_name__								=			self._get_best_spans(
          start_logits=start_logits[doc_id][passage_offset:sequence_len]     ,				end_logits=end_logits[doc_id][passage_offset:sequence_len]     ,				max_answer_length=UpperCamelCase__     ,				top_spans=UpperCamelCase__     ,				)
      for start_index, end_index in best_spans:
        start_index += passage_offset
        end_index += passage_offset
        nbest_spans_predictions.append(
            DPRSpanPrediction(
                span_score=start_logits[doc_id][start_index] + end_logits[doc_id][end_index]     ,				relevance_score=relevance_logits[doc_id]     ,				doc_id=UpperCamelCase__     ,				start_index=UpperCamelCase__     ,				end_index=UpperCamelCase__     ,				text=self.decode(sequence_ids[start_index : end_index + 1]       )     ,				)       )
      if len(UpperCamelCase__       ) >= num_spans:
        break
    return nbest_spans_predictions[:num_spans]





  def 				_lowercase				(					self     :					Optional[int]     ,				UpperCamelCase__     :					List[int]     ,				UpperCamelCase__     :					List[int]     ,				UpperCamelCase__     :					int     ,				UpperCamelCase__     :					int     ,				)     ->      List[DPRSpanPrediction]:







    """simple docstring"""






    __magic_name__								=			[]
    for start_index, start_score in enumerate(UpperCamelCase__       ):
      for answer_length, end_score in enumerate(end_logits[start_index : start_index + max_answer_length]       ):
        scores.append(((start_index, start_index + answer_length), start_score + end_score)       )
    __magic_name__								=			sorted(UpperCamelCase__     ,				key=lambda UpperCamelCase__       : x[1]     ,				reverse=UpperCamelCase__       )
    __magic_name__								=			[]
    for (start_index, end_index), score in scores:
      assert start_index <= end_index, F'''Wrong span indices: [{start_index}:{end_index}]'''
      __magic_name__								=			end_index - start_index + 1
      assert length <= max_answer_length, F'''Span is too long: {length} > {max_answer_length}'''
      if any(
          start_index <= prev_start_index <= prev_end_index <= end_index
          or prev_start_index <= start_index <= end_index <= prev_end_index
          for (prev_start_index, prev_end_index) in chosen_span_intervals       ):
        continue
      chosen_span_intervals.append((start_index, end_index)       )

      if len(UpperCamelCase__       ) == top_spans:
        break
    return chosen_span_intervals







@add_end_docstrings(_A	)
class 			UpperCAmelCase_     (					_A    ,			_A	):


  '''simple docstring'''







  a__       			=						VOCAB_FILES_NAMES
  a__       			=						READER_PRETRAINED_VOCAB_FILES_MAP
  a__       			=						READER_PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
  a__       			=						READER_PRETRAINED_INIT_CONFIGURATION
  a__       			=						["""input_ids""", """attention_mask"""]
  a__       			=						DPRReaderTokenizer

