





'''simple docstring'''



from __future__ import annotations

import inspect
import unittest

from transformers import ViTConfig
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 TFViTForImageClassification, TFViTModel


if is_vision_available():
 from PIL import Image

 from transformers import ViTImageProcessor


class       __SCREAMING_SNAKE_CASE	:



     '''simple docstring'''






     def __init__(					self						,   lowerCamelCase						,   lowerCamelCase=13						,   lowerCamelCase=30						,   lowerCamelCase=2						,   lowerCamelCase=3						,   lowerCamelCase=True						,   lowerCamelCase=True						,   lowerCamelCase=32						,   lowerCamelCase=2						,   lowerCamelCase=4						,   lowerCamelCase=37						,   lowerCamelCase="gelu"						,   lowerCamelCase=0.1						,   lowerCamelCase=0.1						,   lowerCamelCase=10						,   lowerCamelCase=0.02						,   lowerCamelCase=3						,   lowerCamelCase=None						,   ):
       _snake_case     		=				parent
       _snake_case     		=				batch_size
       _snake_case     		=				image_size
       _snake_case     		=				patch_size
       _snake_case     		=				num_channels
       _snake_case     		=				is_training
       _snake_case     		=				use_labels
       _snake_case     		=				hidden_size
       _snake_case     		=				num_hidden_layers
       _snake_case     		=				num_attention_heads
       _snake_case     		=				intermediate_size
       _snake_case     		=				hidden_act
       _snake_case     		=				hidden_dropout_prob
       _snake_case     		=				attention_probs_dropout_prob
       _snake_case     		=				type_sequence_label_size
       _snake_case     		=				initializer_range
       _snake_case     		=				scope

       # in ViT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
       _snake_case     		=				(image_size // patch_size) ** 2
       _snake_case     		=				num_patches + 1

     def 	UpperCamelCase(					self	):
       _snake_case     		=				floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

       _snake_case     		=				self.get_config()

       return config, pixel_values, labels

     def 	UpperCamelCase(					self	):
       return ViTConfig(
           image_size=self.image_size						,   patch_size=self.patch_size						,   num_channels=self.num_channels						,   hidden_size=self.hidden_size						,   num_hidden_layers=self.num_hidden_layers						,   num_attention_heads=self.num_attention_heads						,   intermediate_size=self.intermediate_size						,   hidden_act=self.hidden_act						,   hidden_dropout_prob=self.hidden_dropout_prob						,   attention_probs_dropout_prob=self.attention_probs_dropout_prob						,   is_decoder=lowerCamelCase						,   initializer_range=self.initializer_range						,   )

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase	):
       _snake_case     		=				TFViTModel(config=lowerCamelCase	)
       _snake_case     		=				model(lowerCamelCase						,   training=lowerCamelCase	)
       self.parent.assertEqual(result.last_hidden_state.shape						,   (self.batch_size, self.seq_length, self.hidden_size)	)

       # Test with an image with different size than the one specified in config.
       _snake_case     		=				self.image_size // 2
       _snake_case     		=				pixel_values[:, :, :image_size, :image_size]
       _snake_case     		=				model(lowerCamelCase						,   interpolate_pos_encoding=lowerCamelCase						,   training=lowerCamelCase	)
       _snake_case     		=				(image_size // self.patch_size) ** 2 + 1
       self.parent.assertEqual(result.last_hidden_state.shape						,   (self.batch_size, seq_length, self.hidden_size)	)

     def 	UpperCamelCase(					self						,   lowerCamelCase						,   lowerCamelCase						,   lowerCamelCase	):
       _snake_case     		=				self.type_sequence_label_size
       _snake_case     		=				TFViTForImageClassification(lowerCamelCase	)
       _snake_case     		=				model(lowerCamelCase						,   labels=lowerCamelCase						,   training=lowerCamelCase	)
       self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.type_sequence_label_size)	)

       # Test with an image with different size than the one specified in config.
       _snake_case     		=				self.image_size // 2
       _snake_case     		=				pixel_values[:, :, :image_size, :image_size]
       _snake_case     		=				model(lowerCamelCase						,   interpolate_pos_encoding=lowerCamelCase						,   training=lowerCamelCase	)
       self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.type_sequence_label_size)	)

       # test greyscale images
       _snake_case     		=				1
       _snake_case     		=				TFViTForImageClassification(lowerCamelCase	)
       _snake_case     		=				floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
       _snake_case     		=				model(lowerCamelCase	)
       self.parent.assertEqual(result.logits.shape						,   (self.batch_size, self.type_sequence_label_size)	)






     def 	UpperCamelCase(					self	):
       _snake_case     		=				self.prepare_config_and_inputs()
       _snake_case		,		_snake_case		,		_snake_case     		=				config_and_inputs
       _snake_case     		=				{"pixel_values": pixel_values}
       return config, inputs_dict







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



     '''simple docstring'''






     UpperCAmelCase__       :						Optional[int]      =   (TFViTModel, TFViTForImageClassification) if is_tf_available() else ()
     UpperCAmelCase__       :						int      =   (
         {'''feature-extraction''': TFViTModel, '''image-classification''': TFViTForImageClassification}
         if is_tf_available()
         else {}
     )

     UpperCAmelCase__       :						Union[str, Any]      =   False
     UpperCAmelCase__       :						str      =   False
     UpperCAmelCase__       :						Optional[Any]      =   False

     def 	UpperCamelCase(					self	):
       _snake_case     		=				TFViTModelTester(self	)
       _snake_case     		=				ConfigTester(self						,   config_class=lowerCamelCase						,   has_text_modality=lowerCamelCase						,   hidden_size=37	)

     def 	UpperCamelCase(					self	):
       self.config_tester.run_common_tests()

     @unittest.skip(reason="ViT does not use inputs_embeds"	)
     def 	UpperCamelCase(					self	):
       pass

     @unittest.skip(reason="ViT does not use inputs_embeds"	)
     def 	UpperCamelCase(					self	):
       pass

     def 	UpperCamelCase(					self	):
       _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(lowerCamelCase	)
         self.assertIsInstance(model.get_input_embeddings()						,   (tf.keras.layers.Layer)	)
         _snake_case     		=				model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(lowerCamelCase						,   tf.keras.layers.Layer	)	)

     def 	UpperCamelCase(					self	):
       _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(lowerCamelCase	)
         _snake_case     		=				inspect.signature(model.call	)
         # 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]						,   lowerCamelCase	)

     def 	UpperCamelCase(					self	):
       _snake_case     		=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*lowerCamelCase	)

     def 	UpperCamelCase(					self	):
       _snake_case     		=				self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*lowerCamelCase	)






     @slow
     def 	UpperCamelCase(					self	):
       _snake_case     		=				TFViTModel.from_pretrained("google/vit-base-patch16-224"	)
       self.assertIsNotNone(lowerCamelCase	)







