




'''simple docstring'''







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     _a						:
							def __init__(			self		:			int     ,       lowercase		:			List[Any]     ,       lowercase		:			Optional[int]=100     ,       lowercase		:			Optional[int]=13     ,       lowercase		:			int=30     ,       lowercase		:			Any=2     ,       lowercase		:			Any=3     ,       lowercase		:			Optional[int]=True     ,       lowercase		:			Tuple=True     ,       lowercase		:			Tuple=32     ,       lowercase		:			str=4     ,       lowercase		:			Optional[Any]=4     ,       lowercase		:			Dict=37     ,       lowercase		:			List[Any]="gelu"     ,       lowercase		:			int=0.1     ,       lowercase		:			Union[str, Any]=0.1     ,       lowercase		:			Dict=10     ,       lowercase		:			Tuple=0.02     ,       lowercase		:			Optional[Any]=3     ,       lowercase		:			List[str]=None     ,       lowercase		:			Optional[int]=[0, 1, 2, 3]     ,       ):



											'''simple docstring'''

											UpperCAmelCase     =	parent
											UpperCAmelCase     =	100
											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     =	scope
											UpperCAmelCase     =	out_indices
											UpperCAmelCase     =	num_labels

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



											'''simple docstring'''

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

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

											UpperCAmelCase     =	self.get_config()

											return config, pixel_values, labels, pixel_labels
							def 					A   (			self		:			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=A_     ,       initializer_range=self.initializer_range     ,       out_indices=self.out_indices     ,       )
							def 					A   (			self		:			Union[str, Any]     ,       lowercase		:			Optional[int]     ,       lowercase		:			Dict     ,       lowercase		:			Any     ,       lowercase		:			Dict       ):



											'''simple docstring'''

											UpperCAmelCase     =	BeitModel(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 					A   (			self		:			Optional[int]     ,       lowercase		:			Tuple     ,       lowercase		:			Optional[int]     ,       lowercase		:			List[str]     ,       lowercase		:			Any       ):



											'''simple docstring'''

											UpperCAmelCase     =	BeitForMaskedImageModeling(config=A_       )
											model.to(A_       )
											model.eval()
											UpperCAmelCase     =	model(A_       )
											self.parent.assertEqual(result.logits.shape     ,       (self.batch_size, self.seq_length - 1, self.vocab_size)       )
							def 					A   (			self		:			str     ,       lowercase		:			Dict     ,       lowercase		:			Tuple     ,       lowercase		:			Union[str, Any]     ,       lowercase		:			Tuple       ):



											'''simple docstring'''

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

											# test greyscale images
											UpperCAmelCase     =	1
											UpperCAmelCase     =	BeitForImageClassification(A_       )
											model.to(A_       )
											model.eval()

											UpperCAmelCase     =	floats_tensor([self.batch_size, 1, self.image_size, self.image_size]       )
											UpperCAmelCase     =	model(A_     ,       labels=A_       )
											self.parent.assertEqual(result.logits.shape     ,       (self.batch_size, self.type_sequence_label_size)       )
							def 					A   (			self		:			List[str]     ,       lowercase		:			List[str]     ,       lowercase		:			int     ,       lowercase		:			Optional[Any]     ,       lowercase		:			List[Any]       ):



											'''simple docstring'''

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







							def 					A   (			self		:			Dict       ):



											'''simple docstring'''

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






@require_torch
class     _a						(			_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							unittest.TestCase				):
							__a       :  str            =      (
							    (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
							    if is_torch_available()
							    else ()
							)
							__a       :  Tuple            =      (
							    {
							        "feature-extraction": BeitModel,
							        "image-classification": BeitForImageClassification,
							        "image-segmentation": BeitForSemanticSegmentation,
							    }
							    if is_torch_available()
							    else {}
							)

							__a       :  Any            =      False
							__a       :  int            =      False
							__a       :  List[Any]            =      False
							def 					A   (			self		:			Tuple       ):



											'''simple docstring'''

											UpperCAmelCase     =	BeitModelTester(self       )
											UpperCAmelCase     =	ConfigTester(self     ,       config_class=A_     ,       has_text_modality=A_     ,       hidden_size=37       )
							def 					A   (			self		:			Tuple       ):



											'''simple docstring'''

											self.config_tester.run_common_tests()
							@unittest.skip(reason='''BEiT does not use inputs_embeds'''       )
							def 					A   (			self		:			Any       ):



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



											'''simple docstring'''

											pass
							def 					A   (			self		:			Union[str, Any]       ):



											'''simple docstring'''

											UpperCAmelCase ,  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 					A   (			self		:			Optional[Any]       ):



											'''simple docstring'''

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



											'''simple docstring'''

											UpperCAmelCase     =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*A_       )
							def 					A   (			self		:			str       ):



											'''simple docstring'''

											UpperCAmelCase     =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_lm(*A_       )
							def 					A   (			self		:			Union[str, Any]       ):



											'''simple docstring'''

											UpperCAmelCase     =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*A_       )
							def 					A   (			self		:			Optional[Any]       ):



											'''simple docstring'''

											UpperCAmelCase     =	self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_semantic_segmentation(*A_       )
							def 					A   (			self		:			Dict       ):



											'''simple docstring'''

											if not self.model_tester.is_training:
															return

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

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

															UpperCAmelCase     =	model_class(A_       )
															model.to(A_       )
															model.train()
															UpperCAmelCase     =	self._prepare_for_class(A_     ,       A_     ,       return_labels=A_       )
															UpperCAmelCase     =	model(**A_       ).loss
															loss.backward()
							def 					A   (			self		:			Tuple       ):



											'''simple docstring'''

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

											UpperCAmelCase     =	False
											UpperCAmelCase     =	True

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

															UpperCAmelCase     =	model_class(A_       )
															model.gradient_checkpointing_enable()
															model.to(A_       )
															model.train()
															UpperCAmelCase     =	self._prepare_for_class(A_     ,       A_     ,       return_labels=A_       )
															UpperCAmelCase     =	model(**A_       ).loss
															loss.backward()
							def 					A   (			self		:			Tuple       ):



											'''simple docstring'''

											UpperCAmelCase ,  UpperCAmelCase     =	self.model_tester.prepare_config_and_inputs_for_common()

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



											'''simple docstring'''

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






