




'''simple docstring'''





import inspect
import unittest

from transformers import MobileNetVaConfig
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_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 transformers import MobileNetVaForImageClassification, MobileNetVaModel
   from transformers.models.mobilenet_va.modeling_mobilenet_va import MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
   from PIL import Image

   from transformers import MobileNetVaImageProcessor

class        _a    (						__lowerCAmelCase							):






     def     _lowercase     (			self   )							->      Optional[Any]:
          _snake_case							=				self.config_class(**self.inputs_dict   )
          self.parent.assertTrue(hasattr(_SCREAMING_SNAKE_CASE ,"tf_padding"   )   )
          self.parent.assertTrue(hasattr(_SCREAMING_SNAKE_CASE ,"depth_multiplier"   )   )







class        _a    :






     def __init__(			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE=13 ,_SCREAMING_SNAKE_CASE=3 ,_SCREAMING_SNAKE_CASE=32 ,_SCREAMING_SNAKE_CASE=0.2_5 ,_SCREAMING_SNAKE_CASE=8 ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=1_024 ,_SCREAMING_SNAKE_CASE=32 ,_SCREAMING_SNAKE_CASE="relu6" ,_SCREAMING_SNAKE_CASE=0.1 ,_SCREAMING_SNAKE_CASE=0.0_2 ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=True ,_SCREAMING_SNAKE_CASE=10 ,_SCREAMING_SNAKE_CASE=None ,)							->      List[Any]:
          _snake_case							=				parent
          _snake_case							=				batch_size
          _snake_case							=				num_channels
          _snake_case							=				image_size
          _snake_case							=				depth_multiplier
          _snake_case							=				min_depth
          _snake_case							=				tf_padding
          _snake_case							=				int(last_hidden_size * depth_multiplier   )
          _snake_case							=				output_stride
          _snake_case							=				hidden_act
          _snake_case							=				classifier_dropout_prob
          _snake_case							=				use_labels
          _snake_case							=				is_training
          _snake_case							=				num_labels
          _snake_case							=				initializer_range
          _snake_case							=				scope






     def     _lowercase     (			self   )							->      Optional[Any]:
          _snake_case							=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

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

          _snake_case							=				self.get_config()

          return config, pixel_values, labels, pixel_labels






     def     _lowercase     (			self   )							->      Union[str, Any]:
          return MobileNetVaConfig(
              num_channels=self.num_channels ,image_size=self.image_size ,depth_multiplier=self.depth_multiplier ,min_depth=self.min_depth ,tf_padding=self.tf_padding ,hidden_act=self.hidden_act ,classifier_dropout_prob=self.classifier_dropout_prob ,initializer_range=self.initializer_range ,)






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      int:
          _snake_case							=				MobileNetVaModel(config=_SCREAMING_SNAKE_CASE   )
          model.to(_SCREAMING_SNAKE_CASE   )
          model.eval()
          _snake_case							=				model(_SCREAMING_SNAKE_CASE   )
          self.parent.assertEqual(
              result.last_hidden_state.shape ,(
                  self.batch_size,
                  self.last_hidden_size,
                  self.image_size // self.output_stride,
                  self.image_size // self.output_stride,
              ) ,)






     def     _lowercase     (			self ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )							->      Tuple:
          _snake_case							=				self.num_labels
          _snake_case							=				MobileNetVaForImageClassification(_SCREAMING_SNAKE_CASE   )
          model.to(_SCREAMING_SNAKE_CASE   )
          model.eval()
          _snake_case							=				model(_SCREAMING_SNAKE_CASE ,labels=_SCREAMING_SNAKE_CASE   )
          self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_labels)   )






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







