
"""simple docstring"""





import inspect
import math
import tempfile
import unittest

import numpy as np

from transformers import ViTMAEConfig
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 torch import nn

				from transformers import ViTMAEForPreTraining, ViTMAEModel
				from transformers.models.vit.modeling_vit import VIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
				from PIL import Image

				from transformers import ViTImageProcessor






class     _UpperCAmelCase:



		def __init__(					self				,		__a				,		__a=13				,		__a=30				,		__a=2				,		__a=3				,		__a=True				,		__a=True				,		__a=32				,		__a=5				,		__a=4				,		__a=37				,		__a="gelu"				,		__a=0.1				,		__a=0.1				,		__a=10				,		__a=0.02				,		__a=3				,		__a=0.6				,		__a=None				,		)       ->       Union[str, Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  parent
							_UpperCamelCase							 =  batch_size
							_UpperCamelCase							 =  image_size
							_UpperCamelCase							 =  patch_size
							_UpperCamelCase							 =  num_channels
							_UpperCamelCase							 =  is_training
							_UpperCamelCase							 =  use_labels
							_UpperCamelCase							 =  hidden_size
							_UpperCamelCase							 =  num_hidden_layers
							_UpperCamelCase							 =  num_attention_heads
							_UpperCamelCase							 =  intermediate_size
							_UpperCamelCase							 =  hidden_act
							_UpperCamelCase							 =  hidden_dropout_prob
							_UpperCamelCase							 =  attention_probs_dropout_prob
							_UpperCamelCase							 =  type_sequence_label_size
							_UpperCamelCase							 =  initializer_range
							_UpperCamelCase							 =  mask_ratio
							_UpperCamelCase							 =  scope

							# in ViTMAE, the expected sequence length = (num_patches + 1) * (1 - config.mask_ratio), rounded above
							# (we add 1 for the [CLS] token)
							_UpperCamelCase							 =  (image_size // patch_size) ** 2
							_UpperCamelCase							 =  int(math.ceil((1 - mask_ratio) * (num_patches + 1)))



		def 						UpperCAmelCase							(					self)       ->       Tuple:






							'''simple docstring'''
							_UpperCamelCase							 =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

							_UpperCamelCase							 =  self.get_config()

							return config, pixel_values, labels



		def 						UpperCAmelCase							(					self)       ->       Tuple:






							'''simple docstring'''
							return ViTMAEConfig(
							    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=__a				,		initializer_range=self.initializer_range				,		mask_ratio=self.mask_ratio				,		)



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a)       ->       List[str]:






							'''simple docstring'''
							_UpperCamelCase							 =  ViTMAEModel(config=__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase							 =  model(__a)
							self.parent.assertEqual(result.last_hidden_state.shape				,		(self.batch_size, self.seq_length, self.hidden_size))



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a)       ->       int:






							'''simple docstring'''
							_UpperCamelCase							 =  ViTMAEForPreTraining(__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase							 =  model(__a)
							_UpperCamelCase							 =  (self.image_size // self.patch_size) ** 2
							_UpperCamelCase							 =  self.patch_size**2 * self.num_channels
							self.parent.assertEqual(result.logits.shape				,		(self.batch_size, num_patches, expected_num_channels))

							# test greyscale images
							_UpperCamelCase							 =  1
							_UpperCamelCase							 =  ViTMAEForPreTraining(__a)
							model.to(__a)
							model.eval()
							_UpperCamelCase							 =  floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
							_UpperCamelCase							 =  model(__a)
							_UpperCamelCase							 =  self.patch_size**2
							self.parent.assertEqual(result.logits.shape				,		(self.batch_size, num_patches, expected_num_channels))




		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							_UpperCamelCase							 =  self.prepare_config_and_inputs()
							_UpperCamelCase							 =  config_and_inputs
							_UpperCamelCase							 =  {'''pixel_values''': pixel_values}
							return config, inputs_dict






@require_torch
class     _UpperCAmelCase(    __lowerCamelCase      ,     __lowerCamelCase      ,     unittest.TestCase	):
		lowercase__						=      (ViTMAEModel, ViTMAEForPreTraining) if is_torch_available() else ()
		lowercase__						=      {"feature-extraction": ViTMAEModel} if is_torch_available() else {}

		lowercase__						=      False
		lowercase__						=      False
		lowercase__						=      False
		lowercase__						=      False



		def 						UpperCAmelCase							(					self)       ->       Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  ViTMAEModelTester(self)
							_UpperCamelCase							 =  ConfigTester(self				,		config_class=__a				,		has_text_modality=__a				,		hidden_size=37)



		def 						UpperCAmelCase							(					self)       ->       Tuple:






							'''simple docstring'''
							self.config_tester.run_common_tests()



		@unittest.skip(reason='''ViTMAE does not use inputs_embeds''')
		def 						UpperCAmelCase							(					self)       ->       Any:






							'''simple docstring'''
							pass



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												_UpperCamelCase							 =  model_class(__a)
												self.assertIsInstance(model.get_input_embeddings()				,		(nn.Module))
												_UpperCamelCase							 =  model.get_output_embeddings()
												self.assertTrue(x is None or isinstance(__a				,		nn.Linear))



		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs_for_common()

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

												_UpperCamelCase							 =  ['''pixel_values''']
												self.assertListEqual(arg_names[:1]				,		__a)



		def 						UpperCAmelCase							(					self)       ->       Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__a)



		def 						UpperCAmelCase							(					self)       ->       Optional[int]:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_pretraining(*__a)



		def 						UpperCAmelCase							(					self				,		__a				,		__a				,		__a)       ->       Any:






							'''simple docstring'''
							np.random.seed(2)

							_UpperCamelCase							 =  int((pt_model.config.image_size // pt_model.config.patch_size) ** 2)
							_UpperCamelCase							 =  np.random.uniform(size=(self.model_tester.batch_size, num_patches))
							_UpperCamelCase							 =  torch.from_numpy(__a)

							# Add `noise` argument.
							# PT inputs will be prepared in `super().check_pt_tf_models()` with this added `noise` argument
							_UpperCamelCase							 =  pt_noise

							super().check_pt_tf_models(__a				,		__a				,		__a)



		def 						UpperCAmelCase							(					self)       ->       Optional[Any]:






							'''simple docstring'''
							_UpperCamelCase							 =  self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
												_UpperCamelCase							 =  model_class(__a)
												model.to(__a)
												model.eval()
												# make random mask reproducible
												torch.manual_seed(2)
												with torch.no_grad():
																	_UpperCamelCase							 =  model(**self._prepare_for_class(__a				,		__a))

												_UpperCamelCase							 =  outputs[0].cpu().numpy()
												_UpperCamelCase							 =  0

												with tempfile.TemporaryDirectory() as tmpdirname:
																	model.save_pretrained(__a)
																	_UpperCamelCase							 =  model_class.from_pretrained(__a)
																	model.to(__a)
																	# make random mask reproducible
																	torch.manual_seed(2)
																	with torch.no_grad():
																						_UpperCamelCase							 =  model(**self._prepare_for_class(__a				,		__a))

																	# Make sure we don't have nans
																	_UpperCamelCase							 =  after_outputs[0].cpu().numpy()
																	_UpperCamelCase							 =  0
																	_UpperCamelCase							 =  np.amax(np.abs(out_a - out_a))
																	self.assertLessEqual(__a				,		1e-5)



		@unittest.skip(
		    reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.''')
		def 						UpperCAmelCase							(					self)       ->       Optional[int]:






							'''simple docstring'''
							pass



		@unittest.skip(
		    reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.''')
		def 						UpperCAmelCase							(					self)       ->       int:






							'''simple docstring'''
							pass



		@unittest.skip(
		    reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load
    to get deterministic results.''')
		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							pass



		@unittest.skip(reason='''ViTMAE returns a random mask + ids_restore in each forward pass. See test_save_load''')
		def 						UpperCAmelCase							(					self)       ->       int:






							'''simple docstring'''
							pass



		@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''')
		def 						UpperCAmelCase							(					self)       ->       str:






							'''simple docstring'''
							pass




		@slow
		def 						UpperCAmelCase							(					self)       ->       Optional[int]:






							'''simple docstring'''
							for model_name in VIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												_UpperCamelCase							 =  ViTMAEModel.from_pretrained(__a)
												self.assertIsNotNone(__a)





def       lowerCamelCase__		(			)							->		Optional[int]:


					"""simple docstring"""





					_UpperCamelCase							 =  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
					return image






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



		@cached_property
		def 						UpperCAmelCase							(					self)       ->       Tuple:






							'''simple docstring'''
							return ViTImageProcessor.from_pretrained('''facebook/vit-mae-base''') if is_vision_available() else None




		@slow
		def 						UpperCAmelCase							(					self)       ->       Optional[Any]:






							'''simple docstring'''
							np.random.seed(2)

							_UpperCamelCase							 =  ViTMAEForPreTraining.from_pretrained('''facebook/vit-mae-base''').to(__a)

							_UpperCamelCase							 =  self.default_image_processor
							_UpperCamelCase							 =  prepare_img()
							_UpperCamelCase							 =  image_processor(images=__a				,		return_tensors='''pt''').to(__a)

							# prepare a noise vector that will be also used for testing the TF model
							# (this way we can ensure that the PT and TF models operate on the same inputs)
							_UpperCamelCase							 =  ViTMAEConfig()
							_UpperCamelCase							 =  int((vit_mae_config.image_size // vit_mae_config.patch_size) ** 2)
							_UpperCamelCase							 =  np.random.uniform(size=(1, num_patches))

							# forward pass
							with torch.no_grad():
												_UpperCamelCase							 =  model(**__a				,		noise=torch.from_numpy(__a).to(device=__a))

							# verify the logits
							_UpperCamelCase							 =  torch.Size((1, 1_96, 7_68))
							self.assertEqual(outputs.logits.shape				,		__a)

							_UpperCamelCase							 =  torch.tensor(
							    [[-0.0548, -1.7023, -0.9325], [0.3721, -0.5670, -0.2233], [0.8235, -1.3878, -0.3524]])

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













from __future__ import annotations




def 		lowerCAmelCase_    (  __UpperCAmelCase:			list[int]		,   __UpperCAmelCase:			int      )      ->	list[int]:
    UpperCamelCase__							:				Optional[int]          =      0
    UpperCamelCase__							:				Tuple          =      len(__UpperCAmelCase      ) - 1

    while i < j:
        if nums[i] + nums[j] == target:
            return [i, j]
        elif nums[i] + nums[j] < target:
            UpperCamelCase__							:				Tuple          =      i + 1
        else:
            UpperCamelCase__							:				str          =      j - 1

    return []


if __name__ == "__main__":
  import doctest

  doctest.testmod()
  print(F'''{two_pointer([2, 7, 11, 15], 9) = }''')

