


import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, 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 (
		    MODEL_MAPPING,
		    BeitForImageClassification,
		    BeitForMaskedImageModeling,
		    BeitForSemanticSegmentation,
		    BeitModel,
		)
		from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		import PIL
		from PIL import Image

		from transformers import BeitImageProcessor



class 						_UpperCAmelCase      :






		def __init__(						self				:     Union[str, Any]   ,  UpperCAmelCase				:     Optional[Any]   ,  UpperCAmelCase				:     int=1_00   ,  UpperCAmelCase				:     List[str]=13   ,  UpperCAmelCase				:     Optional[Any]=30   ,  UpperCAmelCase				:     List[str]=2   ,  UpperCAmelCase				:     Tuple=3   ,  UpperCAmelCase				:     Optional[int]=True   ,  UpperCAmelCase				:     int=True   ,  UpperCAmelCase				:     Dict=32   ,  UpperCAmelCase				:     Optional[Any]=4   ,  UpperCAmelCase				:     List[str]=4   ,  UpperCAmelCase				:     Dict=37   ,  UpperCAmelCase				:     int="gelu"   ,  UpperCAmelCase				:     List[Any]=0.1   ,  UpperCAmelCase				:     int=0.1   ,  UpperCAmelCase				:     Any=10   ,  UpperCAmelCase				:     Union[str, Any]=0.02   ,  UpperCAmelCase				:     str=3   ,  UpperCAmelCase				:     int=None   ,  UpperCAmelCase				:     Optional[Any]=[0, 1, 2, 3]   ,  ):
				SCREAMING_SNAKE_CASE_				:Any				     =						parent
				SCREAMING_SNAKE_CASE_				:Any				     =						1_00
				SCREAMING_SNAKE_CASE_				:int				     =						batch_size
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						image_size
				SCREAMING_SNAKE_CASE_				:Any				     =						patch_size
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						num_channels
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						is_training
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						use_labels
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						hidden_size
				SCREAMING_SNAKE_CASE_				:int				     =						num_hidden_layers
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						num_attention_heads
				SCREAMING_SNAKE_CASE_				:int				     =						intermediate_size
				SCREAMING_SNAKE_CASE_				:Dict				     =						hidden_act
				SCREAMING_SNAKE_CASE_				:List[str]				     =						hidden_dropout_prob
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						attention_probs_dropout_prob
				SCREAMING_SNAKE_CASE_				:Dict				     =						type_sequence_label_size
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						initializer_range
				SCREAMING_SNAKE_CASE_				:List[str]				     =						scope
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						out_indices
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						num_labels

				# in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						(image_size // patch_size) ** 2
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						num_patches + 1






		def _snake_case		(						self				:     Tuple):
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

				SCREAMING_SNAKE_CASE_				:Any				     =						None
				SCREAMING_SNAKE_CASE_				:Dict				     =						None
				if self.use_labels:
						SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						ids_tensor([self.batch_size]   ,  self.type_sequence_label_size)
						SCREAMING_SNAKE_CASE_				:Dict				     =						ids_tensor([self.batch_size, self.image_size, self.image_size]   ,  self.num_labels)

				SCREAMING_SNAKE_CASE_				:List[str]				     =						self.get_config()

				return config, pixel_values, labels, pixel_labels






		def _snake_case		(						self				:     Tuple):
				return BeitConfig(
				    vocab_size=self.vocab_size   ,  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   ,  out_indices=self.out_indices   ,  )






		def _snake_case		(						self				:     str   ,  UpperCAmelCase				:     Optional[int]   ,  UpperCAmelCase				:     Optional[Any]   ,  UpperCAmelCase				:     int   ,  UpperCAmelCase				:     Optional[int]):
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						BeitModel(config=lowerCamelCase__)
				model.to(lowerCamelCase__)
				model.eval()
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						model(lowerCamelCase__)
				self.parent.assertEqual(result.last_hidden_state.shape   ,  (self.batch_size, self.seq_length, self.hidden_size))






		def _snake_case		(						self				:     Union[str, Any]   ,  UpperCAmelCase				:     Optional[Any]   ,  UpperCAmelCase				:     Union[str, Any]   ,  UpperCAmelCase				:     Union[str, Any]   ,  UpperCAmelCase				:     Dict):
				SCREAMING_SNAKE_CASE_				:List[str]				     =						BeitForMaskedImageModeling(config=lowerCamelCase__)
				model.to(lowerCamelCase__)
				model.eval()
				SCREAMING_SNAKE_CASE_				:List[str]				     =						model(lowerCamelCase__)
				self.parent.assertEqual(result.logits.shape   ,  (self.batch_size, self.seq_length - 1, self.vocab_size))






		def _snake_case		(						self				:     Optional[int]   ,  UpperCAmelCase				:     List[Any]   ,  UpperCAmelCase				:     Dict   ,  UpperCAmelCase				:     List[Any]   ,  UpperCAmelCase				:     int):
				SCREAMING_SNAKE_CASE_				:str				     =						self.type_sequence_label_size
				SCREAMING_SNAKE_CASE_				:Tuple				     =						BeitForImageClassification(lowerCamelCase__)
				model.to(lowerCamelCase__)
				model.eval()
				SCREAMING_SNAKE_CASE_				:Any				     =						model(lowerCamelCase__   ,  labels=lowerCamelCase__)
				self.parent.assertEqual(result.logits.shape   ,  (self.batch_size, self.type_sequence_label_size))

				# test greyscale images
				SCREAMING_SNAKE_CASE_				:Tuple				     =						1
				SCREAMING_SNAKE_CASE_				:Dict				     =						BeitForImageClassification(lowerCamelCase__)
				model.to(lowerCamelCase__)
				model.eval()

				SCREAMING_SNAKE_CASE_				:Tuple				     =						floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						model(lowerCamelCase__   ,  labels=lowerCamelCase__)
				self.parent.assertEqual(result.logits.shape   ,  (self.batch_size, self.type_sequence_label_size))






		def _snake_case		(						self				:     Optional[int]   ,  UpperCAmelCase				:     List[str]   ,  UpperCAmelCase				:     Any   ,  UpperCAmelCase				:     Union[str, Any]   ,  UpperCAmelCase				:     Optional[int]):
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						self.num_labels
				SCREAMING_SNAKE_CASE_				:Any				     =						BeitForSemanticSegmentation(lowerCamelCase__)
				model.to(lowerCamelCase__)
				model.eval()
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						model(lowerCamelCase__)
				self.parent.assertEqual(
				    result.logits.shape   ,  (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2))
				SCREAMING_SNAKE_CASE_				:List[str]				     =						model(lowerCamelCase__   ,  labels=lowerCamelCase__)
				self.parent.assertEqual(
				    result.logits.shape   ,  (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2))







		def _snake_case		(						self				:     List[str]):
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						self.prepare_config_and_inputs()
				SCREAMING_SNAKE_CASE_				:Any				     =						config_and_inputs
				SCREAMING_SNAKE_CASE_				:int				     =						{'pixel_values': pixel_values}
				return config, inputs_dict




