






'''simple docstring'''

from typing import List

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


UpperCAmelCase__						:List[Any]          =			logging.get_logger(__name__)

UpperCAmelCase__						:str          =			{
    """snap-research/efficientformer-l1-300""": (
        """https://huggingface.co/snap-research/efficientformer-l1-300/resolve/main/config.json"""
    ),
}







class 	SCREAMING_SNAKE_CASE	(      lowerCAmelCase_  ):
       snake_case__    :     int   		=			'efficientformer'




       def __init__(					self      : str	,    A__      : List[int] = [3, 2, 6, 4]	,    A__      : List[int] = [48, 96, 224, 448]	,    A__      : List[bool] = [True, True, True, True]	,    A__      : int = 448	,    A__      : int = 32	,    A__      : int = 4	,    A__      : int = 7	,    A__      : int = 5	,    A__      : int = 8	,    A__      : int = 4	,    A__      : float = 0.0	,    A__      : int = 16	,    A__      : int = 3	,    A__      : int = 3	,    A__      : int = 3	,    A__      : int = 2	,    A__      : int = 1	,    A__      : float = 0.0	,    A__      : int = 1	,    A__      : bool = True	,    A__      : bool = True	,    A__      : float = 1e-5	,    A__      : str = "gelu"	,    A__      : float = 0.02	,    A__      : float = 1e-1_2	,    A__      : int = 224	,    A__      : float = 1e-0_5	,    **A__      : str	,    ):


            """simple docstring"""







            super().__init__(**A__					)

            __lowerCamelCase						:       Optional[int]				   =				hidden_act
            __lowerCamelCase						:       Dict				   =				hidden_dropout_prob
            __lowerCamelCase						:       str				   =				hidden_sizes
            __lowerCamelCase						:       List[Any]				   =				num_hidden_layers
            __lowerCamelCase						:       List[str]				   =				num_attention_heads
            __lowerCamelCase						:       Optional[Any]				   =				initializer_range
            __lowerCamelCase						:       Dict				   =				layer_norm_eps
            __lowerCamelCase						:       str				   =				patch_size
            __lowerCamelCase						:       Union[str, Any]				   =				num_channels
            __lowerCamelCase						:       List[str]				   =				depths
            __lowerCamelCase						:       int				   =				mlp_expansion_ratio
            __lowerCamelCase						:       Any				   =				downsamples
            __lowerCamelCase						:       Union[str, Any]				   =				dim
            __lowerCamelCase						:       Tuple				   =				key_dim
            __lowerCamelCase						:       int				   =				attention_ratio
            __lowerCamelCase						:       Dict				   =				resolution
            __lowerCamelCase						:       str				   =				pool_size
            __lowerCamelCase						:       str				   =				downsample_patch_size
            __lowerCamelCase						:       int				   =				downsample_stride
            __lowerCamelCase						:       Tuple				   =				downsample_pad
            __lowerCamelCase						:       Union[str, Any]				   =				drop_path_rate
            __lowerCamelCase						:       List[Any]				   =				num_metaad_blocks
            __lowerCamelCase						:       str				   =				distillation
            __lowerCamelCase						:       Union[str, Any]				   =				use_layer_scale
            __lowerCamelCase						:       Optional[Any]				   =				layer_scale_init_value
            __lowerCamelCase						:       List[str]				   =				image_size
            __lowerCamelCase						:       Any				   =				batch_norm_eps











'''simple docstring'''

def     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # bit count represents no. of bits in the gray code
     if bit_count < 0:
          raise ValueError("""The given input must be positive"""     )

     # get the generated string sequence
     __lowerCamelCase						:       Optional[Any]				   =				gray_code_sequence_string(_lowercase     )
     #
     # convert them to integers
     for i in range(len(_lowercase     )     ):
          __lowerCamelCase						:       List[str]				   =				int(sequence[i],						2     )

     return sequence
def     __lowercase  (_lowercase     )   ->     list:


     """simple docstring"""

     # The approach is a recursive one
     # Base case achieved when either n = 0 or n=1
     if bit_count == 0:
          return ["0"]

     if bit_count == 1:
          return ["0", "1"]

     __lowerCamelCase						:       str				   =				1 << bit_count  # defines the length of the sequence
     # 1<< n is equivalent to 2^n

     # recursive answer will generate answer for n-1 bits
     __lowerCamelCase						:       Union[str, Any]				   =				gray_code_sequence_string(bit_count - 1     )

     __lowerCamelCase						:       Optional[int]				   =				[]

     # append 0 to first half of the smaller sequence generated
     for i in range(seq_len // 2     ):
          __lowerCamelCase						:       Union[str, Any]				   =				"""0""" + smaller_sequence[i]
          sequence.append(_lowercase     )

     # append 1 to second half ... start from the end of the list
     for i in reversed(range(seq_len // 2     )     ):
          __lowerCamelCase						:       Optional[Any]				   =				"""1""" + smaller_sequence[i]
          sequence.append(_lowercase     )

     return sequence


if __name__ == "__main__":
   import doctest

   doctest.testmod()



