
"""simple docstring"""






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


UpperCamelCase_							=					logging.get_logger(__name__)

UpperCamelCase_							=					{
    'google/efficientnet-b7': 'https://huggingface.co/google/efficientnet-b7/resolve/main/config.json',
}





class 				snake_case    (			__A						):
   a_ :						str			 =			"efficientnet"







   def __init__(      self    ,				__UpperCAmelCase = 3    ,				__UpperCAmelCase = 6_00    ,				__UpperCAmelCase = 2.0    ,				__UpperCAmelCase = 3.1    ,				__UpperCAmelCase = 8    ,				__UpperCAmelCase = [3, 3, 5, 3, 5, 5, 3]    ,				__UpperCAmelCase = [32, 16, 24, 40, 80, 1_12, 1_92]    ,				__UpperCAmelCase = [16, 24, 40, 80, 1_12, 1_92, 3_20]    ,				__UpperCAmelCase = []    ,				__UpperCAmelCase = [1, 2, 2, 2, 1, 2, 1]    ,				__UpperCAmelCase = [1, 2, 2, 3, 3, 4, 1]    ,				__UpperCAmelCase = [1, 6, 6, 6, 6, 6, 6]    ,				__UpperCAmelCase = 0.25    ,				__UpperCAmelCase = "swish"    ,				__UpperCAmelCase = 25_60    ,				__UpperCAmelCase = "mean"    ,				__UpperCAmelCase = 0.02    ,				__UpperCAmelCase = 0.001    ,				__UpperCAmelCase = 0.99    ,				__UpperCAmelCase = 0.5    ,				__UpperCAmelCase = 0.2    ,				**__UpperCAmelCase    ,				)					->str:
      super().__init__(**_UpperCamelCase)

      a_							=			num_channels
      a_							=			image_size
      a_							=			width_coefficient
      a_							=			depth_coefficient
      a_							=			depth_divisor
      a_							=			kernel_sizes
      a_							=			in_channels
      a_							=			out_channels
      a_							=			depthwise_padding
      a_							=			strides
      a_							=			num_block_repeats
      a_							=			expand_ratios
      a_							=			squeeze_expansion_ratio
      a_							=			hidden_act
      a_							=			hidden_dim
      a_							=			pooling_type
      a_							=			initializer_range
      a_							=			batch_norm_eps
      a_							=			batch_norm_momentum
      a_							=			dropout_rate
      a_							=			drop_connect_rate
      a_							=			sum(_UpperCamelCase) * 4






class 				snake_case    (			__A						):
   a_ :						Union[str, Any]			 =			version.parse("""1.11"""						)







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







   @property
   def 					UpperCAmelCase__     (      self)					->float:
      return 1E-5


import unittest

from transformers.testing_utils import CaptureStdout
from transformers.tools.python_interpreter import evaluate


def   __SCREAMING_SNAKE_CASE					(SCREAMING_SNAKE_CASE__       ):
						return x + 2





class 	snake_case_   (		unittest.TestCase					):







			'''simple docstring'''

			def 				snake_case__(     self :				Optional[Any]							)      ->int:
									snake_case_   =	'''x = 3'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result == 3
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3}							)

									snake_case_   =	'''x = y'''
									snake_case_   =	{'''y''': 5}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 5, '''y''': 5}							)







			def 				snake_case__(     self :				Dict							)      ->Optional[int]:
									snake_case_   =	'''y = add_two(x)'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 5}							)

									# Won't work without the tool
									with CaptureStdout() as out:
															snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result is None
									assert "tried to execute add_two" in out.out







			def 				snake_case__(     self :				Union[str, Any]							)      ->Dict:
									snake_case_   =	'''x = 3'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result == 3
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3}							)







			def 				snake_case__(     self :				Optional[int]							)      ->Optional[int]:
									snake_case_   =	'''test_dict = {\'x\': x, \'y\': add_two(x)}'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 5}							)
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}							)







			def 				snake_case__(     self :				Dict							)      ->str:
									snake_case_   =	'''x = 3\ny = 5'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 5}							)







			def 				snake_case__(     self :				str							)      ->Tuple:
									snake_case_   =	'''text = f\'This is x: {x}.\''''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == "This is x: 3."
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''text''': '''This is x: 3.'''}							)







			def 				snake_case__(     self :				Optional[Any]							)      ->List[str]:
									snake_case_   =	'''if x <= 3:\n    y = 2\nelse:\n    y = 5'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 2
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 2}							)

									snake_case_   =	{'''x''': 8}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									# evaluate returns the value of the last assignment.
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 8, '''y''': 5}							)







			def 				snake_case__(     self :				str							)      ->str:
									snake_case_   =	'''test_list = [x, add_two(x)]'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									self.assertListEqual(_UpperCamelCase							,   [3, 5]							)
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_list''': [3, 5]}							)







			def 				snake_case__(     self :				Any							)      ->List[Any]:
									snake_case_   =	'''y = x'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {}							,   state=_UpperCamelCase							)
									assert result == 3
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''y''': 3}							)







			def 				snake_case__(     self :				Optional[int]							)      ->Dict:
									snake_case_   =	'''test_list = [x, add_two(x)]\ntest_list[1]'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_list''': [3, 5]}							)

									snake_case_   =	'''test_dict = {\'x\': x, \'y\': add_two(x)}\ntest_dict[\'y\']'''
									snake_case_   =	{'''x''': 3}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''add_two''': add_two}							,   state=_UpperCamelCase							)
									assert result == 5
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}							)







			def 				snake_case__(     self :				Optional[Any]							)      ->int:
									snake_case_   =	'''x = 0\nfor i in range(3):\n    x = i'''
									snake_case_   =	{}
									snake_case_   =	evaluate(_UpperCamelCase							,   {'''range''': range}							,   state=_UpperCamelCase							)
									assert result == 2
									self.assertDictEqual(_UpperCamelCase							,   {'''x''': 2, '''i''': 2}							)