'''simple docstring'''





from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import TFResNetForImageClassification, TFResNetModel
    from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor




class        __A      :



    def __init__(self    :    List[Any]   ,			__a    :    List[Any]   ,			__a    :    int=3   ,			__a    :    Optional[int]=32   ,			__a    :    Optional[Any]=3   ,			__a    :    List[Any]=10   ,			__a    :    str=[10, 20, 30, 40]   ,			__a    :    Any=[1, 1, 2, 1]   ,			__a    :    str=True   ,			__a    :    Optional[Any]=True   ,			__a    :    Optional[int]="relu"   ,			__a    :    Optional[Any]=3   ,			__a    :    Union[str, Any]=None   ,			):
         UpperCAmelCase_           =   parent
         UpperCAmelCase_           =   batch_size
         UpperCAmelCase_           =   image_size
         UpperCAmelCase_           =   num_channels
         UpperCAmelCase_           =   embeddings_size
         UpperCAmelCase_           =   hidden_sizes
         UpperCAmelCase_           =   depths
         UpperCAmelCase_           =   is_training
         UpperCAmelCase_           =   use_labels
         UpperCAmelCase_           =   hidden_act
         UpperCAmelCase_           =   num_labels
         UpperCAmelCase_           =   scope
         UpperCAmelCase_           =   len(__a )



    def 					_lowercase						(self    :    Tuple ):
         UpperCAmelCase_           =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

         UpperCAmelCase_           =   None
         if self.use_labels:
              UpperCAmelCase_           =   ids_tensor([self.batch_size]   ,			self.num_labels )

         UpperCAmelCase_           =   self.get_config()

         return config, pixel_values, labels



    def 					_lowercase						(self    :    int ):
         return ResNetConfig(
             num_channels=self.num_channels   ,			embeddings_size=self.embeddings_size   ,			hidden_sizes=self.hidden_sizes   ,			depths=self.depths   ,			hidden_act=self.hidden_act   ,			num_labels=self.num_labels   ,			image_size=self.image_size   ,			)



    def 					_lowercase						(self    :    str   ,			__a    :    List[Any]   ,			__a    :    Tuple   ,			__a    :    Dict ):
         UpperCAmelCase_           =   TFResNetModel(config=__a )
         UpperCAmelCase_           =   model(__a )
         # expected last hidden states: B, C, H // 32, W // 32
         self.parent.assertEqual(
             result.last_hidden_state.shape   ,			(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)   ,			)



    def 					_lowercase						(self    :    List[Any]   ,			__a    :    Tuple   ,			__a    :    Dict   ,			__a    :    Tuple ):
         UpperCAmelCase_           =   self.num_labels
         UpperCAmelCase_           =   TFResNetForImageClassification(__a )
         UpperCAmelCase_           =   model(__a   ,			labels=__a )
         self.parent.assertEqual(result.logits.shape   ,			(self.batch_size, self.num_labels) )






    def 					_lowercase						(self    :    Any ):
         UpperCAmelCase_           =   self.prepare_config_and_inputs()
         UpperCAmelCase_    , UpperCAmelCase_    , UpperCAmelCase_           =   config_and_inputs
         UpperCAmelCase_           =   {"pixel_values": pixel_values}
         return config, inputs_dict




