





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      _SCREAMING_SNAKE_CASE		:







 '''simple docstring'''

 def __init__(self       :     List[str] ,				UpperCAmelCase_       :     Optional[int] ,				UpperCAmelCase_       :     List[Any]=3 ,				UpperCAmelCase_       :     List[str]=32 ,				UpperCAmelCase_       :     List[str]=3 ,				UpperCAmelCase_       :     str=10 ,				UpperCAmelCase_       :     Any=[10, 20, 30, 40] ,				UpperCAmelCase_       :     Dict=[1, 1, 2, 1] ,				UpperCAmelCase_       :     Dict=True ,				UpperCAmelCase_       :     Optional[Any]=True ,				UpperCAmelCase_       :     List[str]="relu" ,				UpperCAmelCase_       :     Optional[Any]=3 ,				UpperCAmelCase_       :     List[Any]=None ,				) ->Tuple:



   '''simple docstring'''



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

 def 							SCREAMING_SNAKE_CASE_      (self       :     List[Any]) ->Tuple:



   '''simple docstring'''



   lowerCamelCase__:   Optional[int]    						=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

   lowerCamelCase__:   int    						=None
   if self.use_labels:
     lowerCamelCase__:   Optional[int]    						=ids_tensor([self.batch_size] ,				self.num_labels)

   lowerCamelCase__:   Optional[int]    						=self.get_config()

   return config, pixel_values, labels

 def 							SCREAMING_SNAKE_CASE_      (self       :     str) ->Optional[int]:



   '''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 							SCREAMING_SNAKE_CASE_      (self       :     Any ,				UpperCAmelCase_       :     Tuple ,				UpperCAmelCase_       :     Any ,				UpperCAmelCase_       :     int) ->int:



   '''simple docstring'''



   lowerCamelCase__:   List[Any]    						=TFResNetModel(config=UpperCAmelCase_)
   lowerCamelCase__:   List[Any]    						=model(UpperCAmelCase_)
   # 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 							SCREAMING_SNAKE_CASE_      (self       :     Optional[int] ,				UpperCAmelCase_       :     Tuple ,				UpperCAmelCase_       :     List[Any] ,				UpperCAmelCase_       :     Dict) ->str:



   '''simple docstring'''



   lowerCamelCase__:   Optional[int]    						=self.num_labels
   lowerCamelCase__:   Union[str, Any]    						=TFResNetForImageClassification(UpperCAmelCase_)
   lowerCamelCase__:   Optional[int]    						=model(UpperCAmelCase_ ,				labels=UpperCAmelCase_)
   self.parent.assertEqual(result.logits.shape ,				(self.batch_size, self.num_labels))







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



   '''simple docstring'''



   lowerCamelCase__:   Any    						=self.prepare_config_and_inputs()
   lowerCamelCase__:   Optional[Any]    						=config_and_inputs
   lowerCamelCase__:   int    						={"pixel_values": pixel_values}
   return config, inputs_dict



@require_tf
class      _SCREAMING_SNAKE_CASE		(			__SCREAMING_SNAKE_CASE					,							__SCREAMING_SNAKE_CASE					,							unittest.TestCase					):







 '''simple docstring'''
 lowercase_	=    (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
 lowercase_	=    (
     {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
     if is_tf_available()
     else {}
 )

 lowercase_	=    False
 lowercase_	=    False
 lowercase_	=    False
 lowercase_	=    False
 lowercase_	=    False

 def 							SCREAMING_SNAKE_CASE_      (self       :     Dict) ->int:



   '''simple docstring'''



   lowerCamelCase__:   Union[str, Any]    						=TFResNetModelTester(self)
   lowerCamelCase__:   Dict    						=ConfigTester(self ,				config_class=UpperCAmelCase_ ,				has_text_modality=UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_      (self       :     Optional[int]) ->Tuple:



   '''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 							SCREAMING_SNAKE_CASE_      (self       :     str) ->Dict:



   '''simple docstring'''



   return

 @unittest.skip(reason="ResNet does not use inputs_embeds")
 def 							SCREAMING_SNAKE_CASE_      (self       :     str) ->Optional[Any]:



   '''simple docstring'''



   pass

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



   '''simple docstring'''



   pass

 def 							SCREAMING_SNAKE_CASE_      (self       :     Dict) ->Tuple:



   '''simple docstring'''



   lowerCamelCase__:   List[str]    						=self.model_tester.prepare_config_and_inputs_for_common()

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

     lowerCamelCase__:   List[str]    						=["pixel_values"]
     self.assertListEqual(arg_names[:1] ,				UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_      (self       :     List[str]) ->int:



   '''simple docstring'''



   lowerCamelCase__:   Optional[Any]    						=self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*UpperCAmelCase_)

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



   '''simple docstring'''



   def check_hidden_states_output(UpperCAmelCase_       :     Optional[Any] ,				UpperCAmelCase_       :     List[Any] ,				UpperCAmelCase_       :     Optional[int]):
     lowerCamelCase__:   Any    						=model_class(UpperCAmelCase_)
     lowerCamelCase__:   List[Any]    						=model(**self._prepare_for_class(UpperCAmelCase_ ,				UpperCAmelCase_))

     lowerCamelCase__:   Union[str, Any]    						=outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

     lowerCamelCase__:   Dict    						=self.model_tester.num_stages
     self.assertEqual(len(UpperCAmelCase_) ,				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] ,				)

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

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       lowerCamelCase__:   List[str]    						=True

       check_hidden_states_output(UpperCAmelCase_ ,				UpperCAmelCase_ ,				UpperCAmelCase_)

 def 							SCREAMING_SNAKE_CASE_      (self       :     Tuple) ->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__:   Tuple    						=self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase_)







 @slow
 def 							SCREAMING_SNAKE_CASE_      (self       :     Tuple) ->Any:



   '''simple docstring'''



   for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     lowerCamelCase__:   int    						=TFResNetModel.from_pretrained(UpperCAmelCase_)
     self.assertIsNotNone(UpperCAmelCase_)





