


"""simple docstring"""

from argparse import ArgumentParser

from . import BaseTransformersCLICommand


def lowerCAmelCase_   (					UpperCamelCase__						:			List[Any]			):






 """simple docstring"""







 return DownloadCommand(args.model					, args.cache_dir					, args.force					, args.trust_remote_code			)





class  lowerCamelCase__    (		_a     ):
      @staticmethod
      def SCREAMING_SNAKE_CASE_						(		A_						:						ArgumentParser				):






       '''simple docstring'''


       __lowercase						=						parser.add_parser("""download"""				)
       download_parser.add_argument(
           """--cache-dir"""   ,							type=_lowercase   ,							default=_lowercase   ,							help="""Path to location to store the models"""				)
       download_parser.add_argument(
           """--force"""   ,							action="""store_true"""   ,							help="""Force the model to be download even if already in cache-dir"""				)
       download_parser.add_argument(
           """--trust-remote-code"""   ,							action="""store_true"""   ,							help="""Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you\'ve reviewed the code as it will execute on your local machine"""   ,							)
       download_parser.add_argument("""model"""   ,							type=_lowercase   ,							help="""Name of the model to download"""				)
       download_parser.set_defaults(func=_lowercase				)
      def __init__(		self						:						Dict   ,							A_						:						str   ,							A_						:						str   ,							A_						:						bool   ,							A_						:						bool				):






       '''simple docstring'''


       __lowercase						=						model
       __lowercase						=						cache
       __lowercase						=						force
       __lowercase						=						trust_remote_code






      def SCREAMING_SNAKE_CASE_						(		self						:						str				):






       '''simple docstring'''


       from ..models.auto import AutoModel, AutoTokenizer

       AutoModel.from_pretrained(
           self._model   ,							cache_dir=self._cache   ,							force_download=self._force   ,							trust_remote_code=self._trust_remote_code				)
       AutoTokenizer.from_pretrained(
           self._model   ,							cache_dir=self._cache   ,							force_download=self._force   ,							trust_remote_code=self._trust_remote_code				)






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



					'''simple docstring'''





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



					def     __snake_case						(	self     :						List[Any]      ,       _lowercase     :						Any      ,       _lowercase     :						int      ,       _lowercase     :						Optional[Any]      ,       _lowercase     :						Tuple)    ->							Tuple:
								A_									= BeitModel(config=_lowercase)
								model.to(_lowercase)
								model.eval()
								A_									= model(_lowercase)
								self.parent.assertEqual(result.last_hidden_state.shape      ,       (self.batch_size, self.seq_length, self.hidden_size))



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



					def     __snake_case						(	self     :						Optional[int]      ,       _lowercase     :						Tuple      ,       _lowercase     :						Optional[Any]      ,       _lowercase     :						str      ,       _lowercase     :						Optional[int])    ->							Any:
								A_									= self.type_sequence_label_size
								A_									= BeitForImageClassification(_lowercase)
								model.to(_lowercase)
								model.eval()
								A_									= model(_lowercase      ,       labels=_lowercase)
								self.parent.assertEqual(result.logits.shape      ,       (self.batch_size, self.type_sequence_label_size))

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

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



					def     __snake_case						(	self     :						Tuple      ,       _lowercase     :						List[str]      ,       _lowercase     :						Any      ,       _lowercase     :						List[str]      ,       _lowercase     :						Optional[int])    ->							Union[str, Any]:
								A_									= self.num_labels
								A_									= BeitForSemanticSegmentation(_lowercase)
								model.to(_lowercase)
								model.eval()
								A_									= model(_lowercase)
								self.parent.assertEqual(
								    result.logits.shape      ,       (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2))
								A_									= model(_lowercase      ,       labels=_lowercase)
								self.parent.assertEqual(
								    result.logits.shape      ,       (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2))



					def     __snake_case						(	self     :						Optional[int])    ->							Dict:
								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   __UpperCAmelCase				(     lowerCAmelCase			,lowerCAmelCase			,unittest.TestCase				):



					'''simple docstring'''





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

					_UpperCamelCase							=		False
					_UpperCamelCase							=		False
					_UpperCamelCase							=		False



					def     __snake_case						(	self     :						str)    ->							str:
								A_									= BeitModelTester(self)
								A_									= ConfigTester(self      ,       config_class=_lowercase      ,       has_text_modality=_lowercase      ,       hidden_size=37)



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



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



					def     __snake_case						(	self     :						List[Any])    ->							Optional[int]:
								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()

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



					def     __snake_case						(	self     :						Optional[Any])    ->							Optional[Any]:
								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
											A_									= model_class(_lowercase)
											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]      ,       _lowercase)



					def     __snake_case						(	self     :						List[str])    ->							str:
								A_									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowercase)



					def     __snake_case						(	self     :						List[Any])    ->							Optional[int]:
								A_									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_lm(*_lowercase)



					def     __snake_case						(	self     :						int)    ->							List[str]:
								A_									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_lowercase)



					def     __snake_case						(	self     :						Union[str, Any])    ->							Optional[int]:
								A_									= self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*_lowercase)



					def     __snake_case						(	self     :						int)    ->							str:
								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(_lowercase), BeitForMaskedImageModeling]:
														continue

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



					def     __snake_case						(	self     :						List[Any])    ->							Optional[int]:
								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(_lowercase), BeitForMaskedImageModeling]
											    or not model_class.supports_gradient_checkpointing
											):
														continue

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



					def     __snake_case						(	self     :						int)    ->							int:
								A_		, A_									= self.model_tester.prepare_config_and_inputs_for_common()

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





