






'''simple docstring'''





from collections import OrderedDict
from typing import Mapping

from packaging import version

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


_UpperCamelCase						:						int  =					logging.get_logger(__name__)

_UpperCamelCase						:						str  =					{
    "facebook/levit-128S": "https://huggingface.co/facebook/levit-128S/resolve/main/config.json",
    # See all LeViT models at https://huggingface.co/models?filter=levit
}


class  snake_case__      (					snake_case__):
					a_        =					"levit"




					def __init__(  self  :		Union[str, Any]				, _A  :		Tuple=2_24				, _A  :		Optional[Any]=3				, _A  :		int=3				, _A  :		Any=2				, _A  :		str=1				, _A  :		List[str]=16				, _A  :		List[Any]=[1_28, 2_56, 3_84]				, _A  :		str=[4, 8, 12]				, _A  :		Optional[Any]=[4, 4, 4]				, _A  :		List[Any]=[16, 16, 16]				, _A  :		Dict=0				, _A  :		Union[str, Any]=[2, 2, 2]				, _A  :		List[str]=[2, 2, 2]				, _A  :		Optional[Any]=0.02				, **_A  :		str				, )    ->							Dict:
								super().__init__(**__snake_case      )
								UpperCAmelCase_      :       Optional[int]          =       image_size
								UpperCAmelCase_      :       List[Any]          =       num_channels
								UpperCAmelCase_      :       str          =       kernel_size
								UpperCAmelCase_      :       int          =       stride
								UpperCAmelCase_      :       Any          =       padding
								UpperCAmelCase_      :       int          =       hidden_sizes
								UpperCAmelCase_      :       List[str]          =       num_attention_heads
								UpperCAmelCase_      :       Optional[int]          =       depths
								UpperCAmelCase_      :       Optional[int]          =       key_dim
								UpperCAmelCase_      :       List[Any]          =       drop_path_rate
								UpperCAmelCase_      :       Union[str, Any]          =       patch_size
								UpperCAmelCase_      :       Tuple          =       attention_ratio
								UpperCAmelCase_      :       Optional[int]          =       mlp_ratio
								UpperCAmelCase_      :       int          =       initializer_range
								UpperCAmelCase_      :       Union[str, Any]          =       [
								    ['''Subsample''', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
								    ['''Subsample''', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
								]






class  snake_case__      (					snake_case__):
					a_        =					version.parse("1.11")




					@property
					def 		A      (  self  :		Any      )    ->							Tuple:
								return OrderedDict(
								    [
								        ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
								    ]      )





					@property
					def 		A      (  self  :		Any      )    ->							int:
								return 1e-4






from functools import lru_cache
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     snake_case											=							2
     snake_case											=							set()
     while i * i <= n:
          if n % i:
               i += 1
          else:
               n //= i
               factors.add(UpperCamelCase_							)
     if n > 1:
          factors.add(UpperCamelCase_							)
     return factors
@lru_cache
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     return len(unique_prime_factors(UpperCamelCase_							)							)
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     return len(set(UpperCamelCase_							)							) in (0, 1)
def      UpperCAmelCase__		(UpperCamelCase_							):



     """simple docstring"""






     snake_case											=							2

     while True:
          # Increment each value of a generated range
          snake_case											=							[base + i for i in range(UpperCamelCase_							)]

          # Run elements through out unique_prime_factors function
          # Append our target number to the end.
          snake_case											=							[upf_len(UpperCamelCase_							) for x in group]
          checker.append(UpperCamelCase_							)

          # If all numbers in the list are equal, return the group variable.
          if equality(UpperCamelCase_							):
               return group

          # Increment our base variable by 1
          base += 1
def      UpperCAmelCase__		(UpperCamelCase_ = 4							):



     """simple docstring"""






     snake_case											=							run(UpperCamelCase_							)
     return results[0] if len(UpperCamelCase_							) else None


if __name__ == "__main__":
 print(solution())




