





'''simple docstring'''


import inspect
import unittest

from transformers import ResNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
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 ResNetBackbone, ResNetForImageClassification, ResNetModel
       from transformers.models.resnet.modeling_resnet import RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
       from PIL import Image

       from transformers import AutoImageProcessor

class 				lowerCAmelCase_						:




 def __init__(		self     ,       _lowerCAmelCase     ,       _lowerCAmelCase=3     ,       _lowerCAmelCase=32     ,       _lowerCAmelCase=3     ,       _lowerCAmelCase=10     ,       _lowerCAmelCase=[10, 20, 30, 40]     ,       _lowerCAmelCase=[1, 1, 2, 1]     ,       _lowerCAmelCase=True     ,       _lowerCAmelCase=True     ,       _lowerCAmelCase="relu"     ,       _lowerCAmelCase=3     ,       _lowerCAmelCase=None     ,       _lowerCAmelCase=["stage2", "stage3", "stage4"]     ,       _lowerCAmelCase=[2, 3, 4]     ,       )      ->							List[Any]:
     _lowerCAmelCase		     = parent
     _lowerCAmelCase		     = batch_size
     _lowerCAmelCase		     = image_size
     _lowerCAmelCase		     = num_channels
     _lowerCAmelCase		     = embeddings_size
     _lowerCAmelCase		     = hidden_sizes
     _lowerCAmelCase		     = depths
     _lowerCAmelCase		     = is_training
     _lowerCAmelCase		     = use_labels
     _lowerCAmelCase		     = hidden_act
     _lowerCAmelCase		     = num_labels
     _lowerCAmelCase		     = scope
     _lowerCAmelCase		     = len(_lowerCAmelCase						)
     _lowerCAmelCase		     = out_features
     _lowerCAmelCase		     = out_indices




 def 							_snake_case				(		self						)      ->							Dict:
     _lowerCAmelCase		     = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

     _lowerCAmelCase		     = self.get_config()

     return config, pixel_values, labels




 def 							_snake_case				(		self						)      ->							Dict:
     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     ,       out_features=self.out_features     ,       out_indices=self.out_indices     ,       )




 def 							_snake_case				(		self     ,       _lowerCAmelCase     ,       _lowerCAmelCase     ,       _lowerCAmelCase						)      ->							int:
     _lowerCAmelCase		     = ResNetModel(config=_lowerCAmelCase						)
     model.to(_lowerCAmelCase						)
     model.eval()
     _lowerCAmelCase		     = 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 							_snake_case				(		self     ,       _lowerCAmelCase     ,       _lowerCAmelCase     ,       _lowerCAmelCase						)      ->							Tuple:
     _lowerCAmelCase		     = self.num_labels
     _lowerCAmelCase		     = ResNetForImageClassification(_lowerCAmelCase						)
     model.to(_lowerCAmelCase						)
     model.eval()
     _lowerCAmelCase		     = model(_lowerCAmelCase     ,       labels=_lowerCAmelCase						)
     self.parent.assertEqual(result.logits.shape     ,       (self.batch_size, self.num_labels)						)




 def 							_snake_case				(		self     ,       _lowerCAmelCase     ,       _lowerCAmelCase     ,       _lowerCAmelCase						)      ->							Optional[int]:
     _lowerCAmelCase		     = ResNetBackbone(config=_lowerCAmelCase						)
     model.to(_lowerCAmelCase						)
     model.eval()
     _lowerCAmelCase		     = model(_lowerCAmelCase						)

     # verify feature maps
     self.parent.assertEqual(len(result.feature_maps						)     ,       len(config.out_features						)						)
     self.parent.assertListEqual(list(result.feature_maps[0].shape						)     ,       [self.batch_size, self.hidden_sizes[1], 4, 4]						)

     # verify channels
     self.parent.assertEqual(len(model.channels						)     ,       len(config.out_features						)						)
     self.parent.assertListEqual(model.channels     ,       config.hidden_sizes[1:]						)

     # verify backbone works with out_features=None
     _lowerCAmelCase		     = None
     _lowerCAmelCase		     = ResNetBackbone(config=_lowerCAmelCase						)
     model.to(_lowerCAmelCase						)
     model.eval()
     _lowerCAmelCase		     = model(_lowerCAmelCase						)

     # verify feature maps
     self.parent.assertEqual(len(result.feature_maps						)     ,       1						)
     self.parent.assertListEqual(list(result.feature_maps[0].shape						)     ,       [self.batch_size, self.hidden_sizes[-1], 1, 1]						)

     # verify channels
     self.parent.assertEqual(len(model.channels						)     ,       1						)
     self.parent.assertListEqual(model.channels     ,       [config.hidden_sizes[-1]]						)





 def 							_snake_case				(		self						)      ->							int:
     _lowerCAmelCase		     = self.prepare_config_and_inputs()
     _lowerCAmelCase     ,     _lowerCAmelCase     ,     _lowerCAmelCase		     = config_and_inputs
     _lowerCAmelCase		     = {"pixel_values": pixel_values}
     return config, inputs_dict







