import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
     import torch
     from torch import nn

     from transformers import RegNetForImageClassification, RegNetModel
     from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor



class       _snake_case   :


 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					,  ):


   '''simple docstring'''




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


 def      lowercase__     (					self):


   '''simple docstring'''




   lowercase__  :   Tuple    		=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

   lowercase__  :   Dict    		=      self.get_config()

   return config, pixel_values, labels


 def      lowercase__     (					self):


   '''simple docstring'''




   return RegNetConfig(
       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					,  )


 def      lowercase__     (					self					,  SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   lowercase__  :   Optional[int]    		=      RegNetModel(config=snake_case_)
   model.to(snake_case_)
   model.eval()
   lowercase__  :   str    		=      model(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      lowercase__     (					self					,  SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_):


   '''simple docstring'''




   lowercase__  :   Any    		=      self.num_labels
   lowercase__  :   List[str]    		=      RegNetForImageClassification(snake_case_)
   model.to(snake_case_)
   model.eval()
   lowercase__  :   List[Any]    		=      model(snake_case_					,  labels=snake_case_)
   self.parent.assertEqual(result.logits.shape					,  (self.batch_size, self.num_labels))



 def      lowercase__     (					self):


   '''simple docstring'''




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



@require_torch
class       _snake_case   (	_snake_case  ,						_snake_case  ,						unittest.TestCase							):
 __lowerCAmelCase  :     Dict        =			(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
 __lowerCAmelCase  :     Dict        =			(
     {"""feature-extraction""": RegNetModel, """image-classification""": RegNetForImageClassification}
     if is_torch_available()
     else {}
 )

 __lowerCAmelCase  :     Optional[Any]        =			False
 __lowerCAmelCase  :     Dict        =			False
 __lowerCAmelCase  :     List[Any]        =			False
 __lowerCAmelCase  :     Optional[int]        =			False


 def      lowercase__     (					self):


   '''simple docstring'''




   lowercase__  :   Optional[int]    		=      RegNetModelTester(self)
   lowercase__  :   int    		=      ConfigTester(self					,  config_class=snake_case_					,  has_text_modality=snake_case_)


 def      lowercase__     (					self):


   '''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      lowercase__     (					self):


   '''simple docstring'''




   return


 @unittest.skip(reason="""RegNet does not use inputs_embeds""")
 def      lowercase__     (					self):


   '''simple docstring'''




   pass


 @unittest.skip(reason="""RegNet does not support input and output embeddings""")
 def      lowercase__     (					self):


   '''simple docstring'''




   pass


 def      lowercase__     (					self):


   '''simple docstring'''




   lowercase__  :   str    		=      self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     lowercase__  :   Any    		=      model_class(snake_case_)
     lowercase__  :   Optional[int]    		=      inspect.signature(model.forward)
     # signature.parameters is an OrderedDict => so arg_names order is deterministic
     lowercase__  :   List[str]    		=      [*signature.parameters.keys()]

     lowercase__  :   Dict    		=      ["pixel_values"]
     self.assertListEqual(arg_names[:1]					,  snake_case_)


 def      lowercase__     (					self):


   '''simple docstring'''




   lowercase__  :   Any    		=      self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*snake_case_)


 def      lowercase__     (					self):


   '''simple docstring'''




   lowercase__  :   Optional[Any]    		=      self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     lowercase__  :   Union[str, Any]    		=      model_class(config=snake_case_)
     for name, module in model.named_modules():
       if isinstance(snake_case_					,  (nn.BatchNormad, nn.GroupNorm)):
         self.assertTrue(
             torch.all(module.weight == 1)					,  msg=f'Parameter {name} of model {model_class} seems not properly initialized'					,  )
         self.assertTrue(
             torch.all(module.bias == 0)					,  msg=f'Parameter {name} of model {model_class} seems not properly initialized'					,  )


 def      lowercase__     (					self):


   '''simple docstring'''




   def check_hidden_states_output(SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_					,  SCREAMING_SNAKE_CASE_):
     lowercase__  :   List[str]    		=      model_class(snake_case_)
     model.to(snake_case_)
     model.eval()

     with torch.no_grad():
       lowercase__  :   Tuple    		=      model(**self._prepare_for_class(snake_case_					,  snake_case_))

     lowercase__  :   str    		=      outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

     lowercase__  :   Optional[int]    		=      self.model_tester.num_stages
     self.assertEqual(len(snake_case_)					,  expected_num_stages + 1)

     # RegNet'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 // 2, self.model_tester.image_size // 2]					,  )

   lowercase__  :   List[str]    		=      self.model_tester.prepare_config_and_inputs_for_common()
   lowercase__  :   str    		=      ["basic", "bottleneck"]
   for model_class in self.all_model_classes:
     for layer_type in layers_type:
       lowercase__  :   str    		=      layer_type
       lowercase__  :   List[str]    		=      True
       check_hidden_states_output(snake_case_					,  snake_case_					,  snake_case_)

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

       check_hidden_states_output(snake_case_					,  snake_case_					,  snake_case_)


 def      lowercase__     (					self):


   '''simple docstring'''




   lowercase__  :   Dict    		=      self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*snake_case_)



 @slow
 def      lowercase__     (					self):


   '''simple docstring'''




   for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     lowercase__  :   Tuple    		=      RegNetModel.from_pretrained(snake_case_)
     self.assertIsNotNone(snake_case_)

def 		UpperCamelCase	(      )		->	List[Any]:


  '''simple docstring'''






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



@require_torch
@require_vision
class       _snake_case   (	unittest.TestCase							):


 @cached_property
 def      lowercase__     (					self):


   '''simple docstring'''




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



 @slow
 def      lowercase__     (					self):


   '''simple docstring'''




   lowercase__  :   Tuple    		=      RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]).to(snake_case_)

   lowercase__  :   Dict    		=      self.default_image_processor
   lowercase__  :   List[Any]    		=      prepare_img()
   lowercase__  :   Tuple    		=      image_processor(images=snake_case_					,  return_tensors="""pt""").to(snake_case_)

   # forward pass
   with torch.no_grad():
     lowercase__  :   int    		=      model(**snake_case_)

   # verify the logits
   lowercase__  :   List[str]    		=      torch.Size((1, 10_00))
   self.assertEqual(outputs.logits.shape					,  snake_case_)

   lowercase__  :   Optional[int]    		=      torch.tensor([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]).to(snake_case_)

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








import sys

lowerCamelCase__    :		List[Any]          =   (
    """73167176531330624919225119674426574742355349194934"""
    """96983520312774506326239578318016984801869478851843"""
    """85861560789112949495459501737958331952853208805511"""
    """12540698747158523863050715693290963295227443043557"""
    """66896648950445244523161731856403098711121722383113"""
    """62229893423380308135336276614282806444486645238749"""
    """30358907296290491560440772390713810515859307960866"""
    """70172427121883998797908792274921901699720888093776"""
    """65727333001053367881220235421809751254540594752243"""
    """52584907711670556013604839586446706324415722155397"""
    """53697817977846174064955149290862569321978468622482"""
    """83972241375657056057490261407972968652414535100474"""
    """82166370484403199890008895243450658541227588666881"""
    """16427171479924442928230863465674813919123162824586"""
    """17866458359124566529476545682848912883142607690042"""
    """24219022671055626321111109370544217506941658960408"""
    """07198403850962455444362981230987879927244284909188"""
    """84580156166097919133875499200524063689912560717606"""
    """05886116467109405077541002256983155200055935729725"""
    """71636269561882670428252483600823257530420752963450"""
)

def 		UpperCamelCase	(      lowercase_ = N   )		->	int:


  '''simple docstring'''






  lowercase__  :   int    		=      -sys.maxsize - 1
  for i in range(len(lowercase_   ) - 12   ):
    lowercase__  :   Optional[int]    		=      1
    for j in range(13   ):
      product *= int(n[i + j]   )
    if product > largest_product:
      lowercase__  :   int    		=      product
  return largest_product


if __name__ == "__main__":
     print(f'''{solution() = }''')






