





from __future__ import annotations

from random import random
from typing import Generic, TypeVar

_lowerCamelCase 					=      TypeVar('KT')
_lowerCamelCase 					=      TypeVar('VT')




class 	UpperCamelCase_							(  Generic[KT, VT]     ):


							def __init__(				self     :List[str]				,					__A     :KT | str = "root"				,					__A     :VT | None = None		) -> Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   key
									SCREAMING_SNAKE_CASE__								=   value
									SCREAMING_SNAKE_CASE__								=   []


							def __repr__(				self     :Optional[Any]		) -> str:



									"""simple docstring"""



									return f'''Node({self.key}: {self.value})'''


							@property
							def   _snake_case	(				self     :str		) -> int:



									"""simple docstring"""



									return len(self.forward		)




class 	UpperCamelCase_							(  Generic[KT, VT]     ):


							def __init__(				self     :Union[str, Any]				,					__A     :float = 0.5				,					__A     :int = 16		) -> Dict:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   Node[KT, VT]()
									SCREAMING_SNAKE_CASE__								=   0
									SCREAMING_SNAKE_CASE__								=   p
									SCREAMING_SNAKE_CASE__								=   max_level


							def __str__(				self     :Optional[int]		) -> str:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   list(self		)

									if len(__A		) == 0:
											return f'''SkipList(level={self.level})'''

									SCREAMING_SNAKE_CASE__								=   max((len(str(__A		)		) for item in items)				,					default=4		)
									SCREAMING_SNAKE_CASE__								=   max(__A				,					4		) + 4

									SCREAMING_SNAKE_CASE__								=   self.head
									SCREAMING_SNAKE_CASE__								=   []

									SCREAMING_SNAKE_CASE__								=   node.forward.copy()
									lines.append(f'''[{node.key}]'''.ljust(__A				,					"""-"""		) + """* """ * len(__A		)		)
									lines.append(""" """ * label_size + """| """ * len(__A		)		)

									while len(node.forward		) != 0:
											SCREAMING_SNAKE_CASE__								=   node.forward[0]

											lines.append(
											    f'''[{node.key}]'''.ljust(__A				,					"""-"""		)
											    + """ """.join(str(n.key		) if n.key == node.key else """|""" for n in forwards		)		)
											lines.append(""" """ * label_size + """| """ * len(__A		)		)
											SCREAMING_SNAKE_CASE__								=   node.forward

									lines.append("""None""".ljust(__A		) + """* """ * len(__A		)		)
									return f'''SkipList(level={self.level})\n''' + "\n".join(__A		)


							def __iter__(				self     :Dict		) -> Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   self.head

									while len(node.forward		) != 0:
											yield node.forward[0].key
											SCREAMING_SNAKE_CASE__								=   node.forward[0]


							def   _snake_case	(				self     :str		) -> int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   1
									while random() < self.p and level < self.max_level:
											level += 1

									return level


							def   _snake_case	(				self     :Dict				,					__A     :Optional[int]		) -> tuple[Node[KT, VT] | None, list[Node[KT, VT]]]:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__								=   []

									SCREAMING_SNAKE_CASE__								=   self.head

									for i in reversed(range(self.level		)		):
											# i < node.level - When node level is lesser than `i` decrement `i`.
											# node.forward[i].key < key - Jumping to node with key value higher
											#                             or equal to searched key would result
											#                             in skipping searched key.
											while i < node.level and node.forward[i].key < key:
													SCREAMING_SNAKE_CASE__								=   node.forward[i]
											# Each leftmost node (relative to searched node) will potentially have to
											# be updated.
											update_vector.append(__A		)

									update_vector.reverse()  # Note that we were inserting values in reverse order.

									# len(node.forward) != 0 - If current node doesn't contain any further
									#                          references then searched key is not present.
									# node.forward[0].key == key - Next node key should be equal to search key
									#                              if key is present.
									if len(node.forward		) != 0 and node.forward[0].key == key:
											return node.forward[0], update_vector
									else:
											return None, update_vector


							def   _snake_case	(				self     :Optional[int]				,					__A     :KT		) -> Any:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__						,    SCREAMING_SNAKE_CASE__								=   self._locate_node(__A		)

									if node is not None:
											for i, update_node in enumerate(__A		):
													# Remove or replace all references to removed node.
													if update_node.level > i and update_node.forward[i].key == key:
															if node.level > i:
																	SCREAMING_SNAKE_CASE__								=   node.forward[i]
															else:
																	SCREAMING_SNAKE_CASE__								=   update_node.forward[:i]


							def   _snake_case	(				self     :List[Any]				,					__A     :KT				,					__A     :VT		) -> int:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__						,    SCREAMING_SNAKE_CASE__								=   self._locate_node(__A		)
									if node is not None:
											SCREAMING_SNAKE_CASE__								=   value
									else:
											SCREAMING_SNAKE_CASE__								=   self.random_level()

											if level > self.level:
													# After level increase we have to add additional nodes to head.
													for _ in range(self.level - 1				,					__A		):
															update_vector.append(self.head		)
													SCREAMING_SNAKE_CASE__								=   level

											SCREAMING_SNAKE_CASE__								=   Node(__A				,					__A		)

											for i, update_node in enumerate(update_vector[:level]		):
													# Change references to pass through new node.
													if update_node.level > i:
															new_node.forward.append(update_node.forward[i]		)

													if update_node.level < i + 1:
															update_node.forward.append(__A		)
													else:
															SCREAMING_SNAKE_CASE__								=   new_node


							def   _snake_case	(				self     :Optional[Any]				,					__A     :VT		) -> VT | None:



									"""simple docstring"""



									SCREAMING_SNAKE_CASE__						,    SCREAMING_SNAKE_CASE__								=   self._locate_node(__A		)

									if node is not None:
											return node.value

									return None