def 				snake_case_      (		):







  '''simple docstring'''



  _snake_case     		=				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 	UpperCamelCase(					self	):
       return ViTImageProcessor.from_pretrained("google/vit-base-patch16-224"	) if is_vision_available() else None






     @slow
     def 	UpperCamelCase(					self	):
       _snake_case     		=				TFViTForImageClassification.from_pretrained("google/vit-base-patch16-224"	)

       _snake_case     		=				self.default_image_processor
       _snake_case     		=				prepare_img()
       _snake_case     		=				image_processor(images=lowerCamelCase						,   return_tensors="tf"	)

       # forward pass
       _snake_case     		=				model(**lowerCamelCase	)

       # verify the logits
       _snake_case     		=				tf.TensorShape((1, 1_000)	)
       self.assertEqual(outputs.logits.shape						,   lowerCamelCase	)

       _snake_case     		=				tf.constant([-0.2744, 0.8215, -0.0836]	)

       tf.debugging.assert_near(outputs.logits[0, :3]						,   lowerCamelCase						,   atol=1e-4	)









'''simple docstring'''



from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


__magic_name__   :						Any    =			logging.get_logger(__name__)

__magic_name__   :						Dict    =			{
    """google/bit-50""": """https://huggingface.co/google/bit-50/resolve/main/config.json""",
}


class       __SCREAMING_SNAKE_CASE	(						__UpperCamelCase					,    __UpperCamelCase			):



     '''simple docstring'''






     UpperCAmelCase__       :						List[str]      =   '''bit'''
     UpperCAmelCase__       :						Union[str, Any]      =   ['''preactivation''', '''bottleneck''']
     UpperCAmelCase__       :						int      =   ['''SAME''', '''VALID''']

     def __init__(					self						,   lowerCamelCase=3						,   lowerCamelCase=64						,   lowerCamelCase=[256, 512, 1_024, 2_048]						,   lowerCamelCase=[3, 4, 6, 3]						,   lowerCamelCase="preactivation"						,   lowerCamelCase="relu"						,   lowerCamelCase=None						,   lowerCamelCase=32						,   lowerCamelCase=0.0						,   lowerCamelCase=False						,   lowerCamelCase=32						,   lowerCamelCase=1						,   lowerCamelCase=None						,   lowerCamelCase=None						,   **lowerCamelCase						,   ):
       super().__init__(**lowerCamelCase	)
       if layer_type not in self.layer_types:
         raise ValueError(F'''layer_type={layer_type} is not one of {",".join(self.layer_types	)}'''	)
       if global_padding is not None:
         if global_padding.upper() in self.supported_padding:
           _snake_case     		=				global_padding.upper()
         else:
           raise ValueError(F'''Padding strategy {global_padding} not supported'''	)
       _snake_case     		=				num_channels
       _snake_case     		=				embedding_size
       _snake_case     		=				hidden_sizes
       _snake_case     		=				depths
       _snake_case     		=				layer_type
       _snake_case     		=				hidden_act
       _snake_case     		=				global_padding
       _snake_case     		=				num_groups
       _snake_case     		=				drop_path_rate
       _snake_case     		=				embedding_dynamic_padding
       _snake_case     		=				output_stride
       _snake_case     		=				width_factor

       _snake_case     		=				["stem"] + [F'''stage{idx}''' for idx in range(1						,   len(lowerCamelCase	) + 1	)]
       _snake_case		,		_snake_case     		=				get_aligned_output_features_output_indices(
           out_features=lowerCamelCase						,   out_indices=lowerCamelCase						,   stage_names=self.stage_names	)


