
import inspect
import unittest

from transformers import ViTHybridConfig
from transformers.testing_utils import require_accelerate, 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, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch
			from torch import nn

			from transformers import ViTHybridForImageClassification, ViTHybridImageProcessor, ViTHybridModel
			from transformers.models.vit_hybrid.modeling_vit_hybrid import VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
			from PIL import Image




class        SCREAMING_SNAKE_CASE__					:





	'''simple docstring'''



	def __init__(  self     :   List[Any]      ,  lowercase     :   Tuple      ,  lowercase     :   Dict=13      ,  lowercase     :   List[str]=64      ,  lowercase     :   int=2      ,  lowercase     :   Any=3      ,  lowercase     :   List[Any]=True      ,  lowercase     :   Any=True      ,  lowercase     :   Optional[int]=32      ,  lowercase     :   Tuple=5      ,  lowercase     :   int=4      ,  lowercase     :   str=37      ,  lowercase     :   Dict="gelu"      ,  lowercase     :   Union[str, Any]=0.1      ,  lowercase     :   Union[str, Any]=0.1      ,  lowercase     :   List[Any]=10      ,  lowercase     :   List[Any]=0.02      ,  lowercase     :   Optional[Any]=[1, 16, 4, 4]      ,  lowercase     :   Tuple=None      ,  ):


				'''simple docstring'''


				_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
				_snake_case          =      backbone_featmap_shape

				# in ViT hybrid, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
				# the number of patches is based on the feature map of the backbone, which by default uses an output stride
				# of 32, which means that the feature map has a spatial resolution of 1/32 of the input image size
				_snake_case          =      (self.image_size // 32) ** 2
				_snake_case          =      num_patches + 1



	def 			A							(  self     :   Tuple     ):


				'''simple docstring'''


				_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 			A							(  self     :   List[Any]     ):


				'''simple docstring'''


				_snake_case          =      {
				    'global_padding': 'same',
				    'layer_type': 'bottleneck',
				    'depths': [3, 4, 9],
				    'out_features': ['stage1', 'stage2', 'stage3'],
				    'embedding_dynamic_padding': True,
				    'hidden_sizes': [4, 8, 16, 32],
				    'num_groups': 2,
				}

				return ViTHybridConfig(
				    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=lowercase      ,  initializer_range=self.initializer_range      ,  backbone_featmap_shape=self.backbone_featmap_shape      ,  backbone_config=lowercase      ,  )



	def 			A							(  self     :   Any      ,  lowercase     :   List[str]      ,  lowercase     :   Any      ,  lowercase     :   Any     ):


				'''simple docstring'''


				_snake_case          =      ViTHybridModel(config=lowercase     )
				model.to(lowercase     )
				model.eval()
				_snake_case          =      model(lowercase     )
				self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size)     )



	def 			A							(  self     :   Optional[int]      ,  lowercase     :   Union[str, Any]      ,  lowercase     :   str      ,  lowercase     :   Any     ):


				'''simple docstring'''


				_snake_case          =      self.type_sequence_label_size
				_snake_case          =      ViTHybridForImageClassification(lowercase     )
				model.to(lowercase     )
				model.eval()
				_snake_case          =      model(lowercase      ,  labels=lowercase     )
				self.parent.assertEqual(result.logits.shape      ,  (self.batch_size, self.type_sequence_label_size)     )





	def 			A							(  self     :   str     ):


				'''simple docstring'''


				_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_torch