@require_torch
class 				lowerCAmelCase_						(						__magic_name__  ,__magic_name__  ,unittest.TestCase						):
 __lowerCamelCase  :							Union[str, Any]    					=   (
     (
         ResNetModel,
         ResNetForImageClassification,
         ResNetBackbone,
     )
     if is_torch_available()
     else ()
 )
 __lowerCamelCase  :							Optional[int]    					=   (
     {"feature-extraction": ResNetModel, "image-classification": ResNetForImageClassification}
     if is_torch_available()
     else {}
 )

 __lowerCamelCase  :							List[str]    					=   True
 __lowerCamelCase  :							str    					=   False
 __lowerCamelCase  :							Any    					=   False
 __lowerCamelCase  :							List[str]    					=   False
 __lowerCamelCase  :							int    					=   False




 def 							_snake_case				(		self						)      ->							str:
     _lowerCAmelCase		     = ResNetModelTester(self						)
     _lowerCAmelCase		     = ConfigTester(self     ,       config_class=_lowerCAmelCase     ,       has_text_modality=_lowerCAmelCase						)




 def 							_snake_case				(		self						)      ->							List[Any]:
     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 							_snake_case				(		self						)      ->							List[str]:
     return




 @unittest.skip(reason="ResNet does not use inputs_embeds"						)
 def 							_snake_case				(		self						)      ->							Any:
     pass




 @unittest.skip(reason="ResNet does not support input and output embeddings"						)
 def 							_snake_case				(		self						)      ->							Tuple:
     pass




 def 							_snake_case				(		self						)      ->							Tuple:
     _lowerCAmelCase     ,     _lowerCAmelCase		     = self.model_tester.prepare_config_and_inputs_for_common()

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

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




 def 							_snake_case				(		self						)      ->							str:
     _lowerCAmelCase		     = self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_lowerCAmelCase						)




 def 							_snake_case				(		self						)      ->							Union[str, Any]:
     _lowerCAmelCase		     = self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_backbone(*_lowerCAmelCase						)




 def 							_snake_case				(		self						)      ->							List[Any]:
     _lowerCAmelCase     ,     _lowerCAmelCase		     = self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
         _lowerCAmelCase		     = model_class(config=_lowerCAmelCase						)
         for name, module in model.named_modules():
             if isinstance(_lowerCAmelCase     ,       (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 							_snake_case				(		self						)      ->							List[Any]:
     def check_hidden_states_output(_lowerCAmelCase     ,       _lowerCAmelCase     ,       _lowerCAmelCase						):
         _lowerCAmelCase		     = model_class(_lowerCAmelCase						)
         model.to(_lowerCAmelCase						)
         model.eval()

         with torch.no_grad():
             _lowerCAmelCase		     = model(**self._prepare_for_class(_lowerCAmelCase     ,       _lowerCAmelCase						)						)

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

         _lowerCAmelCase		     = 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]     ,       )

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

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

             check_hidden_states_output(_lowerCAmelCase     ,       _lowerCAmelCase     ,       _lowerCAmelCase						)




 @unittest.skip(reason="ResNet does not use feedforward chunking"						)
 def 							_snake_case				(		self						)      ->							Dict:
     pass




 def 							_snake_case				(		self						)      ->							List[str]:
     _lowerCAmelCase		     = self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase						)





 @slow
 def 							_snake_case				(		self						)      ->							int:
     for model_name in RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         _lowerCAmelCase		     = ResNetModel.from_pretrained(_lowerCAmelCase						)
         self.assertIsNotNone(_lowerCAmelCase						)







def 		__a():



    '''simple docstring'''





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

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




 @cached_property
 def 							_snake_case				(		self						)      ->							Dict:
     return (
         AutoImageProcessor.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)
         if is_vision_available()
         else None
     )





 @slow
 def 							_snake_case				(		self						)      ->							str:
     _lowerCAmelCase		     = ResNetForImageClassification.from_pretrained(RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						).to(_lowerCAmelCase						)

     _lowerCAmelCase		     = self.default_image_processor
     _lowerCAmelCase		     = prepare_img()
     _lowerCAmelCase		     = image_processor(images=_lowerCAmelCase     ,       return_tensors="pt"						).to(_lowerCAmelCase						)

     # forward pass
     with torch.no_grad():
         _lowerCAmelCase		     = model(**_lowerCAmelCase						)

     # verify the logits
     _lowerCAmelCase		     = torch.Size((1, 1000)						)
     self.assertEqual(outputs.logits.shape     ,       _lowerCAmelCase						)

     _lowerCAmelCase		     = torch.tensor([-11.1069, -9.7877, -8.3777]						).to(_lowerCAmelCase						)

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







