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 						lowercase    :




							def __init__(						self   :					List[str]	,							_UpperCamelCase   :					Dict	,							_UpperCamelCase   :					Optional[int]=100	,							_UpperCamelCase   :					Any=13	,							_UpperCamelCase   :					Optional[Any]=30	,							_UpperCamelCase   :					Tuple=2	,							_UpperCamelCase   :					List[str]=3	,							_UpperCamelCase   :					List[Any]=True	,							_UpperCamelCase   :					str=True	,							_UpperCamelCase   :					Any=32	,							_UpperCamelCase   :					List[str]=4	,							_UpperCamelCase   :					List[Any]=4	,							_UpperCamelCase   :					Tuple=37	,							_UpperCamelCase   :					List[Any]="gelu"	,							_UpperCamelCase   :					str=0.1	,							_UpperCamelCase   :					Optional[Any]=0.1	,							_UpperCamelCase   :					Any=10	,							_UpperCamelCase   :					Optional[Any]=0.0_2	,							_UpperCamelCase   :					int=3	,							_UpperCamelCase   :					Tuple=None	,							_UpperCamelCase   :					Union[str, Any]=[0, 1, 2, 3]	,							)					->				List[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       parent
												SCREAMING_SNAKE_CASE    			=       100
												SCREAMING_SNAKE_CASE    			=       batch_size
												SCREAMING_SNAKE_CASE    			=       image_size
												SCREAMING_SNAKE_CASE    			=       patch_size
												SCREAMING_SNAKE_CASE    			=       num_channels
												SCREAMING_SNAKE_CASE    			=       is_training
												SCREAMING_SNAKE_CASE    			=       use_labels
												SCREAMING_SNAKE_CASE    			=       hidden_size
												SCREAMING_SNAKE_CASE    			=       num_hidden_layers
												SCREAMING_SNAKE_CASE    			=       num_attention_heads
												SCREAMING_SNAKE_CASE    			=       intermediate_size
												SCREAMING_SNAKE_CASE    			=       hidden_act
												SCREAMING_SNAKE_CASE    			=       hidden_dropout_prob
												SCREAMING_SNAKE_CASE    			=       attention_probs_dropout_prob
												SCREAMING_SNAKE_CASE    			=       type_sequence_label_size
												SCREAMING_SNAKE_CASE    			=       initializer_range
												SCREAMING_SNAKE_CASE    			=       scope
												SCREAMING_SNAKE_CASE    			=       out_indices
												SCREAMING_SNAKE_CASE    			=       num_labels

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




							def 	__snake_case(						self   :					Dict      )					->				int:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

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

												SCREAMING_SNAKE_CASE    			=       self.get_config()

												return config, pixel_values, labels, pixel_labels




							def 	__snake_case(						self   :					Optional[Any]      )					->				Optional[int]:



												'''simple docstring'''

												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=_UpperCamelCase	,							initializer_range=self.initializer_range	,							out_indices=self.out_indices	,							)




							def 	__snake_case(						self   :					List[str]	,							_UpperCamelCase   :					List[Any]	,							_UpperCamelCase   :					str	,							_UpperCamelCase   :					List[str]	,							_UpperCamelCase   :					Union[str, Any]      )					->				List[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       BeitModel(config=_UpperCamelCase      )
												model.to(_UpperCamelCase      )
												model.eval()
												SCREAMING_SNAKE_CASE    			=       model(_UpperCamelCase      )
												self.parent.assertEqual(result.last_hidden_state.shape	,							(self.batch_size, self.seq_length, self.hidden_size)      )




							def 	__snake_case(						self   :					Optional[Any]	,							_UpperCamelCase   :					int	,							_UpperCamelCase   :					Tuple	,							_UpperCamelCase   :					Any	,							_UpperCamelCase   :					Tuple      )					->				str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       BeitForMaskedImageModeling(config=_UpperCamelCase      )
												model.to(_UpperCamelCase      )
												model.eval()
												SCREAMING_SNAKE_CASE    			=       model(_UpperCamelCase      )
												self.parent.assertEqual(result.logits.shape	,							(self.batch_size, self.seq_length - 1, self.vocab_size)      )




							def 	__snake_case(						self   :					Tuple	,							_UpperCamelCase   :					Optional[Any]	,							_UpperCamelCase   :					List[str]	,							_UpperCamelCase   :					Union[str, Any]	,							_UpperCamelCase   :					int      )					->				Union[str, Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       self.type_sequence_label_size
												SCREAMING_SNAKE_CASE    			=       BeitForImageClassification(_UpperCamelCase      )
												model.to(_UpperCamelCase      )
												model.eval()
												SCREAMING_SNAKE_CASE    			=       model(_UpperCamelCase	,							labels=_UpperCamelCase      )
												self.parent.assertEqual(result.logits.shape	,							(self.batch_size, self.type_sequence_label_size)      )

												# test greyscale images
												SCREAMING_SNAKE_CASE    			=       1
												SCREAMING_SNAKE_CASE    			=       BeitForImageClassification(_UpperCamelCase      )
												model.to(_UpperCamelCase      )
												model.eval()

												SCREAMING_SNAKE_CASE    			=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
												SCREAMING_SNAKE_CASE    			=       model(_UpperCamelCase	,							labels=_UpperCamelCase      )
												self.parent.assertEqual(result.logits.shape	,							(self.batch_size, self.type_sequence_label_size)      )




							def 	__snake_case(						self   :					int	,							_UpperCamelCase   :					List[str]	,							_UpperCamelCase   :					Optional[int]	,							_UpperCamelCase   :					str	,							_UpperCamelCase   :					Any      )					->				List[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       self.num_labels
												SCREAMING_SNAKE_CASE    			=       BeitForSemanticSegmentation(_UpperCamelCase      )
												model.to(_UpperCamelCase      )
												model.eval()
												SCREAMING_SNAKE_CASE    			=       model(_UpperCamelCase      )
												self.parent.assertEqual(
												    result.logits.shape	,							(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)      )
												SCREAMING_SNAKE_CASE    			=       model(_UpperCamelCase	,							labels=_UpperCamelCase      )
												self.parent.assertEqual(
												    result.logits.shape	,							(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)      )





							def 	__snake_case(						self   :					int      )					->				List[str]:



												'''simple docstring'''

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



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

							lowercase__						:       str								=							False
							lowercase__						:       int								=							False
							lowercase__						:       Any								=							False




							def 	__snake_case(						self   :					Optional[int]      )					->				Union[str, Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       BeitModelTester(self      )
												SCREAMING_SNAKE_CASE    			=       ConfigTester(self	,							config_class=_UpperCamelCase	,							has_text_modality=_UpperCamelCase	,							hidden_size=37      )




							def 	__snake_case(						self   :					List[str]      )					->				List[str]:



												'''simple docstring'''

												self.config_tester.run_common_tests()




							@unittest.skip(reason="BEiT does not use inputs_embeds"      )
							def 	__snake_case(						self   :					List[str]      )					->				str:



												'''simple docstring'''

												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   :					List[str]      )					->				Optional[int]:



												'''simple docstring'''

												pass




							def 	__snake_case(						self   :					List[Any]      )					->				Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE			,   SCREAMING_SNAKE_CASE    			=       self.model_tester.prepare_config_and_inputs_for_common()

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




							def 	__snake_case(						self   :					List[Any]      )					->				Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE			,   SCREAMING_SNAKE_CASE    			=       self.model_tester.prepare_config_and_inputs_for_common()

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

																	SCREAMING_SNAKE_CASE    			=       ["pixel_values"]
																	self.assertListEqual(arg_names[:1]	,							_UpperCamelCase      )




							def 	__snake_case(						self   :					str      )					->				Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_UpperCamelCase      )




							def 	__snake_case(						self   :					List[str]      )					->				List[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*_UpperCamelCase      )




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



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase      )




							def 	__snake_case(						self   :					Tuple      )					->				Optional[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_semantic_segmentation(*_UpperCamelCase      )




							def 	__snake_case(						self   :					str      )					->				List[str]:



												'''simple docstring'''

												if not self.model_tester.is_training:
																	return

												SCREAMING_SNAKE_CASE			,   SCREAMING_SNAKE_CASE    			=       self.model_tester.prepare_config_and_inputs_for_common()
												SCREAMING_SNAKE_CASE    			=       True

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

																	SCREAMING_SNAKE_CASE    			=       model_class(_UpperCamelCase      )
																	model.to(_UpperCamelCase      )
																	model.train()
																	SCREAMING_SNAKE_CASE    			=       self._prepare_for_class(_UpperCamelCase	,							_UpperCamelCase	,							return_labels=_UpperCamelCase      )
																	SCREAMING_SNAKE_CASE    			=       model(**_UpperCamelCase      ).loss
																	loss.backward()




							def 	__snake_case(						self   :					Tuple      )					->				List[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE			,   SCREAMING_SNAKE_CASE    			=       self.model_tester.prepare_config_and_inputs_for_common()
												if not self.model_tester.is_training:
																	return

												SCREAMING_SNAKE_CASE    			=       False
												SCREAMING_SNAKE_CASE    			=       True

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

																	SCREAMING_SNAKE_CASE    			=       model_class(_UpperCamelCase      )
																	model.gradient_checkpointing_enable()
																	model.to(_UpperCamelCase      )
																	model.train()
																	SCREAMING_SNAKE_CASE    			=       self._prepare_for_class(_UpperCamelCase	,							_UpperCamelCase	,							return_labels=_UpperCamelCase      )
																	SCREAMING_SNAKE_CASE    			=       model(**_UpperCamelCase      ).loss
																	loss.backward()




							def 	__snake_case(						self   :					Union[str, Any]      )					->				List[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE			,   SCREAMING_SNAKE_CASE    			=       self.model_tester.prepare_config_and_inputs_for_common()

												SCREAMING_SNAKE_CASE    			=       _config_zero_init(_UpperCamelCase      )
												for model_class in self.all_model_classes:
																	SCREAMING_SNAKE_CASE    			=       model_class(config=_UpperCamelCase      )
																	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   :					List[str]      )					->				str:



												'''simple docstring'''

												for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	SCREAMING_SNAKE_CASE    			=       BeitModel.from_pretrained(_UpperCamelCase      )
																	self.assertIsNotNone(_UpperCamelCase      )





def 	__lowerCamelCase							():
					SCREAMING_SNAKE_CASE    			=       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
					return image


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




							@cached_property
							def 	__snake_case(						self   :					Dict      )					->				List[str]:



												'''simple docstring'''

												return BeitImageProcessor.from_pretrained("microsoft/beit-base-patch16-224"      ) if is_vision_available() else None




							@slow
							def 	__snake_case(						self   :					Any      )					->				List[Any]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       BeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k"      ).to(_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       self.default_image_processor
												SCREAMING_SNAKE_CASE    			=       prepare_img()
												SCREAMING_SNAKE_CASE    			=       image_processor(images=_UpperCamelCase	,							return_tensors="pt"      ).pixel_values.to(_UpperCamelCase      )

												# prepare bool_masked_pos
												SCREAMING_SNAKE_CASE    			=       torch.ones((1, 196)	,							dtype=torch.bool      ).to(_UpperCamelCase      )

												# forward pass
												with torch.no_grad():
																	SCREAMING_SNAKE_CASE    			=       model(pixel_values=_UpperCamelCase	,							bool_masked_pos=_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       outputs.logits

												# verify the logits
												SCREAMING_SNAKE_CASE    			=       torch.Size((1, 196, 8_192)      )
												self.assertEqual(logits.shape	,							_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       torch.tensor(
												    [[-3.2_4_3_7, 0.5_0_7_2, -13.9_174], [-3.2_4_5_6, 0.4_9_4_8, -13.9_401], [-3.2_0_3_3, 0.5_1_2_1, -13.8_550]]      ).to(_UpperCamelCase      )

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




							@slow
							def 	__snake_case(						self   :					List[Any]      )					->				int:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       BeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224"      ).to(_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       self.default_image_processor
												SCREAMING_SNAKE_CASE    			=       prepare_img()
												SCREAMING_SNAKE_CASE    			=       image_processor(images=_UpperCamelCase	,							return_tensors="pt"      ).to(_UpperCamelCase      )

												# forward pass
												with torch.no_grad():
																	SCREAMING_SNAKE_CASE    			=       model(**_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       outputs.logits

												# verify the logits
												SCREAMING_SNAKE_CASE    			=       torch.Size((1, 1_000)      )
												self.assertEqual(logits.shape	,							_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       torch.tensor([-1.2_3_8_5, -1.0_9_8_7, -1.0_1_0_8]      ).to(_UpperCamelCase      )

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

												SCREAMING_SNAKE_CASE    			=       281
												self.assertEqual(logits.argmax(-1      ).item()	,							_UpperCamelCase      )




							@slow
							def 	__snake_case(						self   :					Any      )					->				List[str]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       BeitForImageClassification.from_pretrained("microsoft/beit-large-patch16-224-pt22k-ft22k"      ).to(
												    _UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       self.default_image_processor
												SCREAMING_SNAKE_CASE    			=       prepare_img()
												SCREAMING_SNAKE_CASE    			=       image_processor(images=_UpperCamelCase	,							return_tensors="pt"      ).to(_UpperCamelCase      )

												# forward pass
												with torch.no_grad():
																	SCREAMING_SNAKE_CASE    			=       model(**_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       outputs.logits

												# verify the logits
												SCREAMING_SNAKE_CASE    			=       torch.Size((1, 21_841)      )
												self.assertEqual(logits.shape	,							_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       torch.tensor([1.6_8_8_1, -0.2_7_8_7, 0.5_9_0_1]      ).to(_UpperCamelCase      )

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

												SCREAMING_SNAKE_CASE    			=       2_396
												self.assertEqual(logits.argmax(-1      ).item()	,							_UpperCamelCase      )




							@slow
							def 	__snake_case(						self   :					List[str]      )					->				str:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640"      )
												SCREAMING_SNAKE_CASE    			=       model.to(_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       BeitImageProcessor(do_resize=_UpperCamelCase	,							size=640	,							do_center_crop=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       load_dataset("hf-internal-testing/fixtures_ade20k"	,							split="test"      )
												SCREAMING_SNAKE_CASE    			=       Image.open(ds[0]["file"]      )
												SCREAMING_SNAKE_CASE    			=       image_processor(images=_UpperCamelCase	,							return_tensors="pt"      ).to(_UpperCamelCase      )

												# forward pass
												with torch.no_grad():
																	SCREAMING_SNAKE_CASE    			=       model(**_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       outputs.logits

												# verify the logits
												SCREAMING_SNAKE_CASE    			=       torch.Size((1, 150, 160, 160)      )
												self.assertEqual(logits.shape	,							_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       version.parse(PIL.__version__      ) < version.parse("9.0.0"      )

												if is_pillow_less_than_a:
																	SCREAMING_SNAKE_CASE    			=       torch.tensor(
																	    [
																	        [[-4.9_2_2_5, -2.3_9_5_4, -3.0_5_2_2], [-2.8_8_2_2, -1.0_0_4_6, -1.7_5_6_1], [-2.9_5_4_9, -1.3_2_2_8, -2.1_3_4_7]],
																	        [[-5.8_1_6_8, -3.4_1_2_9, -4.0_7_7_8], [-3.8_6_5_1, -2.2_2_1_4, -3.0_2_7_7], [-3.8_3_5_6, -2.4_6_4_3, -3.3_5_3_5]],
																	        [[-0.0_0_7_8, 3.9_9_5_2, 4.0_7_5_4], [2.9_8_5_6, 4.6_9_4_4, 5.0_0_3_5], [3.2_4_1_3, 4.7_8_1_3, 4.9_9_6_9]],
																	    ]	,							device=_UpperCamelCase	,							)
												else:
																	SCREAMING_SNAKE_CASE    			=       torch.tensor(
																	    [
																	        [[-4.8_9_6_0, -2.3_6_8_8, -3.0_3_5_5], [-2.8_4_7_8, -0.9_8_3_6, -1.7_4_1_8], [-2.9_4_4_9, -1.3_3_3_2, -2.1_4_5_6]],
																	        [[-5.8_0_8_1, -3.4_1_2_4, -4.1_0_0_6], [-3.8_5_6_1, -2.2_0_8_1, -3.0_3_2_3], [-3.8_3_6_5, -2.4_6_0_1, -3.3_6_6_9]],
																	        [[-0.0_3_0_9, 3.9_8_6_8, 4.0_5_4_0], [2.9_6_4_0, 4.6_8_7_7, 4.9_9_7_6], [3.2_0_8_1, 4.7_6_9_0, 4.9_9_4_2]],
																	    ]	,							device=_UpperCamelCase	,							)

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





							@slow
							def 	__snake_case(						self   :					Union[str, Any]      )					->				Optional[int]:



												'''simple docstring'''

												SCREAMING_SNAKE_CASE    			=       BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640"      )
												SCREAMING_SNAKE_CASE    			=       model.to(_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       BeitImageProcessor(do_resize=_UpperCamelCase	,							size=640	,							do_center_crop=_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       load_dataset("hf-internal-testing/fixtures_ade20k"	,							split="test"      )
												SCREAMING_SNAKE_CASE    			=       Image.open(ds[0]["file"]      )
												SCREAMING_SNAKE_CASE    			=       image_processor(images=_UpperCamelCase	,							return_tensors="pt"      ).to(_UpperCamelCase      )

												# forward pass
												with torch.no_grad():
																	SCREAMING_SNAKE_CASE    			=       model(**_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       outputs.logits.detach().cpu()

												SCREAMING_SNAKE_CASE    			=       image_processor.post_process_semantic_segmentation(outputs=_UpperCamelCase	,							target_sizes=[(500, 300)]      )
												SCREAMING_SNAKE_CASE    			=       torch.Size((500, 300)      )
												self.assertEqual(segmentation[0].shape	,							_UpperCamelCase      )

												SCREAMING_SNAKE_CASE    			=       image_processor.post_process_semantic_segmentation(outputs=_UpperCamelCase      )
												SCREAMING_SNAKE_CASE    			=       torch.Size((160, 160)      )
												self.assertEqual(segmentation[0].shape	,							_UpperCamelCase      )





def 	__lowerCamelCase							(UpperCAmelCase__     :							list[int]  ):
					if not numbers:
										return 0

					if not isinstance(UpperCAmelCase__      , (list, tuple)  ) or not all(
					    isinstance(UpperCAmelCase__      , UpperCAmelCase__  ) for number in numbers  ):
										raise ValueError("numbers must be an iterable of integers"  )

					SCREAMING_SNAKE_CASE    			=       SCREAMING_SNAKE_CASE    			=       SCREAMING_SNAKE_CASE    			=       numbers[0]

					for i in range(1      , len(UpperCAmelCase__  )  ):
										# update the maximum and minimum subarray products
										SCREAMING_SNAKE_CASE    			=       numbers[i]
										if number < 0:
															SCREAMING_SNAKE_CASE			,   SCREAMING_SNAKE_CASE    			=       min_till_now, max_till_now
										SCREAMING_SNAKE_CASE    			=       max(UpperCAmelCase__      , max_till_now * number  )
										SCREAMING_SNAKE_CASE    			=       min(UpperCAmelCase__      , min_till_now * number  )

										# update the maximum product found till now
										SCREAMING_SNAKE_CASE    			=       max(UpperCAmelCase__      , UpperCAmelCase__  )

					return max_prod




