





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


_A :   int  			=  logging.get_logger(__name__)

_A :   Union[str, Any]  			=  {
    'google/efficientnet-b7': 'https://huggingface.co/google/efficientnet-b7/resolve/main/config.json',
}


class        __SCREAMING_SNAKE_CASE      (			lowerCAmelCase_ ):
       _UpperCAmelCase				:  List[Any]			   =   "efficientnet"







       def __init__(				self					:     Optional[int]		, A					:     int = 3		, A					:     int = 6_0_0		, A					:     float = 2.0		, A					:     float = 3.1		, A					:     int = 8		, A					:     List[int] = [3, 3, 5, 3, 5, 5, 3]		, A					:     List[int] = [3_2, 1_6, 2_4, 4_0, 8_0, 1_1_2, 1_9_2]		, A					:     List[int] = [1_6, 2_4, 4_0, 8_0, 1_1_2, 1_9_2, 3_2_0]		, A					:     List[int] = []		, A					:     List[int] = [1, 2, 2, 2, 1, 2, 1]		, A					:     List[int] = [1, 2, 2, 3, 3, 4, 1]		, A					:     List[int] = [1, 6, 6, 6, 6, 6, 6]		, A					:     float = 0.25		, A					:     str = "swish"		, A					:     int = 2_5_6_0		, A					:     str = "mean"		, A					:     float = 0.02		, A					:     float = 0.0_01		, A					:     float = 0.99		, A					:     float = 0.5		, A					:     float = 0.2		, **A					:     List[Any]		, )       ->Any:
          super().__init__(**A      )

          lowerCamelCase__       :						Any        =							num_channels
          lowerCamelCase__       :						Any        =							image_size
          lowerCamelCase__       :						Optional[Any]        =							width_coefficient
          lowerCamelCase__       :						Dict        =							depth_coefficient
          lowerCamelCase__       :						int        =							depth_divisor
          lowerCamelCase__       :						List[str]        =							kernel_sizes
          lowerCamelCase__       :						Dict        =							in_channels
          lowerCamelCase__       :						Tuple        =							out_channels
          lowerCamelCase__       :						Tuple        =							depthwise_padding
          lowerCamelCase__       :						Optional[Any]        =							strides
          lowerCamelCase__       :						Optional[Any]        =							num_block_repeats
          lowerCamelCase__       :						str        =							expand_ratios
          lowerCamelCase__       :						Dict        =							squeeze_expansion_ratio
          lowerCamelCase__       :						Tuple        =							hidden_act
          lowerCamelCase__       :						Dict        =							hidden_dim
          lowerCamelCase__       :						List[str]        =							pooling_type
          lowerCamelCase__       :						List[str]        =							initializer_range
          lowerCamelCase__       :						Optional[int]        =							batch_norm_eps
          lowerCamelCase__       :						Optional[int]        =							batch_norm_momentum
          lowerCamelCase__       :						Tuple        =							dropout_rate
          lowerCamelCase__       :						int        =							drop_connect_rate
          lowerCamelCase__       :						int        =							sum(A      ) * 4


class        __SCREAMING_SNAKE_CASE      (			lowerCAmelCase_ ):
       _UpperCAmelCase				:  int			   =   version.parse("1.11" )







       @property
       def 						__lowerCamelCase   (				self					:     str      )       ->Mapping[str, Mapping[int, str]]:
          return OrderedDict(
              [
                  ('''pixel_values''', {0: '''batch''', 1: '''num_channels''', 2: '''height''', 3: '''width'''}),
              ]      )







       @property
       def 						__lowerCamelCase   (				self					:     Optional[int]      )       ->float:
          return 1e-5










def 	_a						(   UpperCAmelCase					)    ->    int:







   """simple docstring"""
   if not isinstance(UpperCAmelCase      ,  UpperCAmelCase					) or number < 0:
      raise ValueError('''Input must be a non-negative integer'''					)

   lowerCamelCase__       :						List[str]        =							0
   while number:
      # This way we arrive at next set bit (next 1) instead of looping
      # through each bit and checking for 1s hence the
      # loop won't run 32 times it will only run the number of `1` times
      number &= number - 1
      count += 1
   return count


if __name__ == "__main__":
       import doctest

       doctest.testmod()