class        SCREAMING_SNAKE_CASE__					(     UpperCAmelCase							,UpperCAmelCase							,unittest.TestCase ):





	'''simple docstring'''



	_UpperCAmelCase	:		Optional[Any]          = (ViTHybridModel, ViTHybridForImageClassification) if is_torch_available() else ()
	_UpperCAmelCase	:		str          = (
	    {"feature-extraction": ViTHybridModel, "image-classification": ViTHybridForImageClassification}
	    if is_torch_available()
	    else {}
	)
	_UpperCAmelCase	:		int          = False
	_UpperCAmelCase	:		str          = False
	_UpperCAmelCase	:		Optional[int]          = False



	def 			A							(  self     :   List[Any]     ):


				'''simple docstring'''


				_snake_case          =      ViTHybridModelTester(self     )
				_snake_case          =      ConfigTester(self      ,  config_class=lowercase      ,  has_text_modality=lowercase      ,  hidden_size=37     )



	def 			A							(  self     :   Optional[Any]     ):


				'''simple docstring'''


				self.config_tester.run_common_tests()



	@unittest.skip(reason='ViT does not use inputs_embeds'     )
	def 			A							(  self     :   Optional[int]     ):


				'''simple docstring'''


				pass



	def 			A							(  self     :   Any     ):


				'''simple docstring'''


				_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(lowercase     )
							self.assertIsInstance(model.get_input_embeddings()      ,  (nn.Module)     )
							_snake_case          =      model.get_output_embeddings()
							self.assertTrue(x is None or isinstance(lowercase      ,  nn.Linear     )     )



	def 			A							(  self     :   Optional[Any]     ):


				'''simple docstring'''


				_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(lowercase     )
							_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]      ,  lowercase     )



	def 			A							(  self     :   Tuple     ):


				'''simple docstring'''


				_snake_case          =      self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowercase     )



	def 			A							(  self     :   str     ):


				'''simple docstring'''


				_snake_case          =      self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*lowercase     )



	def 			A							(  self     :   List[str]     ):


				'''simple docstring'''


				_snake_case     , _snake_case          =      self.model_tester.prepare_config_and_inputs_for_common()

				_snake_case          =      _config_zero_init(lowercase     )
				for model_class in self.all_model_classes:
							_snake_case          =      model_class(config=lowercase     )
							# Skip the check for the backbone
							for name, module in model.named_modules():
										if module.__class__.__name__ == "ViTHybridPatchEmbeddings":
													_snake_case          =      [f'''{name}.{key}''' for key in module.state_dict().keys()]
													break

							for name, param in model.named_parameters():
										if param.requires_grad:
													if name in backbone_params:
																continue
													self.assertIn(
													    ((param.data.mean() * 1E9).round() / 1E9).item()      ,  [0.0, 1.0]      ,  msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''      ,  )





	@slow
	def 			A							(  self     :   Optional[int]     ):


				'''simple docstring'''


				for model_name in VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							_snake_case          =      ViTHybridModel.from_pretrained(lowercase     )
							self.assertIsNotNone(lowercase     )






def 	a_		(	)			->  int:
			_snake_case          =      Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
			return image




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





	'''simple docstring'''



	@cached_property
	def 			A							(  self     :   Any     ):


				'''simple docstring'''


				return (
				    ViTHybridImageProcessor.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]     )
				    if is_vision_available()
				    else None
				)



	@slow
	def 			A							(  self     :   Tuple     ):


				'''simple docstring'''


				_snake_case          =      ViTHybridForImageClassification.from_pretrained(VIT_HYBRID_PRETRAINED_MODEL_ARCHIVE_LIST[0]     ).to(
				    lowercase     )

				_snake_case          =      self.default_image_processor
				_snake_case          =      prepare_img()
				_snake_case          =      image_processor(images=lowercase      ,  return_tensors='pt'     ).to(lowercase     )

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

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

				_snake_case          =      torch.tensor([-1.9090, -0.4993, -0.2389]     ).to(lowercase     )

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





	@slow
	@require_accelerate
	def 			A							(  self     :   Dict     ):


				'''simple docstring'''


				_snake_case          =      ViTHybridImageProcessor.from_pretrained('google/vit-hybrid-base-bit-384'     )
				_snake_case          =      ViTHybridForImageClassification.from_pretrained('google/vit-hybrid-base-bit-384'      ,  device_map='auto'     )

				_snake_case          =      prepare_img()

				_snake_case          =      image_processor(images=lowercase      ,  return_tensors='pt'     )
				_snake_case          =      model(**lowercase     )
				_snake_case          =      outputs.logits
				# model predicts one of the 1000 ImageNet classes
				_snake_case          =      logits.argmax(-1     ).item()

				self.assertTrue(model.config.idalabel[predicted_class_idx]      ,  'tabby, tabby cat'     )

def 	a_		(	__lowercase       :     int = 50_000_000			)			->  int:
			_snake_case          =      set()
			_snake_case          =      int((limit - 24) ** (1 / 2)			)

			_snake_case          =      set(range(3	, prime_square_limit + 1	, 2			)			)
			primes.add(2			)
			for p in range(3	, prime_square_limit + 1	, 2			):
						if p not in primes:
									continue
						primes.difference_update(set(range(p * p	, prime_square_limit + 1	, __lowercase			)			)			)

			for primea in primes:
						_snake_case          =      primea * primea
						for primea in primes:
									_snake_case          =      primea * primea * primea
									if square + cube >= limit - 16:
												break
									for primea in primes:
												_snake_case          =      primea * primea * primea * primea
												_snake_case          =      square + cube + tetr
												if total >= limit:
															break
												ret.add(__lowercase			)

			return len(__lowercase			)


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