@require_torch
class        _a    (						__lowerCAmelCase , __lowerCAmelCase , unittest.TestCase							):
     SCREAMING_SNAKE_CASE_							:   Any       =						(MobileNetVaModel, MobileNetVaForImageClassification) if is_torch_available() else ()
     SCREAMING_SNAKE_CASE_							:   List[Any]       =						(
         {"""feature-extraction""": MobileNetVaModel, """image-classification""": MobileNetVaForImageClassification}
         if is_torch_available()
         else {}
     )

     SCREAMING_SNAKE_CASE_							:   str       =						False
     SCREAMING_SNAKE_CASE_							:   List[Any]       =						False
     SCREAMING_SNAKE_CASE_							:   Tuple       =						False
     SCREAMING_SNAKE_CASE_							:   Union[str, Any]       =						False






     def     _lowercase     (			self   )							->      Dict:
          _snake_case							=				MobileNetVaModelTester(self   )
          _snake_case							=				MobileNetVaConfigTester(self ,config_class=_SCREAMING_SNAKE_CASE ,has_text_modality=_SCREAMING_SNAKE_CASE   )






     def     _lowercase     (			self   )							->      List[Any]:
          self.config_tester.run_common_tests()






     @unittest.skip(reason="MobileNetV1 does not use inputs_embeds"   )
     def     _lowercase     (			self   )							->      Optional[int]:
          pass






     @unittest.skip(reason="MobileNetV1 does not support input and output embeddings"   )
     def     _lowercase     (			self   )							->      str:
          pass






     @unittest.skip(reason="MobileNetV1 does not output attentions"   )
     def     _lowercase     (			self   )							->      Dict:
          pass






     def     _lowercase     (			self   )							->      str:
          _snake_case							, _snake_case							=				self.model_tester.prepare_config_and_inputs_for_common()

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

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






     def     _lowercase     (			self   )							->      Optional[int]:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*_SCREAMING_SNAKE_CASE   )






     def     _lowercase     (			self   )							->      List[str]:
          def check_hidden_states_output(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   ):
               _snake_case							=				model_class(_SCREAMING_SNAKE_CASE   )
               model.to(_SCREAMING_SNAKE_CASE   )
               model.eval()

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

               _snake_case							=				outputs.hidden_states

               _snake_case							=				26
               self.assertEqual(len(_SCREAMING_SNAKE_CASE   ) ,_SCREAMING_SNAKE_CASE   )

          _snake_case							, _snake_case							=				self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
               _snake_case							=				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"]
               _snake_case							=				True

               check_hidden_states_output(_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE ,_SCREAMING_SNAKE_CASE   )






     def     _lowercase     (			self   )							->      List[Any]:
          _snake_case							=				self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*_SCREAMING_SNAKE_CASE   )






     @slow
     def     _lowercase     (			self   )							->      Optional[Any]:
          for model_name in MOBILENET_V1_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               _snake_case							=				MobileNetVaModel.from_pretrained(_SCREAMING_SNAKE_CASE   )
               self.assertIsNotNone(_SCREAMING_SNAKE_CASE   )







def      __a     (       )						->			Optional[int]:

     """simple docstring"""




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





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






     @cached_property
     def     _lowercase     (			self   )							->      Tuple:
          return (
              MobileNetVaImageProcessor.from_pretrained("google/mobilenet_v1_1.0_224"   ) if is_vision_available() else None
          )






     @slow
     def     _lowercase     (			self   )							->      Any:
          _snake_case							=				MobileNetVaForImageClassification.from_pretrained("google/mobilenet_v1_1.0_224"   ).to(_SCREAMING_SNAKE_CASE   )

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

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

          # verify the logits
          _snake_case							=				torch.Size((1, 1_001)   )
          self.assertEqual(outputs.logits.shape ,_SCREAMING_SNAKE_CASE   )

          _snake_case							=				torch.tensor([-4.1_7_3_9, -1.1_2_3_3, 3.1_2_0_5]   ).to(_SCREAMING_SNAKE_CASE   )

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








'''simple docstring'''





def      __a     (       _UpperCamelCase:   int   )						->			str:

     """simple docstring"""




     if number > 0:
          raise ValueError("input must be a negative integer"   )
     _snake_case							=				len(bin(_UpperCamelCase   )[3:]   )
     _snake_case							=				bin(abs(_UpperCamelCase   ) - (1 << binary_number_length)   )[3:]
     _snake_case							=				(
         (
             "1"
             + "0" * (binary_number_length - len(_UpperCamelCase   ))
             + twos_complement_number
         )
         if number < 0
         else "0"
     )
     return "0b" + twos_complement_number


if __name__ == "__main__":
   import doctest

   doctest.testmod()


