




from __future__ import annotations

import unittest

from transformers import FunnelConfig, is_tf_available
from transformers.testing_utils import require_tf

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


if is_tf_available():
			import tensorflow as tf

			from transformers import (
			    TFFunnelBaseModel,
			    TFFunnelForMaskedLM,
			    TFFunnelForMultipleChoice,
			    TFFunnelForPreTraining,
			    TFFunnelForQuestionAnswering,
			    TFFunnelForSequenceClassification,
			    TFFunnelForTokenClassification,
			    TFFunnelModel,
			)






class  __magic_name__						:
				'''simple docstring'''







				def __init__(							self:   Any		,					_lowerCamelCase:   Optional[Any]		,					_lowerCamelCase:   str=13		,					_lowerCamelCase:   Optional[Any]=7		,					_lowerCamelCase:   List[str]=True		,					_lowerCamelCase:   Dict=True		,					_lowerCamelCase:   Any=True		,					_lowerCamelCase:   List[Any]=True		,					_lowerCamelCase:   Dict=99		,					_lowerCamelCase:   Any=[1, 1, 2]		,					_lowerCamelCase:   Tuple=1		,					_lowerCamelCase:   Optional[Any]=32		,					_lowerCamelCase:   List[str]=4		,					_lowerCamelCase:   str=8		,					_lowerCamelCase:   Union[str, Any]=37		,					_lowerCamelCase:   Optional[Any]="gelu_new"		,					_lowerCamelCase:   Optional[int]=0.1		,					_lowerCamelCase:   List[str]=0.1		,					_lowerCamelCase:   Any=0.0		,					_lowerCamelCase:   str=5_12		,					_lowerCamelCase:   List[str]=3		,					_lowerCamelCase:   Union[str, Any]=0.02		,					_lowerCamelCase:   Any=3		,					_lowerCamelCase:   Any=4		,					_lowerCamelCase:   int=None		,					_lowerCamelCase:   List[str]=False		,					):
											SCREAMING_SNAKE_CASE_   	=    parent
											SCREAMING_SNAKE_CASE_   	=    batch_size
											SCREAMING_SNAKE_CASE_   	=    seq_length
											SCREAMING_SNAKE_CASE_   	=    is_training
											SCREAMING_SNAKE_CASE_   	=    use_input_mask
											SCREAMING_SNAKE_CASE_   	=    use_token_type_ids
											SCREAMING_SNAKE_CASE_   	=    use_labels
											SCREAMING_SNAKE_CASE_   	=    vocab_size
											SCREAMING_SNAKE_CASE_   	=    block_sizes
											SCREAMING_SNAKE_CASE_   	=    num_decoder_layers
											SCREAMING_SNAKE_CASE_   	=    d_model
											SCREAMING_SNAKE_CASE_   	=    n_head
											SCREAMING_SNAKE_CASE_   	=    d_head
											SCREAMING_SNAKE_CASE_   	=    d_inner
											SCREAMING_SNAKE_CASE_   	=    hidden_act
											SCREAMING_SNAKE_CASE_   	=    hidden_dropout
											SCREAMING_SNAKE_CASE_   	=    attention_dropout
											SCREAMING_SNAKE_CASE_   	=    activation_dropout
											SCREAMING_SNAKE_CASE_   	=    max_position_embeddings
											SCREAMING_SNAKE_CASE_   	=    type_vocab_size
											SCREAMING_SNAKE_CASE_   	=    2
											SCREAMING_SNAKE_CASE_   	=    num_labels
											SCREAMING_SNAKE_CASE_   	=    num_choices
											SCREAMING_SNAKE_CASE_   	=    scope
											SCREAMING_SNAKE_CASE_   	=    initializer_std

											# Used in the tests to check the size of the first attention layer
											SCREAMING_SNAKE_CASE_   	=    n_head
											# Used in the tests to check the size of the first hidden state
											SCREAMING_SNAKE_CASE_   	=    self.d_model
											# Used in the tests to check the number of output hidden states/attentions
											SCREAMING_SNAKE_CASE_   	=    sum(self.block_sizes		) + (0 if base else self.num_decoder_layers)
											# FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
											# the last hidden state of the first block (which is the first hidden state of the decoder).
											if not base:
																		SCREAMING_SNAKE_CASE_   	=    self.num_hidden_layers + 2


				def     _A							(							self:   List[Any]		):
											SCREAMING_SNAKE_CASE_   	=    ids_tensor([self.batch_size, self.seq_length]		,					self.vocab_size		)

											SCREAMING_SNAKE_CASE_   	=    None
											if self.use_input_mask:
																		SCREAMING_SNAKE_CASE_   	=    random_attention_mask([self.batch_size, self.seq_length]		)

											SCREAMING_SNAKE_CASE_   	=    None
											if self.use_token_type_ids:
																		SCREAMING_SNAKE_CASE_   	=    ids_tensor([self.batch_size, self.seq_length]		,					self.type_vocab_size		)

											SCREAMING_SNAKE_CASE_   	=    None
											SCREAMING_SNAKE_CASE_   	=    None
											SCREAMING_SNAKE_CASE_   	=    None
											if self.use_labels:
																		SCREAMING_SNAKE_CASE_   	=    ids_tensor([self.batch_size]		,					self.type_sequence_label_size		)
																		SCREAMING_SNAKE_CASE_   	=    ids_tensor([self.batch_size, self.seq_length]		,					self.num_labels		)
																		SCREAMING_SNAKE_CASE_   	=    ids_tensor([self.batch_size]		,					self.num_choices		)

											SCREAMING_SNAKE_CASE_   	=    FunnelConfig(
											    vocab_size=self.vocab_size		,					block_sizes=self.block_sizes		,					num_decoder_layers=self.num_decoder_layers		,					d_model=self.d_model		,					n_head=self.n_head		,					d_head=self.d_head		,					d_inner=self.d_inner		,					hidden_act=self.hidden_act		,					hidden_dropout=self.hidden_dropout		,					attention_dropout=self.attention_dropout		,					activation_dropout=self.activation_dropout		,					max_position_embeddings=self.max_position_embeddings		,					type_vocab_size=self.type_vocab_size		,					initializer_std=self.initializer_std		,					)

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


				def     _A							(							self:   Any		,					_lowerCamelCase:   List[Any]		,					_lowerCamelCase:   List[str]		,					_lowerCamelCase:   Optional[Any]		,					_lowerCamelCase:   str		,					_lowerCamelCase:   Optional[int]		,					_lowerCamelCase:   Optional[Any]		,					_lowerCamelCase:   str		,					):
											SCREAMING_SNAKE_CASE_   	=    TFFunnelModel(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    [input_ids, input_mask]
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(result.last_hidden_state.shape		,					(self.batch_size, self.seq_length, self.d_model)		)

											SCREAMING_SNAKE_CASE_   	=    False
											SCREAMING_SNAKE_CASE_   	=    TFFunnelModel(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(result.last_hidden_state.shape		,					(self.batch_size, self.seq_length, self.d_model)		)

											SCREAMING_SNAKE_CASE_   	=    False
											SCREAMING_SNAKE_CASE_   	=    TFFunnelModel(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(result.last_hidden_state.shape		,					(self.batch_size, self.seq_length, self.d_model)		)


				def     _A							(							self:   Optional[Any]		,					_lowerCamelCase:   Optional[int]		,					_lowerCamelCase:   List[str]		,					_lowerCamelCase:   Union[str, Any]		,					_lowerCamelCase:   Union[str, Any]		,					_lowerCamelCase:   Optional[int]		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   Dict		,					):
											SCREAMING_SNAKE_CASE_   	=    TFFunnelBaseModel(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    [input_ids, input_mask]
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)

											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(result.last_hidden_state.shape		,					(self.batch_size, 2, self.d_model)		)

											SCREAMING_SNAKE_CASE_   	=    False
											SCREAMING_SNAKE_CASE_   	=    TFFunnelBaseModel(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(result.last_hidden_state.shape		,					(self.batch_size, 3, self.d_model)		)

											SCREAMING_SNAKE_CASE_   	=    False
											SCREAMING_SNAKE_CASE_   	=    TFFunnelBaseModel(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(result.last_hidden_state.shape		,					(self.batch_size, 2, self.d_model)		)


				def     _A							(							self:   Tuple		,					_lowerCamelCase:   Any		,					_lowerCamelCase:   Any		,					_lowerCamelCase:   str		,					_lowerCamelCase:   int		,					_lowerCamelCase:   Optional[int]		,					_lowerCamelCase:   int		,					_lowerCamelCase:   Union[str, Any]		,					):
											SCREAMING_SNAKE_CASE_   	=    TFFunnelForPreTraining(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.seq_length)		)


				def     _A							(							self:   Optional[Any]		,					_lowerCamelCase:   Optional[int]		,					_lowerCamelCase:   List[str]		,					_lowerCamelCase:   Any		,					_lowerCamelCase:   Tuple		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   Optional[int]		,					_lowerCamelCase:   Dict		,					):
											SCREAMING_SNAKE_CASE_   	=    TFFunnelForMaskedLM(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.seq_length, self.vocab_size)		)


				def     _A							(							self:   Any		,					_lowerCamelCase:   List[Any]		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   int		,					_lowerCamelCase:   Optional[int]		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   List[str]		,					_lowerCamelCase:   Optional[int]		,					):
											SCREAMING_SNAKE_CASE_   	=    self.num_labels
											SCREAMING_SNAKE_CASE_   	=    TFFunnelForSequenceClassification(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_labels)		)


				def     _A							(							self:   str		,					_lowerCamelCase:   Optional[int]		,					_lowerCamelCase:   Union[str, Any]		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   Optional[Any]		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   Union[str, Any]		,					):
											SCREAMING_SNAKE_CASE_   	=    self.num_choices
											SCREAMING_SNAKE_CASE_   	=    TFFunnelForMultipleChoice(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    tf.tile(tf.expand_dims(_lowerCamelCase		,					1		)		,					(1, self.num_choices, 1)		)
											SCREAMING_SNAKE_CASE_   	=    tf.tile(tf.expand_dims(_lowerCamelCase		,					1		)		,					(1, self.num_choices, 1)		)
											SCREAMING_SNAKE_CASE_   	=    tf.tile(tf.expand_dims(_lowerCamelCase		,					1		)		,					(1, self.num_choices, 1)		)
											SCREAMING_SNAKE_CASE_   	=    {
											    '''input_ids''': multiple_choice_inputs_ids,
											    '''attention_mask''': multiple_choice_input_mask,
											    '''token_type_ids''': multiple_choice_token_type_ids,
											}
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.num_choices)		)


				def     _A							(							self:   int		,					_lowerCamelCase:   Union[str, Any]		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   Any		,					_lowerCamelCase:   Optional[Any]		,					_lowerCamelCase:   Optional[int]		,					_lowerCamelCase:   Union[str, Any]		,					):
											SCREAMING_SNAKE_CASE_   	=    self.num_labels
											SCREAMING_SNAKE_CASE_   	=    TFFunnelForTokenClassification(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											self.parent.assertEqual(result.logits.shape		,					(self.batch_size, self.seq_length, self.num_labels)		)


				def     _A							(							self:   List[Any]		,					_lowerCamelCase:   Any		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   Tuple		,					_lowerCamelCase:   Dict		,					_lowerCamelCase:   int		,					_lowerCamelCase:   Union[str, Any]		,					_lowerCamelCase:   Union[str, Any]		,					):
											SCREAMING_SNAKE_CASE_   	=    TFFunnelForQuestionAnswering(config=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    {'''input_ids''': input_ids, '''attention_mask''': input_mask, '''token_type_ids''': token_type_ids}
											SCREAMING_SNAKE_CASE_   	=    model(_lowerCamelCase		)
											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     _A							(							self:   Dict		):
											SCREAMING_SNAKE_CASE_   	=    self.prepare_config_and_inputs()
											(
											    (
											    SCREAMING_SNAKE_CASE_
											)	,	(
											    SCREAMING_SNAKE_CASE_
											)	,	(
											    SCREAMING_SNAKE_CASE_
											)	,	(
											    SCREAMING_SNAKE_CASE_
											)	,	(
											    SCREAMING_SNAKE_CASE_
											)	,	(
											    SCREAMING_SNAKE_CASE_
											)	,	(
											    SCREAMING_SNAKE_CASE_
											)	,	
											)   	=    config_and_inputs
											SCREAMING_SNAKE_CASE_   	=    {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
											return config, inputs_dict






@require_tf
class  __magic_name__						(  __UpperCAmelCase    ,  __UpperCAmelCase    ,  unittest.TestCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							Union[str, Any]	      =					(
				    (
				        TFFunnelModel,
				        TFFunnelForMaskedLM,
				        TFFunnelForPreTraining,
				        TFFunnelForQuestionAnswering,
				        TFFunnelForTokenClassification,
				    )
				    if is_tf_available()
				    else ()
				)
				SCREAMING_SNAKE_CASE__					:							Optional[int]	      =					(
				    {
				        "feature-extraction": (TFFunnelBaseModel, TFFunnelModel),
				        "fill-mask": TFFunnelForMaskedLM,
				        "question-answering": TFFunnelForQuestionAnswering,
				        "text-classification": TFFunnelForSequenceClassification,
				        "token-classification": TFFunnelForTokenClassification,
				        "zero-shot": TFFunnelForSequenceClassification,
				    }
				    if is_tf_available()
				    else {}
				)
				SCREAMING_SNAKE_CASE__					:							Dict	      =					False
				SCREAMING_SNAKE_CASE__					:							Union[str, Any]	      =					False


				def     _A							(							self:   List[str]		):
											SCREAMING_SNAKE_CASE_   	=    TFFunnelModelTester(self		)
											SCREAMING_SNAKE_CASE_   	=    ConfigTester(self		,					config_class=_lowerCamelCase		)


				def     _A							(							self:   Tuple		):
											self.config_tester.run_common_tests()


				def     _A							(							self:   int		):
											SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*_lowerCamelCase		)


				def     _A							(							self:   Union[str, Any]		):
											SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_pretraining(*_lowerCamelCase		)


				def     _A							(							self:   str		):
											SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_lm(*_lowerCamelCase		)


				def     _A							(							self:   int		):
											SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_token_classification(*_lowerCamelCase		)





				def     _A							(							self:   Optional[int]		):
											SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_question_answering(*_lowerCamelCase		)






@require_tf
class  __magic_name__						(  __UpperCAmelCase    ,  unittest.TestCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							Any	      =					(
				    (TFFunnelBaseModel, TFFunnelForMultipleChoice, TFFunnelForSequenceClassification) if is_tf_available() else ()
				)
				SCREAMING_SNAKE_CASE__					:							Optional[int]	      =					False
				SCREAMING_SNAKE_CASE__					:							List[str]	      =					False


				def     _A							(							self:   Optional[Any]		):
											SCREAMING_SNAKE_CASE_   	=    TFFunnelModelTester(self		,					base=_lowerCamelCase		)
											SCREAMING_SNAKE_CASE_   	=    ConfigTester(self		,					config_class=_lowerCamelCase		)


				def     _A							(							self:   Union[str, Any]		):
											self.config_tester.run_common_tests()


				def     _A							(							self:   List[str]		):
											SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_base_model(*_lowerCamelCase		)


				def     _A							(							self:   List[str]		):
											SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_sequence_classification(*_lowerCamelCase		)





				def     _A							(							self:   Dict		):
											SCREAMING_SNAKE_CASE_   	=    self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_multiple_choice(*_lowerCamelCase		)








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


__SCREAMING_SNAKE_CASE 						=logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE 						={
    """google/realm-cc-news-pretrained-embedder""": (
        """https://huggingface.co/google/realm-cc-news-pretrained-embedder/resolve/main/config.json"""
    ),
    """google/realm-cc-news-pretrained-encoder""": (
        """https://huggingface.co/google/realm-cc-news-pretrained-encoder/resolve/main/config.json"""
    ),
    """google/realm-cc-news-pretrained-scorer""": (
        """https://huggingface.co/google/realm-cc-news-pretrained-scorer/resolve/main/config.json"""
    ),
    """google/realm-cc-news-pretrained-openqa""": (
        """https://huggingface.co/google/realm-cc-news-pretrained-openqa/aresolve/main/config.json"""
    ),
    """google/realm-orqa-nq-openqa""": """https://huggingface.co/google/realm-orqa-nq-openqa/resolve/main/config.json""",
    """google/realm-orqa-nq-reader""": """https://huggingface.co/google/realm-orqa-nq-reader/resolve/main/config.json""",
    """google/realm-orqa-wq-openqa""": """https://huggingface.co/google/realm-orqa-wq-openqa/resolve/main/config.json""",
    """google/realm-orqa-wq-reader""": """https://huggingface.co/google/realm-orqa-wq-reader/resolve/main/config.json""",
    # See all REALM models at https://huggingface.co/models?filter=realm
}






class  __magic_name__						(  __UpperCAmelCase):
				'''simple docstring'''







				SCREAMING_SNAKE_CASE__					:							int	      =					"realm"


				def __init__(							self:   Tuple		,					_lowerCamelCase:   Union[str, Any]=3_05_22		,					_lowerCamelCase:   Tuple=7_68		,					_lowerCamelCase:   str=1_28		,					_lowerCamelCase:   str=12		,					_lowerCamelCase:   int=12		,					_lowerCamelCase:   Union[str, Any]=8		,					_lowerCamelCase:   Optional[Any]=30_72		,					_lowerCamelCase:   str="gelu_new"		,					_lowerCamelCase:   str=0.1		,					_lowerCamelCase:   Union[str, Any]=0.1		,					_lowerCamelCase:   Optional[int]=5_12		,					_lowerCamelCase:   Union[str, Any]=2		,					_lowerCamelCase:   int=0.02		,					_lowerCamelCase:   Tuple=1E-12		,					_lowerCamelCase:   List[Any]=2_56		,					_lowerCamelCase:   Any=10		,					_lowerCamelCase:   Optional[Any]=1E-3		,					_lowerCamelCase:   Any=5		,					_lowerCamelCase:   List[str]=3_20		,					_lowerCamelCase:   List[str]=13_35_37_18		,					_lowerCamelCase:   str=50_00		,					_lowerCamelCase:   str=1		,					_lowerCamelCase:   str=0		,					_lowerCamelCase:   Dict=2		,					**_lowerCamelCase:   Tuple		,					):
											super().__init__(pad_token_id=_lowerCamelCase		,					bos_token_id=_lowerCamelCase		,					eos_token_id=_lowerCamelCase		,					**_lowerCamelCase		)

											# Common config
											SCREAMING_SNAKE_CASE_   	=    vocab_size
											SCREAMING_SNAKE_CASE_   	=    max_position_embeddings
											SCREAMING_SNAKE_CASE_   	=    hidden_size
											SCREAMING_SNAKE_CASE_   	=    retriever_proj_size
											SCREAMING_SNAKE_CASE_   	=    num_hidden_layers
											SCREAMING_SNAKE_CASE_   	=    num_attention_heads
											SCREAMING_SNAKE_CASE_   	=    num_candidates
											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_   	=    initializer_range
											SCREAMING_SNAKE_CASE_   	=    type_vocab_size
											SCREAMING_SNAKE_CASE_   	=    layer_norm_eps

											# Reader config
											SCREAMING_SNAKE_CASE_   	=    span_hidden_size
											SCREAMING_SNAKE_CASE_   	=    max_span_width
											SCREAMING_SNAKE_CASE_   	=    reader_layer_norm_eps
											SCREAMING_SNAKE_CASE_   	=    reader_beam_size
											SCREAMING_SNAKE_CASE_   	=    reader_seq_len

											# Retrieval config
											SCREAMING_SNAKE_CASE_   	=    num_block_records
											SCREAMING_SNAKE_CASE_   	=    searcher_beam_size


