

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





       '''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(_a			)





  def 						A  (		self				:     Union[str, Any]			)     ->   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 						A  (		self				:     Dict			)     ->   Union[str, 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 						A  (		self				:     Any							, _a				:     List[str]							, _a				:     int							, _a				:     int			)     ->   List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFResNetModel(config=_a			)
       _SCREAMING_SNAKE_CASE							   =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 						A  (		self				:     List[Any]							, _a				:     Any							, _a				:     Union[str, Any]							, _a				:     Union[str, Any]			)     ->   str:





       '''simple docstring'''






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





  def 						A  (		self				:     Union[str, Any]			)     ->   Optional[int]:





       '''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__   (	A__					,       A__					,       unittest.TestCase  ):
  A__					=    (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
  A__					=    (
      {'feature-extraction': TFResNetModel, 'image-classification': TFResNetForImageClassification}
      if is_tf_available()
      else {}
  )

  A__					=    False
  A__					=    False
  A__					=    False
  A__					=    False
  A__					=    False





  def 						A  (		self				:     Any			)     ->   Union[str, Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =TFResNetModelTester(self			)
       _SCREAMING_SNAKE_CASE							   =ConfigTester(self							, config_class=_a							, has_text_modality=_a			)





  def 						A  (		self				:     List[Any]			)     ->   Any:





       '''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 						A  (		self				:     List[str]			)     ->   Optional[int]:





       '''simple docstring'''






       return





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





       '''simple docstring'''






       pass





  @unittest.skip(reason='ResNet does not support input and output embeddings'			)
  def 						A  (		self				:     Optional[int]			)     ->   Optional[Any]:





       '''simple docstring'''






       pass





  def 						A  (		self				:     Union[str, Any]			)     ->   Optional[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(_a			)
            _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]							, _a			)





  def 						A  (		self				:     Union[str, Any]			)     ->   List[str]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_a			)





  def 						A  (		self				:     Union[str, Any]			)     ->   Optional[Any]:





       '''simple docstring'''






       def check_hidden_states_output(_a				:     List[str]							, _a				:     List[Any]							, _a				:     Dict			):
            _SCREAMING_SNAKE_CASE							   =model_class(_a			)
            _SCREAMING_SNAKE_CASE							   =model(**self._prepare_for_class(_a							, _a			)			)

            _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(_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]							, )

       _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(_a							, _a							, _a			)

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

                 check_hidden_states_output(_a							, _a							, _a			)





  def 						A  (		self				:     Union[str, Any]			)     ->   Dict:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							   =self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_a			)





  @slow
  def 						A  (		self				:     Optional[Any]			)     ->   Dict:





       '''simple docstring'''






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


def 	_lowerCAmelCase (						)				->      int:
     """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 						A  (		self				:     str			)     ->   str:





       '''simple docstring'''






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





  @slow
  def 						A  (		self				:     int			)     ->   Tuple:





       '''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=_a							, return_tensors='tf'			)

       # forward pass
       _SCREAMING_SNAKE_CASE							   =model(**_a			)

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

       _SCREAMING_SNAKE_CASE							   =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'''
from math import factorial


def 	_lowerCAmelCase (						_UpperCamelCase						:					int							,			_UpperCamelCase						:					int							,			_UpperCamelCase						:					float    )				->      float:
     """simple docstring"""




     if successes > trials:
          raise ValueError('successes must be lower or equal to trials'    )
     if trials < 0 or successes < 0:
          raise ValueError('the function is defined for non-negative integers'    )
     if not isinstance(_UpperCamelCase							,			_UpperCamelCase    ) or not isinstance(_UpperCamelCase							,			_UpperCamelCase    ):
          raise ValueError('the function is defined for non-negative integers'    )
     if not 0 < prob < 1:
          raise ValueError('prob has to be in range of 1 - 0'    )
     _SCREAMING_SNAKE_CASE							   =(prob**successes) * ((1 - prob) ** (trials - successes))
     # Calculate the binomial coefficient: n! / k!(n-k)!
     _SCREAMING_SNAKE_CASE							   =float(factorial(_UpperCamelCase    )    )
     coefficient /= factorial(_UpperCamelCase    ) * factorial(trials - successes    )
     return probability * coefficient


if __name__ == "__main__":
     from doctest import testmod

     testmod()
     print("Probability of 2 successes out of 4 trails")
     print("with probability of 0.75 is:", end=" ")
     print(binomial_distribution(2, 4, 0.7_5))