def 		snake_case_							():
				UpperCAmelCase     =	Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''  )
				return image







@require_torch
@require_vision
class     _a						(			unittest.TestCase				):
							@cached_property
							def 					A   (			self		:			Union[str, Any]       ):



											'''simple docstring'''

											return BeitImageProcessor.from_pretrained('''microsoft/beit-base-patch16-224'''       ) if is_vision_available() else None
							@slow
							def 					A   (			self		:			Optional[Any]       ):



											'''simple docstring'''

											UpperCAmelCase     =	BeitForMaskedImageModeling.from_pretrained('''microsoft/beit-base-patch16-224-pt22k'''       ).to(A_       )

											UpperCAmelCase     =	self.default_image_processor
											UpperCAmelCase     =	prepare_img()
											UpperCAmelCase     =	image_processor(images=A_     ,       return_tensors='''pt'''       ).pixel_values.to(A_       )

											# prepare bool_masked_pos
											UpperCAmelCase     =	torch.ones((1, 196)     ,       dtype=torch.bool       ).to(A_       )

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

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

											UpperCAmelCase     =	torch.tensor(
											    [[-3.2437, 0.5072, -13.9174], [-3.2456, 0.4948, -13.9401], [-3.2033, 0.5121, -13.8550]]       ).to(A_       )

											self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3]     ,       A_     ,       atol=1E-2       )       )
							@slow
							def 					A   (			self		:			List[Any]       ):



											'''simple docstring'''

											UpperCAmelCase     =	BeitForImageClassification.from_pretrained('''microsoft/beit-base-patch16-224'''       ).to(A_       )

											UpperCAmelCase     =	self.default_image_processor
											UpperCAmelCase     =	prepare_img()
											UpperCAmelCase     =	image_processor(images=A_     ,       return_tensors='''pt'''       ).to(A_       )

											# forward pass
											with torch.no_grad():
															UpperCAmelCase     =	model(**A_       )
											UpperCAmelCase     =	outputs.logits

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

											UpperCAmelCase     =	torch.tensor([-1.2385, -1.0987, -1.0108]       ).to(A_       )

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

											UpperCAmelCase     =	281
											self.assertEqual(logits.argmax(-1       ).item()     ,       A_       )
							@slow
							def 					A   (			self		:			List[Any]       ):



											'''simple docstring'''

											UpperCAmelCase     =	BeitForImageClassification.from_pretrained('''microsoft/beit-large-patch16-224-pt22k-ft22k'''       ).to(
											    A_       )

											UpperCAmelCase     =	self.default_image_processor
											UpperCAmelCase     =	prepare_img()
											UpperCAmelCase     =	image_processor(images=A_     ,       return_tensors='''pt'''       ).to(A_       )

											# forward pass
											with torch.no_grad():
															UpperCAmelCase     =	model(**A_       )
											UpperCAmelCase     =	outputs.logits

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

											UpperCAmelCase     =	torch.tensor([1.6881, -0.2787, 0.5901]       ).to(A_       )

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

											UpperCAmelCase     =	2_396
											self.assertEqual(logits.argmax(-1       ).item()     ,       A_       )
							@slow
							def 					A   (			self		:			Dict       ):



											'''simple docstring'''

											UpperCAmelCase     =	BeitForSemanticSegmentation.from_pretrained('''microsoft/beit-base-finetuned-ade-640-640'''       )
											UpperCAmelCase     =	model.to(A_       )

											UpperCAmelCase     =	BeitImageProcessor(do_resize=A_     ,       size=640     ,       do_center_crop=A_       )

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

											# forward pass
											with torch.no_grad():
															UpperCAmelCase     =	model(**A_       )
											UpperCAmelCase     =	outputs.logits

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

											UpperCAmelCase     =	version.parse(PIL.__version__       ) < version.parse('''9.0.0'''       )

											if is_pillow_less_than_a:
															UpperCAmelCase     =	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=A_     ,       )
											else:
															UpperCAmelCase     =	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=A_     ,       )

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







							@slow
							def 					A   (			self		:			int       ):



											'''simple docstring'''

											UpperCAmelCase     =	BeitForSemanticSegmentation.from_pretrained('''microsoft/beit-base-finetuned-ade-640-640'''       )
											UpperCAmelCase     =	model.to(A_       )

											UpperCAmelCase     =	BeitImageProcessor(do_resize=A_     ,       size=640     ,       do_center_crop=A_       )

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

											# forward pass
											with torch.no_grad():
															UpperCAmelCase     =	model(**A_       )

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

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

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