def 			lowerCamelCase(							)		->		str:
			A_									= Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'     )
			return image






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



					'''simple docstring'''





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



					@slow
					def     __snake_case						(	self     :						Any)    ->							Optional[Any]:
								A_									= BeitForMaskedImageModeling.from_pretrained('microsoft/beit-base-patch16-224-pt22k').to(_lowercase)

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

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

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

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

								A_									= torch.tensor(
								    [[-3.24_37, 0.50_72, -13.91_74], [-3.24_56, 0.49_48, -13.94_01], [-3.20_33, 0.51_21, -13.85_50]]).to(_lowercase)

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



					@slow
					def     __snake_case						(	self     :						List[str])    ->							Any:
								A_									= BeitForImageClassification.from_pretrained('microsoft/beit-base-patch16-224').to(_lowercase)

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

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

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

								A_									= torch.tensor([-1.23_85, -1.09_87, -1.01_08]).to(_lowercase)

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

								A_									= 281
								self.assertEqual(logits.argmax(-1).item()      ,       _lowercase)



					@slow
					def     __snake_case						(	self     :						Optional[int])    ->							List[Any]:
								A_									= BeitForImageClassification.from_pretrained('microsoft/beit-large-patch16-224-pt22k-ft22k').to(
								    _lowercase)

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

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

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

								A_									= torch.tensor([1.68_81, -0.27_87, 0.59_01]).to(_lowercase)

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

								A_									= 2_396
								self.assertEqual(logits.argmax(-1).item()      ,       _lowercase)



					@slow
					def     __snake_case						(	self     :						Tuple)    ->							Any:
								A_									= BeitForSemanticSegmentation.from_pretrained('microsoft/beit-base-finetuned-ade-640-640')
								A_									= model.to(_lowercase)

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

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

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

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

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

								if is_pillow_less_than_a:
											A_									= torch.tensor(
											    [
											        [[-4.92_25, -2.39_54, -3.05_22], [-2.88_22, -1.00_46, -1.75_61], [-2.95_49, -1.32_28, -2.13_47]],
											        [[-5.81_68, -3.41_29, -4.07_78], [-3.86_51, -2.22_14, -3.02_77], [-3.83_56, -2.46_43, -3.35_35]],
											        [[-0.00_78, 3.99_52, 4.07_54], [2.98_56, 4.69_44, 5.00_35], [3.24_13, 4.78_13, 4.99_69]],
											    ]      ,       device=_lowercase      ,       )
								else:
											A_									= torch.tensor(
											    [
											        [[-4.89_60, -2.36_88, -3.03_55], [-2.84_78, -0.98_36, -1.74_18], [-2.94_49, -1.33_32, -2.14_56]],
											        [[-5.80_81, -3.41_24, -4.10_06], [-3.85_61, -2.20_81, -3.03_23], [-3.83_65, -2.46_01, -3.36_69]],
											        [[-0.03_09, 3.98_68, 4.05_40], [2.96_40, 4.68_77, 4.99_76], [3.20_81, 4.76_90, 4.99_42]],
											    ]      ,       device=_lowercase      ,       )

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



					@slow
					def     __snake_case						(	self     :						List[str])    ->							Tuple:
								A_									= BeitForSemanticSegmentation.from_pretrained('microsoft/beit-base-finetuned-ade-640-640')
								A_									= model.to(_lowercase)

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

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

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

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

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

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




