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






         """simple docstring"""






         A			:  List[Any]   =		parent
         A			:  List[str]   =		batch_size
         A			:  Optional[int]   =		image_size
         A			:  int   =		num_channels
         A			:  List[str]   =		embeddings_size
         A			:  List[str]   =		hidden_sizes
         A			:  Union[str, Any]   =		depths
         A			:  str   =		is_training
         A			:  Optional[int]   =		use_labels
         A			:  int   =		hidden_act
         A			:  int   =		num_labels
         A			:  List[str]   =		scope
         A			:  Tuple   =		len(SCREAMING_SNAKE_CASE      )





     def 							__lowerCAmelCase				(				self      )					->							Optional[Any]:






         """simple docstring"""






         A			:  str   =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

         A			:  List[Any]   =		None
         if self.use_labels:
             A			:  Optional[Any]   =		ids_tensor([self.batch_size]		,     self.num_labels      )

         A			:  Dict   =		self.get_config()

         return config, pixel_values, labels





     def 							__lowerCAmelCase				(				self      )					->							str:






         """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 							__lowerCAmelCase				(				self		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE      )					->							Union[str, Any]:






         """simple docstring"""






         A			:  Tuple   =		TFResNetModel(config=SCREAMING_SNAKE_CASE      )
         A			:  Optional[int]   =		model(SCREAMING_SNAKE_CASE      )
         # 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 							__lowerCAmelCase				(				self		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE      )					->							int:






         """simple docstring"""






         A			:  List[Any]   =		self.num_labels
         A			:  Optional[int]   =		TFResNetForImageClassification(SCREAMING_SNAKE_CASE      )
         A			:  str   =		model(SCREAMING_SNAKE_CASE		,     labels=SCREAMING_SNAKE_CASE      )
         self.parent.assertEqual(result.logits.shape		,     (self.batch_size, self.num_labels)      )





     def 							__lowerCAmelCase				(				self      )					->							str:






         """simple docstring"""






         A			:  int   =		self.prepare_config_and_inputs()
         A,    A,    A			:  int   =		config_and_inputs
         A			:  Union[str, Any]   =		{'''pixel_values''': pixel_values}
         return config, inputs_dict





@require_tf
class 					A							(				__snake_case       ,     __snake_case       ,     unittest.TestCase		):
     __magic_name__          =						(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
     __magic_name__          =						(
         {'''feature-extraction''': TFResNetModel, '''image-classification''': TFResNetForImageClassification}
         if is_tf_available()
         else {}
     )

     __magic_name__          =						False
     __magic_name__          =						False
     __magic_name__          =						False
     __magic_name__          =						False
     __magic_name__          =						False





     def 							__lowerCAmelCase				(				self      )					->							Optional[int]:






         """simple docstring"""






         A			:  int   =		TFResNetModelTester(self      )
         A			:  Any   =		ConfigTester(self		,     config_class=SCREAMING_SNAKE_CASE		,     has_text_modality=SCREAMING_SNAKE_CASE      )





     def 							__lowerCAmelCase				(				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 							__lowerCAmelCase				(				self      )					->							str:






         """simple docstring"""






         return





     @unittest.skip(reason='''ResNet does not use inputs_embeds'''      )
     def 							__lowerCAmelCase				(				self      )					->							List[Any]:






         """simple docstring"""






         pass





     @unittest.skip(reason='''ResNet does not support input and output embeddings'''      )
     def 							__lowerCAmelCase				(				self      )					->							Dict:






         """simple docstring"""






         pass





     def 							__lowerCAmelCase				(				self      )					->							Any:






         """simple docstring"""






         A,    A			:  str   =		self.model_tester.prepare_config_and_inputs_for_common()

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

             A			:  str   =		['''pixel_values''']
             self.assertListEqual(arg_names[:1]		,     SCREAMING_SNAKE_CASE      )





     def 							__lowerCAmelCase				(				self      )					->							List[str]:






         """simple docstring"""






         A			:  Optional[Any]   =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE      )





     def 							__lowerCAmelCase				(				self      )					->							List[str]:






         """simple docstring"""






         def check_hidden_states_output(SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE      ):
             A			:  Optional[Any]   =		model_class(SCREAMING_SNAKE_CASE      )
             A			:  List[Any]   =		model(**self._prepare_for_class(SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE      )      )

             A			:  List[str]   =		outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

             A			:  Union[str, Any]   =		self.model_tester.num_stages
             self.assertEqual(len(SCREAMING_SNAKE_CASE      )		,     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]		,     )

         A,    A			:  Dict   =		self.model_tester.prepare_config_and_inputs_for_common()
         A			:  Dict   =		['''basic''', '''bottleneck''']
         for model_class in self.all_model_classes:
             for layer_type in layers_type:
                 A			:  Dict   =		layer_type
                 A			:  Optional[Any]   =		True
                 check_hidden_states_output(SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE      )

                 # check that output_hidden_states also work using config
                 del inputs_dict["output_hidden_states"]
                 A			:  Dict   =		True

                 check_hidden_states_output(SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE		,     SCREAMING_SNAKE_CASE      )





     def 							__lowerCAmelCase				(				self      )					->							int:






         """simple docstring"""






         A			:  Dict   =		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE      )





     @slow
     def 							__lowerCAmelCase				(				self      )					->							List[Any]:






         """simple docstring"""






         for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             A			:  Optional[int]   =		TFResNetModel.from_pretrained(SCREAMING_SNAKE_CASE      )
             self.assertIsNotNone(SCREAMING_SNAKE_CASE      )







def 						lowerCAmelCase_							(  ):




    '''simple docstring'''



    A			:  Union[str, Any]   =		Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
    return image







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





     @cached_property
     def 							__lowerCAmelCase				(				self      )					->							Dict:






         """simple docstring"""






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





     @slow
     def 							__lowerCAmelCase				(				self      )					->							Any:






         """simple docstring"""






         A			:  Optional[Any]   =		TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]      )

         A			:  Optional[Any]   =		self.default_image_processor
         A			:  List[str]   =		prepare_img()
         A			:  List[str]   =		image_processor(images=SCREAMING_SNAKE_CASE		,     return_tensors='''tf'''      )

         # forward pass
         A			:  Optional[Any]   =		model(**SCREAMING_SNAKE_CASE      )

         # verify the logits
         A			:  Tuple   =		tf.TensorShape((1, 1000)      )
         self.assertEqual(outputs.logits.shape		,     SCREAMING_SNAKE_CASE      )

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

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






'''simple docstring'''




import math
from collections.abc import Callable







def 						lowerCAmelCase_							(  snake_case__						,							snake_case__						,							snake_case__		):




    '''simple docstring'''



    A			:  float   =		xa
    A			:  float   =		xa
    while True:
        if x_n == x_na or function(snake_case__		) == function(snake_case__		):
            raise ZeroDivisionError('''float division by zero, could not find root'''		)
        A			:  float   =		x_na - (
            function(snake_case__		) / ((function(snake_case__		) - function(snake_case__		)) / (x_na - x_n))
        )
        if abs(x_na - x_na		) < 10**-5:
            return x_na
        A			:  Any   =		x_na
        A			:  Any   =		x_na







def 						lowerCAmelCase_							(  snake_case__		):




    '''simple docstring'''



    return math.pow(snake_case__						,							3		) - (2 * x) - 5


if __name__ == "__main__":
      print(intersection(f, 3, 3.5))