@require_torch
class 				lowerCAmelCase_						(						__magic_name__  ,unittest.TestCase						):
 __lowerCamelCase  :							Optional[int]    					=   (ResNetBackbone,) if is_torch_available() else ()
 __lowerCamelCase  :							Dict    					=   False
 __lowerCamelCase  :							str    					=   ResNetConfig




 def 							_snake_case				(		self						)      ->							Union[str, Any]:
     _lowerCAmelCase		     = ResNetModelTester(self						)









'''simple docstring'''


import math


def 		__a(SCREAMING_SNAKE_CASE_					:   int      ):



    '''simple docstring'''





    if number == 0:
        _lowerCAmelCase		     = "Zero"
        return words
    else:
        _lowerCAmelCase		     = math.logaa(SCREAMING_SNAKE_CASE_      )
        _lowerCAmelCase		     = digits + 1
        _lowerCAmelCase		     = {}
        _lowerCAmelCase		     = ""
        _lowerCAmelCase		     = "One"
        _lowerCAmelCase		     = "Two"
        _lowerCAmelCase		     = "Three"
        _lowerCAmelCase		     = "Four"
        _lowerCAmelCase		     = "Five"
        _lowerCAmelCase		     = "Six"
        _lowerCAmelCase		     = "Seven"
        _lowerCAmelCase		     = "Eight"
        _lowerCAmelCase		     = "Nine"

        _lowerCAmelCase		     = {}
        _lowerCAmelCase		     = ""
        _lowerCAmelCase		     = "Twenty"
        _lowerCAmelCase		     = "Thirty"
        _lowerCAmelCase		     = "Forty"
        _lowerCAmelCase		     = "Fifty"
        _lowerCAmelCase		     = "Sixty"
        _lowerCAmelCase		     = "Seventy"
        _lowerCAmelCase		     = "Eighty"
        _lowerCAmelCase		     = "Ninety"

        _lowerCAmelCase		     = {}
        _lowerCAmelCase		     = "Ten"
        _lowerCAmelCase		     = "Eleven"
        _lowerCAmelCase		     = "Twelve"
        _lowerCAmelCase		     = "Thirteen"
        _lowerCAmelCase		     = "Fourteen"
        _lowerCAmelCase		     = "Fifteen"
        _lowerCAmelCase		     = "Sixteen"
        _lowerCAmelCase		     = "Seventeen"
        _lowerCAmelCase		     = "Eighteen"
        _lowerCAmelCase		     = "Nineteen"

        _lowerCAmelCase		     = {}
        _lowerCAmelCase		     = "Hundred,"
        _lowerCAmelCase		     = "Thousand,"
        _lowerCAmelCase		     = "Lakh,"
        _lowerCAmelCase		     = "Crore,"

        _lowerCAmelCase		     = number
        _lowerCAmelCase		     = ""
        _lowerCAmelCase		     = 0
        _lowerCAmelCase		     = int(SCREAMING_SNAKE_CASE_      )
        while counter < digits:
            _lowerCAmelCase		     = temp_num % 10
            if counter % 2 == 0:
                _lowerCAmelCase		     = ""
                if counter in placevalue and current != 0:
                    _lowerCAmelCase		     = placevalue[counter]
                if counter == 2:
                    _lowerCAmelCase		     = singles[current] + addition + words
                elif counter == 0:
                    if ((temp_num % 100) // 10) == 1:
                        _lowerCAmelCase		     = teens[current] + addition + words
                        _lowerCAmelCase		     = temp_num // 10
                        counter += 1
                    else:
                        _lowerCAmelCase		     = singles[current] + addition + words

                else:
                    _lowerCAmelCase		     = doubles[current] + addition + words

            else:
                if counter == 1:
                    if current == 1:
                        _lowerCAmelCase		     = teens[number % 10] + words
                    else:
                        _lowerCAmelCase		     = ""
                        if counter in placevalue:
                            _lowerCAmelCase		     = placevalue[counter]
                        _lowerCAmelCase		     = doubles[current] + addition + words
                else:
                    _lowerCAmelCase		     = ""
                    if counter in placevalue:
                        if current == 0 and ((temp_num % 100) // 10) == 0:
                            _lowerCAmelCase		     = ""
                        else:
                            _lowerCAmelCase		     = placevalue[counter]
                    if ((temp_num % 100) // 10) == 1:
                        _lowerCAmelCase		     = teens[current] + addition + words
                        _lowerCAmelCase		     = temp_num // 10
                        counter += 1
                    else:
                        _lowerCAmelCase		     = singles[current] + addition + words
            counter += 1
            _lowerCAmelCase		     = temp_num // 10
    return words


if __name__ == "__main__":
       import doctest

       doctest.testmod()