'''simple docstring'''







from ...configuration_utils import PretrainedConfig
from ...utils import logging


A									=logging.get_logger(__name__)

A									={
    'alibaba-damo/mgp-str-base': 'https://huggingface.co/alibaba-damo/mgp-str-base/resolve/main/config.json',
}


class     _a						(			__a				):
       __a       :  List[Any]            =      """mgp-str"""
       def __init__(			self		:			str     ,       lowercase		:			str=[32, 128]     ,       lowercase		:			Optional[Any]=4     ,       lowercase		:			Optional[Any]=3     ,       lowercase		:			Dict=27     ,       lowercase		:			Any=38     ,       lowercase		:			int=50_257     ,       lowercase		:			List[str]=30_522     ,       lowercase		:			Optional[int]=768     ,       lowercase		:			List[Any]=12     ,       lowercase		:			Tuple=12     ,       lowercase		:			Optional[int]=4.0     ,       lowercase		:			Union[str, Any]=True     ,       lowercase		:			str=False     ,       lowercase		:			str=1E-5     ,       lowercase		:			Dict=0.0     ,       lowercase		:			Dict=0.0     ,       lowercase		:			Tuple=0.0     ,       lowercase		:			str=False     ,       lowercase		:			Optional[Any]=0.02     ,       **lowercase		:			List[str]     ,       ):



           '''simple docstring'''

           super().__init__(**lowercase       )

           UpperCAmelCase     =	image_size
           UpperCAmelCase     =	patch_size
           UpperCAmelCase     =	num_channels
           UpperCAmelCase     =	max_token_length
           UpperCAmelCase     =	num_character_labels
           UpperCAmelCase     =	num_bpe_labels
           UpperCAmelCase     =	num_wordpiece_labels
           UpperCAmelCase     =	hidden_size
           UpperCAmelCase     =	num_hidden_layers
           UpperCAmelCase     =	num_attention_heads
           UpperCAmelCase     =	mlp_ratio
           UpperCAmelCase     =	distilled
           UpperCAmelCase     =	layer_norm_eps
           UpperCAmelCase     =	drop_rate
           UpperCAmelCase     =	qkv_bias
           UpperCAmelCase     =	attn_drop_rate
           UpperCAmelCase     =	drop_path_rate
           UpperCAmelCase     =	output_aa_attentions
           UpperCAmelCase     =	initializer_range




