


'''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 					__lowerCAmelCase   :

						"""simple docstring"""






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

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






						def 				_UpperCAmelCase       (  self							:      str	):
													A_			    =		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

													A_			    =		self.get_config()

													return config, pixel_values, labels, pixel_labels






						def 				_UpperCAmelCase       (  self							:      Union[str, Any]	):
													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 				_UpperCAmelCase       (  self							:      str ,  lowerCAmelCase							:      Dict ,  lowerCAmelCase							:      Any ,  lowerCAmelCase							:      Dict ,  lowerCAmelCase							:      Dict	):
													A_			    =		BeitModel(config=lowerCAmelCase	)
													model.to(lowerCAmelCase	)
													model.eval()
													A_			    =		model(lowerCAmelCase	)
													self.parent.assertEqual(result.last_hidden_state.shape ,  (self.batch_size, self.seq_length, self.hidden_size)	)






						def 				_UpperCAmelCase       (  self							:      Dict ,  lowerCAmelCase							:      Union[str, Any] ,  lowerCAmelCase							:      List[Any] ,  lowerCAmelCase							:      Optional[int] ,  lowerCAmelCase							:      Optional[int]	):
													A_			    =		BeitForMaskedImageModeling(config=lowerCAmelCase	)
													model.to(lowerCAmelCase	)
													model.eval()
													A_			    =		model(lowerCAmelCase	)
													self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.seq_length - 1, self.vocab_size)	)






						def 				_UpperCAmelCase       (  self							:      Union[str, Any] ,  lowerCAmelCase							:      List[Any] ,  lowerCAmelCase							:      int ,  lowerCAmelCase							:      Tuple ,  lowerCAmelCase							:      str	):
													A_			    =		self.type_sequence_label_size
													A_			    =		BeitForImageClassification(lowerCAmelCase	)
													model.to(lowerCAmelCase	)
													model.eval()
													A_			    =		model(lowerCAmelCase ,  labels=lowerCAmelCase	)
													self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.type_sequence_label_size)	)

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

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






						def 				_UpperCAmelCase       (  self							:      Optional[int] ,  lowerCAmelCase							:      Optional[int] ,  lowerCAmelCase							:      Optional[Any] ,  lowerCAmelCase							:      Dict ,  lowerCAmelCase							:      List[Any]	):
													A_			    =		self.num_labels
													A_			    =		BeitForSemanticSegmentation(lowerCAmelCase	)
													model.to(lowerCAmelCase	)
													model.eval()
													A_			    =		model(lowerCAmelCase	)
													self.parent.assertEqual(
													    result.logits.shape ,  (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)	)
													A_			    =		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 				_UpperCAmelCase       (  self							:      str	):
													A_			    =		self.prepare_config_and_inputs()
													A_    ,					A_    ,					A_    ,					A_			    =		config_and_inputs
													A_			    =		{"pixel_values": pixel_values}
													return config, inputs_dict






@require_torch
class 					__lowerCAmelCase   (   lowercase				,			lowercase				,			unittest.TestCase						):

						"""simple docstring"""






						_UpperCAmelCase		:       Tuple   						=(
						    (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
						    if is_torch_available()
						    else ()
						)
						_UpperCAmelCase		:       Dict   						=(
						    {
						        "feature-extraction": BeitModel,
						        "image-classification": BeitForImageClassification,
						        "image-segmentation": BeitForSemanticSegmentation,
						    }
						    if is_torch_available()
						    else {}
						)

						_UpperCAmelCase		:       List[str]   						=False
						_UpperCAmelCase		:       Dict   						=False
						_UpperCAmelCase		:       str   						=False






						def 				_UpperCAmelCase       (  self							:      Union[str, Any]	):
													A_			    =		BeitModelTester(self	)
													A_			    =		ConfigTester(self ,  config_class=lowerCAmelCase ,  has_text_modality=lowerCAmelCase ,  hidden_size=37	)






						def 				_UpperCAmelCase       (  self							:      str	):
													self.config_tester.run_common_tests()






						@unittest.skip(reason="BEiT does not use inputs_embeds"	)
						def 				_UpperCAmelCase       (  self							:      Union[str, 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 				_UpperCAmelCase       (  self							:      Optional[Any]	):
													pass






						def 				_UpperCAmelCase       (  self							:      Optional[Any]	):
													A_    ,					A_			    =		self.model_tester.prepare_config_and_inputs_for_common()

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






						def 				_UpperCAmelCase       (  self							:      Union[str, Any]	):
													A_    ,					A_			    =		self.model_tester.prepare_config_and_inputs_for_common()

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

																				A_			    =		["pixel_values"]
																				self.assertListEqual(arg_names[:1] ,  lowerCAmelCase	)






						def 				_UpperCAmelCase       (  self							:      Union[str, Any]	):
													A_			    =		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*lowerCAmelCase	)






						def 				_UpperCAmelCase       (  self							:      Tuple	):
													A_			    =		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase	)






						def 				_UpperCAmelCase       (  self							:      int	):
													A_			    =		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_image_classification(*lowerCAmelCase	)






						def 				_UpperCAmelCase       (  self							:      Dict	):
													A_			    =		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_semantic_segmentation(*lowerCAmelCase	)






						def 				_UpperCAmelCase       (  self							:      int	):
													if not self.model_tester.is_training:
																				return

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

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

																				A_			    =		model_class(lowerCAmelCase	)
																				model.to(lowerCAmelCase	)
																				model.train()
																				A_			    =		self._prepare_for_class(lowerCAmelCase ,  lowerCAmelCase ,  return_labels=lowerCAmelCase	)
																				A_			    =		model(**lowerCAmelCase	).loss
																				loss.backward()






						def 				_UpperCAmelCase       (  self							:      List[Any]	):
													A_    ,					A_			    =		self.model_tester.prepare_config_and_inputs_for_common()
													if not self.model_tester.is_training:
																				return

													A_			    =		False
													A_			    =		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

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






						def 				_UpperCAmelCase       (  self							:      Dict	):
													A_    ,					A_			    =		self.model_tester.prepare_config_and_inputs_for_common()

													A_			    =		_config_zero_init(lowerCAmelCase	)
													for model_class in self.all_model_classes:
																				A_			    =		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 				_UpperCAmelCase       (  self							:      int	):
													for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				A_			    =		BeitModel.from_pretrained(lowerCAmelCase	)
																				self.assertIsNotNone(lowerCAmelCase	)







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







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

						"""simple docstring"""






						@cached_property
						def 				_UpperCAmelCase       (  self							:      str	):
													return BeitImageProcessor.from_pretrained("microsoft/beit-base-patch16-224"	) if is_vision_available() else None






						@slow
						def 				_UpperCAmelCase       (  self							:      List[str]	):
													A_			    =		BeitForMaskedImageModeling.from_pretrained("microsoft/beit-base-patch16-224-pt22k"	).to(lowerCAmelCase	)

													A_			    =		self.default_image_processor
													A_			    =		prepare_img()
													A_			    =		image_processor(images=lowerCAmelCase ,  return_tensors="pt"	).pixel_values.to(lowerCAmelCase	)

													# prepare bool_masked_pos
													A_			    =		torch.ones((1, 1_96) ,  dtype=torch.bool	).to(lowerCAmelCase	)

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

													# verify the logits
													A_			    =		torch.Size((1, 1_96, 81_92)	)
													self.assertEqual(logits.shape ,  lowerCAmelCase	)

													A_			    =		torch.tensor(
													    [[-3.2_4_3_7, 0.5_0_7_2, -1_3.9_1_7_4], [-3.2_4_5_6, 0.4_9_4_8, -1_3.9_4_0_1], [-3.2_0_3_3, 0.5_1_2_1, -1_3.8_5_5_0]]	).to(lowerCAmelCase	)

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






						@slow
						def 				_UpperCAmelCase       (  self							:      Optional[int]	):
													A_			    =		BeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224"	).to(lowerCAmelCase	)

													A_			    =		self.default_image_processor
													A_			    =		prepare_img()
													A_			    =		image_processor(images=lowerCAmelCase ,  return_tensors="pt"	).to(lowerCAmelCase	)

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

													# verify the logits
													A_			    =		torch.Size((1, 10_00)	)
													self.assertEqual(logits.shape ,  lowerCAmelCase	)

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

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

													A_			    =		2_81
													self.assertEqual(logits.argmax(-1	).item() ,  lowerCAmelCase	)






						@slow
						def 				_UpperCAmelCase       (  self							:      Tuple	):
													A_			    =		BeitForImageClassification.from_pretrained("microsoft/beit-large-patch16-224-pt22k-ft22k"	).to(
													    lowerCAmelCase	)

													A_			    =		self.default_image_processor
													A_			    =		prepare_img()
													A_			    =		image_processor(images=lowerCAmelCase ,  return_tensors="pt"	).to(lowerCAmelCase	)

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

													# verify the logits
													A_			    =		torch.Size((1, 2_18_41)	)
													self.assertEqual(logits.shape ,  lowerCAmelCase	)

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

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

													A_			    =		23_96
													self.assertEqual(logits.argmax(-1	).item() ,  lowerCAmelCase	)






						@slow
						def 				_UpperCAmelCase       (  self							:      List[Any]	):
													A_			    =		BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640"	)
													A_			    =		model.to(lowerCAmelCase	)

													A_			    =		BeitImageProcessor(do_resize=lowerCAmelCase ,  size=6_40 ,  do_center_crop=lowerCAmelCase	)

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

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

													# verify the logits
													A_			    =		torch.Size((1, 1_50, 1_60, 1_60)	)
													self.assertEqual(logits.shape ,  lowerCAmelCase	)

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

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

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






						@slow
						def 				_UpperCAmelCase       (  self							:      str	):
													A_			    =		BeitForSemanticSegmentation.from_pretrained("microsoft/beit-base-finetuned-ade-640-640"	)
													A_			    =		model.to(lowerCAmelCase	)

													A_			    =		BeitImageProcessor(do_resize=lowerCAmelCase ,  size=6_40 ,  do_center_crop=lowerCAmelCase	)

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

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

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

													A_			    =		image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase ,  target_sizes=[(5_00, 3_00)]	)
													A_			    =		torch.Size((5_00, 3_00)	)
													self.assertEqual(segmentation[0].shape ,  lowerCAmelCase	)

													A_			    =		image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase	)
													A_			    =		torch.Size((1_60, 1_60)	)
													self.assertEqual(segmentation[0].shape ,  lowerCAmelCase	)









'''simple docstring'''
import string
from math import logaa







def       a_				(	UpperCamelCase_						,  UpperCamelCase_ ):
							A_			    =		document.translate(
							    str.maketrans(""						,  ""						,  string.punctuation ) ).replace("\n"						,  "" )
							A_			    =		document_without_punctuation.split(" " )  # word tokenization
							return len([word for word in tokenize_document if word.lower() == term.lower()] )







def       a_				(	UpperCamelCase_						,  UpperCamelCase_ ):
							A_			    =		corpus.lower().translate(
							    str.maketrans(""						,  ""						,  string.punctuation ) )  # strip all punctuation and replace it with ''
							A_			    =		corpus_without_punctuation.split("\n" )
							A_			    =		term.lower()
							return (len([doc for doc in docs if term in doc] ), len(UpperCamelCase_ ))







def       a_				(	UpperCamelCase_						,  UpperCamelCase_						,  UpperCamelCase_=False ):
							if smoothing:
														if n == 0:
																					raise ValueError("log10(0) is undefined." )
														return round(1 + logaa(n / (1 + df) )						,  3 )

							if df == 0:
														raise ZeroDivisionError("df must be > 0" )
							elif n == 0:
														raise ValueError("log10(0) is undefined." )
							return round(logaa(n / df )						,  3 )







def       a_				(	UpperCamelCase_						,  UpperCamelCase_ ):
							return round(tf * idf						,  3 )