@require_torch
class 						_UpperCAmelCase      (     lowercase		,		lowercase		,		unittest.TestCase							):
		lowerCamelCase_	:			Optional[Any]       			=  (
		    (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
		    if is_torch_available()
		    else ()
		)
		lowerCamelCase_	:			Optional[Any]       			=  (
		    {
		        """feature-extraction""": BeitModel,
		        """image-classification""": BeitForImageClassification,
		        """image-segmentation""": BeitForSemanticSegmentation,
		    }
		    if is_torch_available()
		    else {}
		)

		lowerCamelCase_	:			Optional[int]       			=  False
		lowerCamelCase_	:			Tuple       			=  False
		lowerCamelCase_	:			Optional[Any]       			=  False






		def _snake_case		(						self				:     Tuple):
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						BeitModelTester(self)
				SCREAMING_SNAKE_CASE_				:Dict				     =						ConfigTester(self   ,  config_class=lowerCamelCase__   ,  has_text_modality=lowerCamelCase__   ,  hidden_size=37)






		def _snake_case		(						self				:     Dict):
				self.config_tester.run_common_tests()






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






		@require_torch_multi_gpu
		@unittest.skip(reason="BEiT has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`")
		def _snake_case		(						self				:     str):
				pass






		def _snake_case		(						self				:     Optional[int]):
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						SCREAMING_SNAKE_CASE_				:Optional[int]				     =						model_class(lowerCamelCase__)
						self.assertIsInstance(model.get_input_embeddings()   ,  (nn.Module))
						SCREAMING_SNAKE_CASE_				:Dict				     =						model.get_output_embeddings()
						self.assertTrue(x is None or isinstance(lowerCamelCase__   ,  nn.Linear))






		def _snake_case		(						self				:     Any):
				SCREAMING_SNAKE_CASE_				:List[str]				     =						self.model_tester.prepare_config_and_inputs_for_common()

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

						SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						['pixel_values']
						self.assertListEqual(arg_names[:1]   ,  lowerCamelCase__)






		def _snake_case		(						self				:     int):
				SCREAMING_SNAKE_CASE_				:Tuple				     =						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowerCamelCase__)






		def _snake_case		(						self				:     List[str]):
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_masked_lm(*lowerCamelCase__)






		def _snake_case		(						self				:     Union[str, Any]):
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*lowerCamelCase__)






		def _snake_case		(						self				:     Optional[int]):
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase__)






		def _snake_case		(						self				:     Dict):
				if not self.model_tester.is_training:
						return

				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						self.model_tester.prepare_config_and_inputs_for_common()
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						True

				for model_class in self.all_model_classes:
						# we don't test BeitForMaskedImageModeling
						if model_class in [*get_values(lowerCamelCase__), BeitForMaskedImageModeling]:
								continue

						SCREAMING_SNAKE_CASE_				:str				     =						model_class(lowerCamelCase__)
						model.to(lowerCamelCase__)
						model.train()
						SCREAMING_SNAKE_CASE_				:Tuple				     =						self._prepare_for_class(lowerCamelCase__   ,  lowerCamelCase__   ,  return_labels=lowerCamelCase__)
						SCREAMING_SNAKE_CASE_				:Any				     =						model(**lowerCamelCase__).loss
						loss.backward()






		def _snake_case		(						self				:     str):
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						self.model_tester.prepare_config_and_inputs_for_common()
				if not self.model_tester.is_training:
						return

				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						False
				SCREAMING_SNAKE_CASE_				:str				     =						True

				for model_class in self.all_model_classes:
						# we don't test BeitForMaskedImageModeling
						if (
						    model_class in [*get_values(lowerCamelCase__), BeitForMaskedImageModeling]
						    or not model_class.supports_gradient_checkpointing
						):
								continue

						SCREAMING_SNAKE_CASE_				:Any				     =						model_class(lowerCamelCase__)
						model.gradient_checkpointing_enable()
						model.to(lowerCamelCase__)
						model.train()
						SCREAMING_SNAKE_CASE_				:Any				     =						self._prepare_for_class(lowerCamelCase__   ,  lowerCamelCase__   ,  return_labels=lowerCamelCase__)
						SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						model(**lowerCamelCase__).loss
						loss.backward()






		def _snake_case		(						self				:     Any):
				SCREAMING_SNAKE_CASE_				:List[str]				     =						self.model_tester.prepare_config_and_inputs_for_common()

				SCREAMING_SNAKE_CASE_				:List[str]				     =						_config_zero_init(lowerCamelCase__)
				for model_class in self.all_model_classes:
						SCREAMING_SNAKE_CASE_				:str				     =						model_class(config=lowerCamelCase__)
						for name, param in model.named_parameters():
								# we skip lambda parameters as these require special initial values
								# determined by config.layer_scale_init_value
								if "lambda" in name:
										continue
								if param.requires_grad:
										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 _snake_case		(						self				:     Dict):
				for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						SCREAMING_SNAKE_CASE_				:Tuple				     =						BeitModel.from_pretrained(lowerCamelCase__)
						self.assertIsNotNone(lowerCamelCase__)