def 					SCREAMING_SNAKE_CASE__				(							):
		SCREAMING_SNAKE_CASE__								=   SkipList()
		skip_list.insert("""Key1"""       , 3     )
		skip_list.insert("""Key2"""       , 12     )
		skip_list.insert("""Key3"""       , 41     )
		skip_list.insert("""Key4"""       , -19     )

		SCREAMING_SNAKE_CASE__								=   skip_list.head
		SCREAMING_SNAKE_CASE__								=   {}
		while node.level != 0:
				SCREAMING_SNAKE_CASE__								=   node.forward[0]
				SCREAMING_SNAKE_CASE__								=   node.value

		assert len(UpperCamelCase__     ) == 4
		assert all_values["Key1"] == 3
		assert all_values["Key2"] == 12
		assert all_values["Key3"] == 41
		assert all_values["Key4"] == -19






def 					SCREAMING_SNAKE_CASE__				(							):
		SCREAMING_SNAKE_CASE__								=   SkipList()
		skip_list.insert("""Key1"""       , 10     )
		skip_list.insert("""Key1"""       , 12     )

		skip_list.insert("""Key5"""       , 7     )
		skip_list.insert("""Key7"""       , 10     )
		skip_list.insert("""Key10"""       , 5     )

		skip_list.insert("""Key7"""       , 7     )
		skip_list.insert("""Key5"""       , 5     )
		skip_list.insert("""Key10"""       , 10     )

		SCREAMING_SNAKE_CASE__								=   skip_list.head
		SCREAMING_SNAKE_CASE__								=   {}
		while node.level != 0:
				SCREAMING_SNAKE_CASE__								=   node.forward[0]
				SCREAMING_SNAKE_CASE__								=   node.value

		if len(UpperCamelCase__     ) != 4:
				print()
		assert len(UpperCamelCase__     ) == 4
		assert all_values["Key1"] == 12
		assert all_values["Key7"] == 7
		assert all_values["Key5"] == 5
		assert all_values["Key10"] == 10






def 					SCREAMING_SNAKE_CASE__				(							):
		SCREAMING_SNAKE_CASE__								=   SkipList()
		assert skip_list.find("""Some key"""     ) is None






def 					SCREAMING_SNAKE_CASE__				(							):
		SCREAMING_SNAKE_CASE__								=   SkipList()

		skip_list.insert("""Key2"""       , 20     )
		assert skip_list.find("""Key2"""     ) == 20

		skip_list.insert("""Some Key"""       , 10     )
		skip_list.insert("""Key2"""       , 8     )
		skip_list.insert("""V"""       , 13     )

		assert skip_list.find("""Y"""     ) is None
		assert skip_list.find("""Key2"""     ) == 8
		assert skip_list.find("""Some Key"""     ) == 10
		assert skip_list.find("""V"""     ) == 13