def   lowerCAmelCase_				( )  ->	List[Any]:







  """simple docstring"""





  lowerCamelCase__:   List[Any]    						=Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"	)
  return image







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







 '''simple docstring'''

 @cached_property
 def 							SCREAMING_SNAKE_CASE_      (self       :     int) ->int:



   '''simple docstring'''



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







 @slow
 def 							SCREAMING_SNAKE_CASE_      (self       :     List[str]) ->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__:   int    						=TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0])

   lowerCamelCase__:   Tuple    						=self.default_image_processor
   lowerCamelCase__:   Union[str, Any]    						=prepare_img()
   lowerCamelCase__:   Dict    						=image_processor(images=UpperCAmelCase_ ,				return_tensors="tf")

   # forward pass
   lowerCamelCase__:   Union[str, Any]    						=model(**UpperCAmelCase_)

   # verify the logits
   lowerCamelCase__:   Union[str, Any]    						=tf.TensorShape((1, 1_000))
   self.assertEqual(outputs.logits.shape ,				UpperCAmelCase_)

   lowerCamelCase__:   int    						=tf.constant([-11.1069, -9.7877, -8.3777])

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








from bisect import bisect
from itertools import accumulate





def   lowerCAmelCase_				( __a			,					__a			,					__a			,					__a	)  ->	List[Any]:







  """simple docstring"""





  lowerCamelCase__:   str    						=sorted(zip(__a			,					__a	)			,					key=lambda __a	: x[0] / x[1]			,					reverse=__a	)
  lowerCamelCase__						,      lowerCamelCase__:   str    						=[i[0] for i in r], [i[1] for i in r]
  lowerCamelCase__:   Tuple    						=list(accumulate(__a	)	)
  lowerCamelCase__:   Any    						=bisect(__a			,					__a	)
  return (
      0
      if k == 0
      else sum(vl[:k]	) + (w - acc[k - 1]) * (vl[k]) / (wt[k])
      if k != n
      else sum(vl[:k]	)
  )


if __name__ == "__main__":
     import doctest

     doctest.testmod()

