





'''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					:      Optional[int]					,lowerCamelCase					:      Dict					,lowerCamelCase					:      Any=3					,lowerCamelCase					:      Any=32					,lowerCamelCase					:      Optional[Any]=3					,lowerCamelCase					:      Any=10					,lowerCamelCase					:      Dict=[10, 20, 30, 40]					,lowerCamelCase					:      Dict=[1, 1, 2, 1]					,lowerCamelCase					:      Dict=True					,lowerCamelCase					:      Any=True					,lowerCamelCase					:      str="relu"					,lowerCamelCase					:      Optional[int]=3					,lowerCamelCase					:      List[Any]=None					,):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							parent
      __SCREAMING_SNAKE_CASE   				=							batch_size
      __SCREAMING_SNAKE_CASE   				=							image_size
      __SCREAMING_SNAKE_CASE   				=							num_channels
      __SCREAMING_SNAKE_CASE   				=							embeddings_size
      __SCREAMING_SNAKE_CASE   				=							hidden_sizes
      __SCREAMING_SNAKE_CASE   				=							depths
      __SCREAMING_SNAKE_CASE   				=							is_training
      __SCREAMING_SNAKE_CASE   				=							use_labels
      __SCREAMING_SNAKE_CASE   				=							hidden_act
      __SCREAMING_SNAKE_CASE   				=							num_labels
      __SCREAMING_SNAKE_CASE   				=							scope
      __SCREAMING_SNAKE_CASE   				=							len(lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]     )

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

      __SCREAMING_SNAKE_CASE   				=							self.get_config()

      return config, pixel_values, labels





   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      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   UpperCAmelCase__  (       self					:      Dict					,lowerCamelCase					:      str					,lowerCamelCase					:      List[Any]					,lowerCamelCase					:      int     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							TFResNetModel(config=lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase     )
      # 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   UpperCAmelCase__  (       self					:      int					,lowerCamelCase					:      List[str]					,lowerCamelCase					:      Optional[int]					,lowerCamelCase					:      List[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.num_labels
      __SCREAMING_SNAKE_CASE   				=							TFResNetForImageClassification(lowerCamelCase     )
      __SCREAMING_SNAKE_CASE   				=							model(lowerCamelCase					,labels=lowerCamelCase     )
      self.parent.assertEqual(result.logits.shape					,(self.batch_size, self.num_labels)     )





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.prepare_config_and_inputs()
      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							config_and_inputs
      __SCREAMING_SNAKE_CASE   				=							{"""pixel_values""": pixel_values}
      return config, inputs_dict







@require_tf
class __a			( _snake_case, _snake_case, unittest.TestCase      ):
   __UpperCamelCase :			int						   =						(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
   __UpperCamelCase :			str						   =						(
       {'feature-extraction': TFResNetModel, 'image-classification': TFResNetForImageClassification}
       if is_tf_available()
       else {}
   )

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





   def   UpperCAmelCase__  (       self					:      Optional[int]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							TFResNetModelTester(self     )
      __SCREAMING_SNAKE_CASE   				=							ConfigTester(self					,config_class=lowerCamelCase					,has_text_modality=lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      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   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      return





   @unittest.skip(reason="""ResNet does not use inputs_embeds"""     )
   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      pass





   @unittest.skip(reason="""ResNet does not support input and output embeddings"""     )
   def   UpperCAmelCase__  (       self					:      Optional[int]     ):

      '''simple docstring'''

      pass





   def   UpperCAmelCase__  (       self					:      List[Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE				,  __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs_for_common()

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

         __SCREAMING_SNAKE_CASE   				=							["""pixel_values"""]
         self.assertListEqual(arg_names[:1]					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Union[str, Any]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      Dict     ):

      '''simple docstring'''

      def check_hidden_states_output(lowerCamelCase					:      List[str]					,lowerCamelCase					:      Dict					,lowerCamelCase					:      str     ):
         __SCREAMING_SNAKE_CASE   				=							model_class(lowerCamelCase     )
         __SCREAMING_SNAKE_CASE   				=							model(**self._prepare_for_class(lowerCamelCase					,lowerCamelCase     )     )

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

         __SCREAMING_SNAKE_CASE   				=							self.model_tester.num_stages
         self.assertEqual(len(lowerCamelCase     )					,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]					,)

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

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

            check_hidden_states_output(lowerCamelCase					,lowerCamelCase					,lowerCamelCase     )





   def   UpperCAmelCase__  (       self					:      str     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_image_classification(*lowerCamelCase     )





   @slow
   def   UpperCAmelCase__  (       self					:      Any     ):

      '''simple docstring'''

      for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         __SCREAMING_SNAKE_CASE   				=							TFResNetModel.from_pretrained(lowerCamelCase     )
         self.assertIsNotNone(lowerCamelCase     )





def     __magic_name__							(				)    ->       Optional[Any]:

   '''simple docstring'''







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







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





   @cached_property
   def   UpperCAmelCase__  (       self					:      Optional[Any]     ):

      '''simple docstring'''

      return (
          AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )
          if is_vision_available()
          else None
      )





   @slow
   def   UpperCAmelCase__  (       self					:      Optional[int]     ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE   				=							TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )

      __SCREAMING_SNAKE_CASE   				=							self.default_image_processor
      __SCREAMING_SNAKE_CASE   				=							prepare_img()
      __SCREAMING_SNAKE_CASE   				=							image_processor(images=lowerCamelCase					,return_tensors="""tf"""     )

      # forward pass
      __SCREAMING_SNAKE_CASE   				=							model(**lowerCamelCase     )

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

      __SCREAMING_SNAKE_CASE   				=							tf.constant([-11.1_069, -9.7_877, -8.3_777]     )

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







"""simple docstring"""




def     __magic_name__		(					UpperCamelCase     :		float							,		UpperCamelCase     :		float							,		UpperCamelCase     :		float							,		UpperCamelCase     :		float							,		UpperCamelCase     :		float							,		)     ->						float:
    a__		=			[redshift, radiation_density, matter_density, dark_energy]
    if any(p < 0 for p in parameters     ):
        raise ValueError('All input parameters must be positive'     )

    if any(p > 1 for p in parameters[1:4]     ):
        raise ValueError('Relative densities cannot be greater than one'     )
    else:
        a__		=			1 - (matter_density + radiation_density + dark_energy)

        a__		=			(
            radiation_density * (redshift + 1) ** 4
            + matter_density * (redshift + 1) ** 3
            + curvature * (redshift + 1) ** 2
            + dark_energy
        )

        a__		=			hubble_constant * e_a ** (1 / 2)
        return hubble


if __name__ == "__main__":
    import doctest

    # run doctest
    doctest.testmod()

    # demo LCDM approximation
    a		:       Any     						=       0.3

    print(
        hubble_parameter(
            hubble_constant=68.3,
            radiation_density=1e-4,
            matter_density=matter_density,
            dark_energy=1 - matter_density,
            redshift=0,
        )
    )