def 					SCREAMING_SNAKE_CASE__				(							):
		SCREAMING_SNAKE_CASE__								=   SkipList()
		skip_list.delete("""Some key"""     )

		assert len(skip_list.head.forward     ) == 0






def 					SCREAMING_SNAKE_CASE__				(							):
		SCREAMING_SNAKE_CASE__								=   SkipList()

		skip_list.insert("""Key1"""       , 12     )
		skip_list.insert("""V"""       , 13     )
		skip_list.insert("""X"""       , 14     )
		skip_list.insert("""Key2"""       , 15     )

		skip_list.delete("""V"""     )
		skip_list.delete("""Key2"""     )

		assert skip_list.find("""V"""     ) is None
		assert skip_list.find("""Key2"""     ) is None






def 					SCREAMING_SNAKE_CASE__				(							):
		SCREAMING_SNAKE_CASE__								=   SkipList()

		skip_list.insert("""Key1"""       , 12     )
		skip_list.insert("""V"""       , 13     )
		skip_list.insert("""X"""       , 14     )
		skip_list.insert("""Key2"""       , 15     )

		skip_list.delete("""V"""     )
		assert skip_list.find("""V"""     ) is None
		assert skip_list.find("""X"""     ) == 14
		assert skip_list.find("""Key1"""     ) == 12
		assert skip_list.find("""Key2"""     ) == 15

		skip_list.delete("""X"""     )
		assert skip_list.find("""V"""     ) is None
		assert skip_list.find("""X"""     ) is None
		assert skip_list.find("""Key1"""     ) == 12
		assert skip_list.find("""Key2"""     ) == 15

		skip_list.delete("""Key1"""     )
		assert skip_list.find("""V"""     ) is None
		assert skip_list.find("""X"""     ) is None
		assert skip_list.find("""Key1"""     ) is None
		assert skip_list.find("""Key2"""     ) == 15

		skip_list.delete("""Key2"""     )
		assert skip_list.find("""V"""     ) is None
		assert skip_list.find("""X"""     ) is None
		assert skip_list.find("""Key1"""     ) is None
		assert skip_list.find("""Key2"""     ) is None






def 					SCREAMING_SNAKE_CASE__				(							):
		SCREAMING_SNAKE_CASE__								=   SkipList()

		skip_list.insert("""Key1"""       , 12     )
		skip_list.insert("""V"""       , 13     )
		skip_list.insert("""X"""       , 142     )
		skip_list.insert("""Key2"""       , 15     )

		skip_list.delete("""X"""     )

		def traverse_keys(UpperCamelCase__:				List[Any]     ):
				yield node.key
				for forward_node in node.forward:
						yield from traverse_keys(UpperCamelCase__     )

		assert len(set(traverse_keys(skip_list.head     )     )     ) == 4






def 					SCREAMING_SNAKE_CASE__				(							):
		def is_sorted(UpperCamelCase__:				str     ):
				return all(next_item >= item for item, next_item in zip(UpperCamelCase__       , lst[1:]     )     )

		SCREAMING_SNAKE_CASE__								=   SkipList()
		for i in range(10     ):
				skip_list.insert(UpperCamelCase__       , UpperCamelCase__     )
		assert is_sorted(list(UpperCamelCase__     )     )
		skip_list.delete(5     )
		skip_list.delete(8     )
		skip_list.delete(2     )
		assert is_sorted(list(UpperCamelCase__     )     )
		skip_list.insert(-12       , -12     )
		skip_list.insert(77       , 77     )
		assert is_sorted(list(UpperCamelCase__     )     )






def 					SCREAMING_SNAKE_CASE__				(							):
		for _ in range(100     ):
				# Repeat test 100 times due to the probabilistic nature of skip list
				# random values == random bugs
				test_insert()
				test_insert_overrides_existing_value()

				test_searching_empty_list_returns_none()
				test_search()

				test_deleting_item_from_empty_list_do_nothing()
				test_deleted_items_are_not_founded_by_find_method()
				test_delete_removes_only_given_key()
				test_delete_doesnt_leave_dead_nodes()

				test_iter_always_yields_sorted_values()






