





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


__lowerCamelCase			:	Optional[Any]					    =	logging.get_logger(__name__)

__lowerCamelCase			:	List[str]					    =	{
    """microsoft/focalnet-tiny""": """https://huggingface.co/microsoft/focalnet-tiny/resolve/main/config.json""",
}



class    A__  (			__snake_case			,  __snake_case     ):
      _UpperCAmelCase      :Tuple		       =  'focalnet'





      def __init__(					self			,				A_=224			,				A_=4			,				A_=3			,				A_=96			,				A_=False			,				A_=[192, 384, 768, 768]			,				A_=[2, 2, 6, 2]			,				A_=[2, 2, 2, 2]			,				A_=[3, 3, 3, 3]			,				A_="gelu"			,				A_=4.0			,				A_=0.0			,				A_=0.1			,				A_=False			,				A_=1e-4			,				A_=False			,				A_=False			,				A_=False			,				A_=0.02			,				A_=1e-5			,				A_=32			,				A_=None			,				A_=None			,				**A_			,				):
       '''simple docstring'''




       super().__init__(**A_  )

       UpperCamelCase      :   str			      =  image_size
       UpperCamelCase      :   Dict			      =  patch_size
       UpperCamelCase      :   List[str]			      =  num_channels
       UpperCamelCase      :   str			      =  embed_dim
       UpperCamelCase      :   List[Any]			      =  use_conv_embed
       UpperCamelCase      :   Any			      =  hidden_sizes
       UpperCamelCase      :   Optional[Any]			      =  depths
       UpperCamelCase      :   Union[str, Any]			      =  focal_levels
       UpperCamelCase      :   Any			      =  focal_windows
       UpperCamelCase      :   Union[str, Any]			      =  hidden_act
       UpperCamelCase      :   Union[str, Any]			      =  mlp_ratio
       UpperCamelCase      :   List[Any]			      =  hidden_dropout_prob
       UpperCamelCase      :   int			      =  drop_path_rate
       UpperCamelCase      :   Optional[Any]			      =  use_layerscale
       UpperCamelCase      :   Union[str, Any]			      =  layerscale_value
       UpperCamelCase      :   Tuple			      =  use_post_layernorm
       UpperCamelCase      :   Any			      =  use_post_layernorm_in_modulation
       UpperCamelCase      :   List[Any]			      =  normalize_modulator
       UpperCamelCase      :   Optional[Any]			      =  initializer_range
       UpperCamelCase      :   List[str]			      =  layer_norm_eps
       UpperCamelCase      :   List[str]			      =  encoder_stride
       UpperCamelCase      :   Dict			      =  ["stem"] + [F"""stage{idx}""" for idx in range(1			,				len(self.depths  ) + 1  )]
       UpperCamelCase      ,       UpperCamelCase      :   Dict			      =  get_aligned_output_features_output_indices(
           out_features=A_			,				out_indices=A_			,				stage_names=self.stage_names  )







from typing import Any



def 						A_							(	_lowerCAmelCase	)		->					list[Any]:
 if not input_list:
  return []
 UpperCamelCase      :   List[str]			      =  [input_list.count(_lowerCAmelCase	) for value in input_list]
 UpperCamelCase      :   Dict			      =  max(_lowerCAmelCase	)  # Gets the maximum count in the input list.
 # Gets values of modes
 return sorted({input_list[i] for i, value in enumerate(_lowerCAmelCase	) if value == y}	)


if __name__ == "__main__":
    import doctest

    doctest.testmod()
