






"""simple docstring"""



def 					_snake_case							(	lowerCamelCase__      :       Optional[int]							,		lowerCamelCase__      :       Union[str, Any]    )							->      Optional[int]:
							lowerCamelCase_			:				int										=0
							lowerCamelCase_			:				Any										=len(__snake_case    ) - 1

							while left <= right:
														# avoid divided by 0 during interpolation
														if sorted_collection[left] == sorted_collection[right]:
																					if sorted_collection[left] == item:
																												return left
																					else:
																												return None

														lowerCamelCase_			:				Union[str, Any]										=left + ((item - sorted_collection[left]) * (right - left)) // (
														    sorted_collection[right] - sorted_collection[left]
														)

														# out of range check
														if point < 0 or point >= len(__snake_case    ):
																					return None

														lowerCamelCase_			:				List[str]										=sorted_collection[point]
														if current_item == item:
																					return point
														else:
																					if point < left:
																												lowerCamelCase_			:				Union[str, Any]										=left
																												lowerCamelCase_			:				str										=point
																					elif point > right:
																												lowerCamelCase_			:				Any										=right
																												lowerCamelCase_			:				List[Any]										=point
																					else:
																												if item < current_item:
																																			lowerCamelCase_			:				Union[str, Any]										=point - 1
																												else:
																																			lowerCamelCase_			:				Tuple										=point + 1
							return None

def 					_snake_case							(	lowerCamelCase__      :       Optional[Any]							,		lowerCamelCase__      :       Dict							,		lowerCamelCase__      :       List[str]							,		lowerCamelCase__      :       str    )							->      Tuple:

							# avoid divided by 0 during interpolation
							if sorted_collection[left] == sorted_collection[right]:
														if sorted_collection[left] == item:
																					return left
														else:
																					return None

							lowerCamelCase_			:				Dict										=left + ((item - sorted_collection[left]) * (right - left)) // (
							    sorted_collection[right] - sorted_collection[left]
							)

							# out of range check
							if point < 0 or point >= len(__snake_case    ):
														return None

							if sorted_collection[point] == item:
														return point
							elif point < left:
														return interpolation_search_by_recursion(__snake_case							,		__snake_case							,		__snake_case							,		__snake_case    )
							elif point > right:
														return interpolation_search_by_recursion(__snake_case							,		__snake_case							,		__snake_case							,		__snake_case    )
							else:
														if sorted_collection[point] > item:
																					return interpolation_search_by_recursion(
																					    __snake_case							,		__snake_case							,		__snake_case							,		point - 1    )
														else:
																					return interpolation_search_by_recursion(
																					    __snake_case							,		__snake_case							,		point + 1							,		__snake_case    )

def 					_snake_case							(	lowerCamelCase__      :       Optional[int]    )							->      Optional[Any]:
							if collection != sorted(__snake_case    ):
														raise ValueError("Collection must be ascending sorted"    )
							return True


if __name__ == "__main__":
						import sys
						A__			:							Optional[Any]					   =   0
						if debug == 1:
												A__			:							List[Any]					   =   [10, 30, 40, 45, 50, 66, 77, 93]
												try:
																		__assert_sorted(collection)
												except ValueError:
																		sys.exit('Sequence must be ascending sorted to apply interpolation search')
												A__			:							Optional[int]					   =   67

						A__			:							Tuple					   =   interpolation_search(collection, target)
						if result is not None:
												print(f'{target} found at positions: {result}')
						else:
												print('Not found')








"""simple docstring"""






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


__snake_case				:  Dict =       logging.get_logger(__name__)