def 					SCREAMING_SNAKE_CASE__				(							):
		SCREAMING_SNAKE_CASE__								=   SkipList()
		skip_list.insert(2       , """2"""     )
		skip_list.insert(4       , """4"""     )
		skip_list.insert(6       , """4"""     )
		skip_list.insert(4       , """5"""     )
		skip_list.insert(8       , """4"""     )
		skip_list.insert(9       , """4"""     )

		skip_list.delete(4     )

		print(UpperCamelCase__     )


if __name__ == "__main__":
	import doctest

	doctest.testmod()
	main()
"""simple docstring"""


from collections import OrderedDict
from typing import List, Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


UpperCAmelCase__			=    logging.get_logger(__name__)

UpperCAmelCase__			=    {
    """google/efficientnet-b7""": """https://huggingface.co/google/efficientnet-b7/resolve/main/config.json""",
}


class 							a					(		lowerCAmelCase_ ):
    _snake_case  :	Tuple  				=				'efficientnet'


    def __init__(       self						:	int ,					__lowerCAmelCase						:	int = 3 ,					__lowerCAmelCase						:	int = 600 ,					__lowerCAmelCase						:	float = 2.0 ,					__lowerCAmelCase						:	float = 3.1 ,					__lowerCAmelCase						:	int = 8 ,					__lowerCAmelCase						:	List[int] = [3, 3, 5, 3, 5, 5, 3] ,					__lowerCAmelCase						:	List[int] = [32, 16, 24, 40, 80, 112, 192] ,					__lowerCAmelCase						:	List[int] = [16, 24, 40, 80, 112, 192, 320] ,					__lowerCAmelCase						:	List[int] = [] ,					__lowerCAmelCase						:	List[int] = [1, 2, 2, 2, 1, 2, 1] ,					__lowerCAmelCase						:	List[int] = [1, 2, 2, 3, 3, 4, 1] ,					__lowerCAmelCase						:	List[int] = [1, 6, 6, 6, 6, 6, 6] ,					__lowerCAmelCase						:	float = 0.25 ,					__lowerCAmelCase						:	str = "swish" ,					__lowerCAmelCase						:	int = 2560 ,					__lowerCAmelCase						:	str = "mean" ,					__lowerCAmelCase						:	float = 0.02 ,					__lowerCAmelCase						:	float = 0.001 ,					__lowerCAmelCase						:	float = 0.99 ,					__lowerCAmelCase						:	float = 0.5 ,					__lowerCAmelCase						:	float = 0.2 ,					**__lowerCAmelCase						:	Optional[Any] ,					):
      super().__init__(**__lowerCAmelCase       )

      _UpperCAmelCase    			=   num_channels
      _UpperCAmelCase    			=   image_size
      _UpperCAmelCase    			=   width_coefficient
      _UpperCAmelCase    			=   depth_coefficient
      _UpperCAmelCase    			=   depth_divisor
      _UpperCAmelCase    			=   kernel_sizes
      _UpperCAmelCase    			=   in_channels
      _UpperCAmelCase    			=   out_channels
      _UpperCAmelCase    			=   depthwise_padding
      _UpperCAmelCase    			=   strides
      _UpperCAmelCase    			=   num_block_repeats
      _UpperCAmelCase    			=   expand_ratios
      _UpperCAmelCase    			=   squeeze_expansion_ratio
      _UpperCAmelCase    			=   hidden_act
      _UpperCAmelCase    			=   hidden_dim
      _UpperCAmelCase    			=   pooling_type
      _UpperCAmelCase    			=   initializer_range
      _UpperCAmelCase    			=   batch_norm_eps
      _UpperCAmelCase    			=   batch_norm_momentum
      _UpperCAmelCase    			=   dropout_rate
      _UpperCAmelCase    			=   drop_connect_rate
      _UpperCAmelCase    			=   sum(__lowerCAmelCase       ) * 4



class 							a					(		lowerCAmelCase_ ):
    _snake_case  :	Union[str, Any]  				=				version.parse('1.11' )


    @property
    def   lowerCAmelCase_	(       self						:	Any       ):
      return OrderedDict(
          [
              ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
          ]       )


    @property
    def   lowerCAmelCase_	(       self						:	List[Any]       ):
      return 1e-5
