from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


_SCREAMING_SNAKE_CASE										=						logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE										=						{
    'microsoft/focalnet-tiny': 'https://huggingface.co/microsoft/focalnet-tiny/resolve/main/config.json',
}



class 				a							(			__lowerCAmelCase       ,			__lowerCAmelCase       ):







 """simple docstring"""






 lowerCamelCase	:Optional[Any]    			=		'''focalnet'''



 def __init__(					self		,				lowerCAmelCase_=2_24		,				lowerCAmelCase_=4		,				lowerCAmelCase_=3		,				lowerCAmelCase_=96		,				lowerCAmelCase_=False		,				lowerCAmelCase_=[1_92, 3_84, 7_68, 7_68]		,				lowerCAmelCase_=[2, 2, 6, 2]		,				lowerCAmelCase_=[2, 2, 2, 2]		,				lowerCAmelCase_=[3, 3, 3, 3]		,				lowerCAmelCase_="gelu"		,				lowerCAmelCase_=4.0		,				lowerCAmelCase_=0.0		,				lowerCAmelCase_=0.1		,				lowerCAmelCase_=False		,				lowerCAmelCase_=1E-4		,				lowerCAmelCase_=False		,				lowerCAmelCase_=False		,				lowerCAmelCase_=False		,				lowerCAmelCase_=0.02		,				lowerCAmelCase_=1E-5		,				lowerCAmelCase_=32		,				lowerCAmelCase_=None		,				lowerCAmelCase_=None		,				**lowerCAmelCase_		,				)  ->					Tuple:
        super().__init__(**lowerCAmelCase_							)

        _A        =  image_size
        _A        =  patch_size
        _A        =  num_channels
        _A        =  embed_dim
        _A        =  use_conv_embed
        _A        =  hidden_sizes
        _A        =  depths
        _A        =  focal_levels
        _A        =  focal_windows
        _A        =  hidden_act
        _A        =  mlp_ratio
        _A        =  hidden_dropout_prob
        _A        =  drop_path_rate
        _A        =  use_layerscale
        _A        =  layerscale_value
        _A        =  use_post_layernorm
        _A        =  use_post_layernorm_in_modulation
        _A        =  normalize_modulator
        _A        =  initializer_range
        _A        =  layer_norm_eps
        _A        =  encoder_stride
        _A        =  ["""stem"""] + [F'''stage{idx}''' for idx in range(1		,				len(self.depths							) + 1							)]
        _A   ,  _A        =  get_aligned_output_features_output_indices(
            out_features=lowerCAmelCase_		,				out_indices=lowerCAmelCase_		,				stage_names=self.stage_names							)





def  snake_case  (       snake_case__			:str = "The quick brown fox jumps over the lazy dog"   ,	)						->   bool:
       _A        =  set()

       # Replace all the whitespace in our sentence
       _A        =  input_str.replace(""" """   ,	"""""")
       for alpha in input_str:
              if "a" <= alpha.lower() <= "z":
                     frequency.add(alpha.lower())
       return len(snake_case__) == 26






def  snake_case  (       snake_case__			:str = "The quick brown fox jumps over the lazy dog"   ,	)						->   bool:
       _A        =  [False] * 26
       for char in input_str:
              if char.islower():
                     _A        =  True
              elif char.isupper():
                     _A        =  True
       return all(snake_case__)






def  snake_case  (       snake_case__			:str = "The quick brown fox jumps over the lazy dog"   ,	)						->   bool:
       return len({char for char in input_str.lower() if char.isalpha()}) == 26






def  snake_case  (       )						->   None:
       from timeit import timeit

       _A        =  """from __main__ import is_pangram, is_pangram_faster, is_pangram_fastest"""
       print(timeit("""is_pangram()"""   ,	setup=snake_case__))
       print(timeit("""is_pangram_faster()"""   ,	setup=snake_case__))
       print(timeit("""is_pangram_fastest()"""   ,	setup=snake_case__))
       # 5.348480500048026, 2.6477354579837993, 1.8470395830227062
       # 5.036091582966037, 2.644472333951853,  1.8869528750656173


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    benchmark()