__snake_case				:  int =       {
    'uclanlp/visualbert-vqa': 'https://huggingface.co/uclanlp/visualbert-vqa/resolve/main/config.json',
    'uclanlp/visualbert-vqa-pre': 'https://huggingface.co/uclanlp/visualbert-vqa-pre/resolve/main/config.json',
    'uclanlp/visualbert-vqa-coco-pre': (
        'https://huggingface.co/uclanlp/visualbert-vqa-coco-pre/resolve/main/config.json'
    ),
    'uclanlp/visualbert-vcr': 'https://huggingface.co/uclanlp/visualbert-vcr/resolve/main/config.json',
    'uclanlp/visualbert-vcr-pre': 'https://huggingface.co/uclanlp/visualbert-vcr-pre/resolve/main/config.json',
    'uclanlp/visualbert-vcr-coco-pre': (
        'https://huggingface.co/uclanlp/visualbert-vcr-coco-pre/resolve/main/config.json'
    ),
    'uclanlp/visualbert-nlvr2': 'https://huggingface.co/uclanlp/visualbert-nlvr2/resolve/main/config.json',
    'uclanlp/visualbert-nlvr2-pre': 'https://huggingface.co/uclanlp/visualbert-nlvr2-pre/resolve/main/config.json',
    'uclanlp/visualbert-nlvr2-coco-pre': (
        'https://huggingface.co/uclanlp/visualbert-nlvr2-coco-pre/resolve/main/config.json'
    )
    # See all VisualBERT models at https://huggingface.co/models?filter=visual_bert
}



class      A__  (    __SCREAMING_SNAKE_CASE				):




	'''simple docstring'''





	SCREAMING_SNAKE_CASE        =      'visual_bert'

	def __init__(	self:						int			,     _SCREAMING_SNAKE_CASE:						Dict=3_0522			,     _SCREAMING_SNAKE_CASE:						Union[str, Any]=768			,     _SCREAMING_SNAKE_CASE:						List[str]=512			,     _SCREAMING_SNAKE_CASE:						Optional[int]=12			,     _SCREAMING_SNAKE_CASE:						List[str]=12			,     _SCREAMING_SNAKE_CASE:						Tuple=3072			,     _SCREAMING_SNAKE_CASE:						Union[str, Any]="gelu"			,     _SCREAMING_SNAKE_CASE:						Tuple=0.1			,     _SCREAMING_SNAKE_CASE:						str=0.1			,     _SCREAMING_SNAKE_CASE:						List[Any]=512			,     _SCREAMING_SNAKE_CASE:						Any=2			,     _SCREAMING_SNAKE_CASE:						Optional[int]=0.02			,     _SCREAMING_SNAKE_CASE:						Union[str, Any]=1e-12			,     _SCREAMING_SNAKE_CASE:						List[str]=False			,     _SCREAMING_SNAKE_CASE:						int=True			,     _SCREAMING_SNAKE_CASE:						str=1			,     _SCREAMING_SNAKE_CASE:						Tuple=0			,     _SCREAMING_SNAKE_CASE:						Any=2			,     **_SCREAMING_SNAKE_CASE:						List[str]			,     )							->			str:

				"""simple docstring"""

				super().__init__(pad_token_id=_SCREAMING_SNAKE_CASE			,     bos_token_id=_SCREAMING_SNAKE_CASE			,     eos_token_id=_SCREAMING_SNAKE_CASE			,     **_SCREAMING_SNAKE_CASE)

				__lowerCAmelCase :    str				=			vocab_size
				__lowerCAmelCase :    Tuple				=			max_position_embeddings
				__lowerCAmelCase :    Any				=			hidden_size
				__lowerCAmelCase :    Union[str, Any]				=			visual_embedding_dim
				__lowerCAmelCase :    List[str]				=			num_hidden_layers
				__lowerCAmelCase :    Optional[int]				=			num_attention_heads
				__lowerCAmelCase :    str				=			intermediate_size
				__lowerCAmelCase :    int				=			hidden_act
				__lowerCAmelCase :    Union[str, Any]				=			hidden_dropout_prob
				__lowerCAmelCase :    int				=			attention_probs_dropout_prob
				__lowerCAmelCase :    List[Any]				=			initializer_range
				__lowerCAmelCase :    Dict				=			type_vocab_size
				__lowerCAmelCase :    Optional[int]				=			layer_norm_eps
				__lowerCAmelCase :    Union[str, Any]				=			bypass_transformer
				__lowerCAmelCase :    List[str]				=			special_visual_initialize