code: 
  '''simple docstring'''
  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   snake_case__					(			__SCREAMING_SNAKE_CASE				):
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		lowerCamelCase           =	DPRContextEncoderTokenizer
  		lowerCamelCase           =	DPRContextEncoderTokenizerFast
  		lowerCamelCase           =	True
  
  
  
  
  
  
  
  @require_tokenizers
  class   snake_case__					(			__SCREAMING_SNAKE_CASE				):
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		lowerCamelCase           =	DPRQuestionEncoderTokenizer
  		lowerCamelCase           =	DPRQuestionEncoderTokenizerFast
  		lowerCamelCase           =	True
  
  
  
  
  
  
  
  @require_tokenizers
  class   snake_case__					(			__SCREAMING_SNAKE_CASE				):
  
  
  
  
  
  
  
  		"""simple docstring"""
  
  		lowerCamelCase           =	DPRReaderTokenizer
  		lowerCamelCase           =	DPRReaderTokenizerFast
  		lowerCamelCase           =	True
  
  
  
  		@slow
  		def 			lowerCAmelCase							(			self							: str			)	-> Union[str, Any]:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					Union[str, Any]     =	self.tokenizer_class.from_pretrained('''bert-base-uncased'''			)
  
  				snake_case     :					List[Any]     =	tokenizer.encode('''question sequence'''     ,  add_special_tokens=UpperCamelCase__			)
  				snake_case     :					List[str]     =	tokenizer.encode('''title sequence'''     ,  add_special_tokens=UpperCamelCase__			)
  				snake_case     :					Optional[int]     =	tokenizer.encode('''text sequence ''' * 4     ,  add_special_tokens=UpperCamelCase__			)
  				snake_case     :					Union[str, Any]     =	[[101] + text_a + [102] + text_a + [102] + text_a]
  				snake_case     :					Union[str, Any]     =	BatchEncoding({'''input_ids''': input_ids}			)
  
  				snake_case     :					Optional[Any]     =	[[0] * len(input_ids[0]			)]
  				snake_case     :					Optional[int]     =	[[0] * len(input_ids[0]			)]
  				snake_case     :					List[str]     =	[0]
  				snake_case     :					Union[str, Any]     =	DPRReaderOutput(UpperCamelCase__     ,  UpperCamelCase__     ,  UpperCamelCase__			)
  
  				snake_case ,snake_case     :					Union[str, Any]     =	8, 9
  				snake_case     :					Dict     =	10
  				snake_case     :					List[str]     =	10
  				snake_case     :					List[str]     =	tokenizer.decode_best_spans(UpperCamelCase__     ,  UpperCamelCase__			)
  				self.assertEqual(predicted_spans[0].start_index     ,  UpperCamelCase__			)
  				self.assertEqual(predicted_spans[0].end_index     ,  UpperCamelCase__			)
  				self.assertEqual(predicted_spans[0].doc_id     ,  0			)
  
  
  
  		@slow
  		def 			lowerCAmelCase							(			self							: List[str]			)	-> str:
  
  
  
  
  
  
  				"""simple docstring"""
  
  
  
  
  
  
  
  				snake_case     :					List[str]     =	self.tokenizer_class.from_pretrained('''bert-base-uncased'''			)
  
  				snake_case     :					Tuple     =	tokenizer.encode('''question sequence'''     ,  add_special_tokens=UpperCamelCase__			)
  				snake_case     :					Optional[Any]     =	tokenizer.encode('''title sequence'''     ,  add_special_tokens=UpperCamelCase__			)
  				snake_case     :					Any     =	tokenizer.encode('''text sequence'''     ,  add_special_tokens=UpperCamelCase__			)
  				snake_case     :					Any     =	[101] + text_a + [102] + text_a + [102] + text_a
  				snake_case     :					Optional[Any]     =	tokenizer(questions=['''question sequence''']     ,  titles=['''title sequence''']     ,  texts=['''text sequence''']			)
  				self.assertIn('''input_ids'''     ,  UpperCamelCase__			)
  				self.assertIn('''attention_mask'''     ,  UpperCamelCase__			)
  				self.assertListEqual(encoded_input['''input_ids'''][0]     ,  UpperCamelCase__			)
  
  
  
style_context: 
  '''simple docstring'''
  import numpy as np
  
  
  
  
  def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__ )     ->       Optional[Any]:
  
  
  		'''simple docstring'''
  
  
  		snake_case ,snake_case     :					str     =	a.shape
  		snake_case     :					Union[str, Any]     =	min(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )
  		snake_case     :					List[Any]     =	np.eye(SCREAMING_SNAKE_CASE__ )
  		snake_case     :					Union[str, Any]     =	a.copy()
  
  		for k in range(t - 1 ):
  				# select a column of modified matrix A':
  				snake_case     :					Union[str, Any]     =	r[k:, [k]]
  				# construct first basis vector
  				snake_case     :					str     =	np.zeros_like(SCREAMING_SNAKE_CASE__ )
  				snake_case     :					List[str]     =	1.0
  				# determine scaling factor
  				snake_case     :					int     =	np.linalg.norm(SCREAMING_SNAKE_CASE__ )
  				# construct vector v for Householder reflection
  				snake_case     :					Optional[int]     =	x + np.sign(x[0] ) * alpha * ea
  				v /= np.linalg.norm(SCREAMING_SNAKE_CASE__ )
  
  				# construct the Householder matrix
  				snake_case     :					Tuple     =	np.eye(m - k ) - 2.0 * v @ v.T
  				# pad with ones and zeros as necessary
  				snake_case     :					int     =	np.block([[np.eye(SCREAMING_SNAKE_CASE__ ), np.zeros((k, m - k) )], [np.zeros((m - k, k) ), q_k]] )
  
  				snake_case     :					int     =	q @ q_k.T
  				snake_case     :					Dict     =	q_k @ r
  
  		return q, r
  
  
  if __name__ == "__main__":
  						import doctest
  
  						doctest.testmod()
  
  
  