@require_tf
class        __A      ( UpperCamelCase__		,	UpperCamelCase__		,	unittest.TestCase	):
    a__       :						Union[str, Any]          =  (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
    a__       :						List[Any]          =  (
        {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
        if is_tf_available()
        else {}
    )

    a__       :						int          =  False
    a__       :						str          =  False
    a__       :						Optional[Any]          =  False
    a__       :						List[str]          =  False
    a__       :						str          =  False



    def 					_lowercase						(self    :    Tuple ):
         UpperCAmelCase_           =   TFResNetModelTester(self )
         UpperCAmelCase_           =   ConfigTester(self   ,			config_class=__a   ,			has_text_modality=__a )



    def 					_lowercase						(self    :    Union[str, Any] ):
         self.create_and_test_config_common_properties()
         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()



    def 					_lowercase						(self    :    Optional[int] ):
         return



    @unittest.skip(reason="ResNet does not use inputs_embeds" )
    def 					_lowercase						(self    :    Optional[Any] ):
         pass



    @unittest.skip(reason="ResNet does not support input and output embeddings" )
    def 					_lowercase						(self    :    str ):
         pass



    def 					_lowercase						(self    :    Optional[Any] ):
         UpperCAmelCase_    , UpperCAmelCase_           =   self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
              UpperCAmelCase_           =   model_class(__a )
              UpperCAmelCase_           =   inspect.signature(model.call )
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              UpperCAmelCase_           =   [*signature.parameters.keys()]

              UpperCAmelCase_           =   ["pixel_values"]
              self.assertListEqual(arg_names[:1]   ,			__a )



    def 					_lowercase						(self    :    str ):
         UpperCAmelCase_           =   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__a )



    def 					_lowercase						(self    :    List[Any] ):
         def check_hidden_states_output(__a    :    str   ,			__a    :    Dict   ,			__a    :    Tuple ):
              UpperCAmelCase_           =   model_class(__a )
              UpperCAmelCase_           =   model(**self._prepare_for_class(__a   ,			__a ) )

              UpperCAmelCase_           =   outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

              UpperCAmelCase_           =   self.model_tester.num_stages
              self.assertEqual(len(__a )   ,			expected_num_stages + 1 )

              # ResNet's feature maps are of shape (batch_size, num_channels, height, width)
              self.assertListEqual(
                  list(hidden_states[0].shape[-2:] )   ,			[self.model_tester.image_size // 4, self.model_tester.image_size // 4]   ,			)

         UpperCAmelCase_    , UpperCAmelCase_           =   self.model_tester.prepare_config_and_inputs_for_common()
         UpperCAmelCase_           =   ["basic", "bottleneck"]
         for model_class in self.all_model_classes:
              for layer_type in layers_type:
                   UpperCAmelCase_           =   layer_type
                   UpperCAmelCase_           =   True
                   check_hidden_states_output(__a   ,			__a   ,			__a )

                   # check that output_hidden_states also work using config
                   del inputs_dict["output_hidden_states"]
                   UpperCAmelCase_           =   True

                   check_hidden_states_output(__a   ,			__a   ,			__a )



    def 					_lowercase						(self    :    Tuple ):
         UpperCAmelCase_           =   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*__a )






    @slow
    def 					_lowercase						(self    :    List[str] ):
         for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCAmelCase_           =   TFResNetModel.from_pretrained(__a )
              self.assertIsNotNone(__a )





def 	lowerCAmelCase_				(					)    ->      str:


     '''simple docstring'''




     UpperCAmelCase_           =   Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
     return image






@require_tf
@require_vision
class        __A      ( unittest.TestCase	):



    @cached_property
    def 					_lowercase						(self    :    List[str] ):
         return (
             AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] )
             if is_vision_available()
             else None
         )






    @slow
    def 					_lowercase						(self    :    str ):
         UpperCAmelCase_           =   TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0] )

         UpperCAmelCase_           =   self.default_image_processor
         UpperCAmelCase_           =   prepare_img()
         UpperCAmelCase_           =   image_processor(images=__a   ,			return_tensors="tf" )

         # forward pass
         UpperCAmelCase_           =   model(**__a )

         # verify the logits
         UpperCAmelCase_           =   tf.TensorShape((1, 1000) )
         self.assertEqual(outputs.logits.shape   ,			__a )

         UpperCAmelCase_           =   tf.constant([-11.10_69, -9.78_77, -8.37_77] )

         self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()   ,			__a   ,			atol=1E-4 ) )





'''simple docstring'''





import os
from math import logaa





def 	lowerCAmelCase_				(					snake_case_       : str = "base_exp.txt"			)    ->      int:


     '''simple docstring'''




     UpperCAmelCase_           =   0
     UpperCAmelCase_           =   0
     for i, line in enumerate(open(os.path.join(os.path.dirname(snake_case_			)					,    snake_case_			)			)			):
          UpperCAmelCase_    , UpperCAmelCase_           =   list(map(snake_case_					,    line.split(","			)			)			)
          if x * logaa(snake_case_			) > largest:
               UpperCAmelCase_           =   x * logaa(snake_case_			)
               UpperCAmelCase_           =   i + 1
     return result


if __name__ == "__main__":
    print(solution())