def     lowercase	(    ):



		'''simple docstring'''




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



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






		@cached_property
		def _snake_case		(						self				:     List[Any]):
				return BeitImageProcessor.from_pretrained("microsoft/beit-base-patch16-224") if is_vision_available() else None






		@slow
		def _snake_case		(						self				:     List[Any]):
				SCREAMING_SNAKE_CASE_				:Any				     =						BeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k").to(lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:Tuple				     =						self.default_image_processor
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						prepare_img()
				SCREAMING_SNAKE_CASE_				:List[str]				     =						image_processor(images=lowerCamelCase__   ,  return_tensors="pt").pixel_values.to(lowerCamelCase__)

				# prepare bool_masked_pos
				SCREAMING_SNAKE_CASE_				:Any				     =						torch.ones((1, 1_96)   ,  dtype=torch.bool).to(lowerCamelCase__)

				# forward pass
				with torch.no_grad():
						SCREAMING_SNAKE_CASE_				:Dict				     =						model(pixel_values=lowerCamelCase__   ,  bool_masked_pos=lowerCamelCase__)
				SCREAMING_SNAKE_CASE_				:Dict				     =						outputs.logits

				# verify the logits
				SCREAMING_SNAKE_CASE_				:str				     =						torch.Size((1, 1_96, 81_92))
				self.assertEqual(logits.shape   ,  lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						torch.tensor(
				    [[-3.2437, 0.5072, -13.91_74], [-3.2456, 0.4948, -13.94_01], [-3.2033, 0.5121, -13.85_50]]).to(lowerCamelCase__)

				self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]   ,  lowerCamelCase__   ,  atol=1E-2))






		@slow
		def _snake_case		(						self				:     Optional[Any]):
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						BeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224").to(lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:str				     =						self.default_image_processor
				SCREAMING_SNAKE_CASE_				:Any				     =						prepare_img()
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						image_processor(images=lowerCamelCase__   ,  return_tensors="pt").to(lowerCamelCase__)

				# forward pass
				with torch.no_grad():
						SCREAMING_SNAKE_CASE_				:Any				     =						model(**lowerCamelCase__)
				SCREAMING_SNAKE_CASE_				:Dict				     =						outputs.logits

				# verify the logits
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						torch.Size((1, 10_00))
				self.assertEqual(logits.shape   ,  lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						torch.tensor([-1.2385, -1.0987, -1.0108]).to(lowerCamelCase__)

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

				SCREAMING_SNAKE_CASE_				:List[str]				     =						2_81
				self.assertEqual(logits.argmax(-1).item()   ,  lowerCamelCase__)






		@slow
		def _snake_case		(						self				:     Tuple):
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						BeitForImageClassification.from_pretrained("microsoft/beit-large-patch16-224-pt22k-ft22k").to(
				    lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						self.default_image_processor
				SCREAMING_SNAKE_CASE_				:List[str]				     =						prepare_img()
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						image_processor(images=lowerCamelCase__   ,  return_tensors="pt").to(lowerCamelCase__)

				# forward pass
				with torch.no_grad():
						SCREAMING_SNAKE_CASE_				:Optional[int]				     =						model(**lowerCamelCase__)
				SCREAMING_SNAKE_CASE_				:Any				     =						outputs.logits

				# verify the logits
				SCREAMING_SNAKE_CASE_				:Any				     =						torch.Size((1, 2_18_41))
				self.assertEqual(logits.shape   ,  lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:List[str]				     =						torch.tensor([1.6881, -0.2787, 0.5901]).to(lowerCamelCase__)

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

				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						23_96
				self.assertEqual(logits.argmax(-1).item()   ,  lowerCamelCase__)






		@slow
		def _snake_case		(						self				:     List[str]):
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640")
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						model.to(lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:str				     =						BeitImageProcessor(do_resize=lowerCamelCase__   ,  size=6_40   ,  do_center_crop=lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:List[str]				     =						load_dataset("hf-internal-testing/fixtures_ade20k"   ,  split="test")
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						Image.open(ds[0]["file"])
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						image_processor(images=lowerCamelCase__   ,  return_tensors="pt").to(lowerCamelCase__)

				# forward pass
				with torch.no_grad():
						SCREAMING_SNAKE_CASE_				:List[Any]				     =						model(**lowerCamelCase__)
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						outputs.logits

				# verify the logits
				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						torch.Size((1, 1_50, 1_60, 1_60))
				self.assertEqual(logits.shape   ,  lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:Tuple				     =						version.parse(PIL.__version__) < version.parse("9.0.0")

				if is_pillow_less_than_a:
						SCREAMING_SNAKE_CASE_				:List[Any]				     =						torch.tensor(
						    [
						        [[-4.9225, -2.3954, -3.0522], [-2.8822, -1.0046, -1.7561], [-2.9549, -1.3228, -2.1347]],
						        [[-5.8168, -3.4129, -4.0778], [-3.8651, -2.2214, -3.0277], [-3.8356, -2.4643, -3.3535]],
						        [[-0.0078, 3.9952, 4.0754], [2.9856, 4.6944, 5.0035], [3.2413, 4.7813, 4.9969]],
						    ]   ,  device=lowerCamelCase__   ,  )
				else:
						SCREAMING_SNAKE_CASE_				:List[str]				     =						torch.tensor(
						    [
						        [[-4.8960, -2.3688, -3.0355], [-2.8478, -0.9836, -1.7418], [-2.9449, -1.3332, -2.1456]],
						        [[-5.8081, -3.4124, -4.1006], [-3.8561, -2.2081, -3.0323], [-3.8365, -2.4601, -3.3669]],
						        [[-0.0309, 3.9868, 4.0540], [2.9640, 4.6877, 4.9976], [3.2081, 4.7690, 4.9942]],
						    ]   ,  device=lowerCamelCase__   ,  )

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







		@slow
		def _snake_case		(						self				:     Dict):
				SCREAMING_SNAKE_CASE_				:List[str]				     =						BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640")
				SCREAMING_SNAKE_CASE_				:Tuple				     =						model.to(lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:Dict				     =						BeitImageProcessor(do_resize=lowerCamelCase__   ,  size=6_40   ,  do_center_crop=lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:Optional[Any]				     =						load_dataset("hf-internal-testing/fixtures_ade20k"   ,  split="test")
				SCREAMING_SNAKE_CASE_				:List[str]				     =						Image.open(ds[0]["file"])
				SCREAMING_SNAKE_CASE_				:str				     =						image_processor(images=lowerCamelCase__   ,  return_tensors="pt").to(lowerCamelCase__)

				# forward pass
				with torch.no_grad():
						SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						model(**lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:int				     =						outputs.logits.detach().cpu()

				SCREAMING_SNAKE_CASE_				:List[Any]				     =						image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase__   ,  target_sizes=[(5_00, 3_00)])
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						torch.Size((5_00, 3_00))
				self.assertEqual(segmentation[0].shape   ,  lowerCamelCase__)

				SCREAMING_SNAKE_CASE_				:Tuple				     =						image_processor.post_process_semantic_segmentation(outputs=lowerCamelCase__)
				SCREAMING_SNAKE_CASE_				:List[Any]				     =						torch.Size((1_60, 1_60))
				self.assertEqual(segmentation[0].shape   ,  lowerCamelCase__)











'''simple docstring'''
def A__       (	UpperCAmelCase_ = 1_0_0_0				):
						_UpperCamelCase   :						List[str]												=  3
						_UpperCamelCase   :						Any												=  0
						while a < n:
												if a % 3 == 0 or a % 5 == 0:
																		result += a
												elif a % 1_5 == 0:
																		result -= a
												a += 1
						return result


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


