





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



      def 						lowerCAmelCase__     (						self:    Union[str, Any]		,	_lowerCAmelCase:    Tuple		,	_lowerCAmelCase:    int		,	_lowerCAmelCase:    Union[str, Any]		,	_lowerCAmelCase:    Union[str, Any]							)    ->     int:
         '''simple docstring'''

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



      def 						lowerCAmelCase__     (						self:    List[str]		,	_lowerCAmelCase:    Union[str, Any]		,	_lowerCAmelCase:    Union[str, Any]		,	_lowerCAmelCase:    Union[str, Any]		,	_lowerCAmelCase:    Dict							)    ->     Dict:
         '''simple docstring'''

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



      def 						lowerCAmelCase__     (						self:    Optional[Any]		,	_lowerCAmelCase:    int		,	_lowerCAmelCase:    Optional[Any]		,	_lowerCAmelCase:    List[str]		,	_lowerCAmelCase:    Optional[Any]							)    ->     Optional[Any]:
         '''simple docstring'''

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

         # test greyscale images
         UpperCAmelCase_           =1
         UpperCAmelCase_           =BeitForImageClassification(_lowerCAmelCase							)
         model.to(_lowerCAmelCase							)
         model.eval()

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



      def 						lowerCAmelCase__     (						self:    List[str]		,	_lowerCAmelCase:    str		,	_lowerCAmelCase:    int		,	_lowerCAmelCase:    Any		,	_lowerCAmelCase:    int							)    ->     str:
         '''simple docstring'''

         UpperCAmelCase_           =self.num_labels
         UpperCAmelCase_           =BeitForSemanticSegmentation(_lowerCAmelCase							)
         model.to(_lowerCAmelCase							)
         model.eval()
         UpperCAmelCase_           =model(_lowerCAmelCase							)
         self.parent.assertEqual(
             result.logits.shape		,	(self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)							)
         UpperCAmelCase_           =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 						lowerCAmelCase__     (						self:    Any							)    ->     Union[str, Any]:
         '''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							(						__lowercase		,   __lowercase		,   unittest.TestCase    ):
      _snake_case				  =(
          (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
          if is_torch_available()
          else ()
      )
      _snake_case				  =(
          {
              '''feature-extraction''': BeitModel,
              '''image-classification''': BeitForImageClassification,
              '''image-segmentation''': BeitForSemanticSegmentation,
          }
          if is_torch_available()
          else {}
      )

      _snake_case				  =False
      _snake_case				  =False
      _snake_case				  =False



      def 						lowerCAmelCase__     (						self:    Union[str, Any]							)    ->     List[str]:
         '''simple docstring'''

         UpperCAmelCase_           =BeitModelTester(self							)
         UpperCAmelCase_           =ConfigTester(self		,	config_class=_lowerCAmelCase		,	has_text_modality=_lowerCAmelCase		,	hidden_size=37							)



      def 						lowerCAmelCase__     (						self:    List[Any]							)    ->     int:
         '''simple docstring'''

         self.config_tester.run_common_tests()



      @unittest.skip(reason="BEiT does not use inputs_embeds"							)
      def 						lowerCAmelCase__     (						self:    Union[str, Any]							)    ->     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 						lowerCAmelCase__     (						self:    List[Any]							)    ->     Any:
         '''simple docstring'''

         pass



      def 						lowerCAmelCase__     (						self:    str							)    ->     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(_lowerCAmelCase							)
            self.assertIsInstance(model.get_input_embeddings()		,	(nn.Module)							)
            UpperCAmelCase_           =model.get_output_embeddings()
            self.assertTrue(x is None or isinstance(_lowerCAmelCase		,	nn.Linear							)							)



      def 						lowerCAmelCase__     (						self:    str							)    ->     List[str]:
         '''simple docstring'''

         UpperCAmelCase_    ,							UpperCAmelCase_           =self.model_tester.prepare_config_and_inputs_for_common()

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



      def 						lowerCAmelCase__     (						self:    Any							)    ->     int:
         '''simple docstring'''

         UpperCAmelCase_           =self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*_lowerCAmelCase							)



      def 						lowerCAmelCase__     (						self:    str							)    ->     Tuple:
         '''simple docstring'''

         UpperCAmelCase_           =self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_masked_lm(*_lowerCAmelCase							)



      def 						lowerCAmelCase__     (						self:    List[Any]							)    ->     Any:
         '''simple docstring'''

         UpperCAmelCase_           =self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase							)



      def 						lowerCAmelCase__     (						self:    Union[str, Any]							)    ->     Optional[int]:
         '''simple docstring'''

         UpperCAmelCase_           =self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_semantic_segmentation(*_lowerCAmelCase							)



      def 						lowerCAmelCase__     (						self:    Optional[int]							)    ->     Union[str, Any]:
         '''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(_lowerCAmelCase							), BeitForMaskedImageModeling]:
               continue

            UpperCAmelCase_           =model_class(_lowerCAmelCase							)
            model.to(_lowerCAmelCase							)
            model.train()
            UpperCAmelCase_           =self._prepare_for_class(_lowerCAmelCase		,	_lowerCAmelCase		,	return_labels=_lowerCAmelCase							)
            UpperCAmelCase_           =model(**_lowerCAmelCase							).loss
            loss.backward()



      def 						lowerCAmelCase__     (						self:    List[Any]							)    ->     Any:
         '''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(_lowerCAmelCase							), BeitForMaskedImageModeling]
                or not model_class.supports_gradient_checkpointing
            ):
               continue

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



      def 						lowerCAmelCase__     (						self:    Tuple							)    ->     Dict:
         '''simple docstring'''

         UpperCAmelCase_    ,							UpperCAmelCase_           =self.model_tester.prepare_config_and_inputs_for_common()

         UpperCAmelCase_           =_config_zero_init(_lowerCAmelCase							)
         for model_class in self.all_model_classes:
            UpperCAmelCase_           =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 						lowerCAmelCase__     (						self:    Optional[Any]							)    ->     List[Any]:
         '''simple docstring'''

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




def      a__			(       ):






   '''simple docstring'''






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





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



      @cached_property
      def 						lowerCAmelCase__     (						self:    Union[str, Any]							)    ->     List[Any]:
         '''simple docstring'''

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



      @slow
      def 						lowerCAmelCase__     (						self:    Union[str, Any]							)    ->     int:
         '''simple docstring'''

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

         UpperCAmelCase_           =self.default_image_processor
         UpperCAmelCase_           =prepare_img()
         UpperCAmelCase_           =image_processor(images=_lowerCAmelCase		,	return_tensors="pt"							).pixel_values.to(_lowerCAmelCase							)

         # prepare bool_masked_pos
         UpperCAmelCase_           =torch.ones((1, 196)		,	dtype=torch.bool							).to(_lowerCAmelCase							)

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

         # verify the logits
         UpperCAmelCase_           =torch.Size((1, 196, 8192)							)
         self.assertEqual(logits.shape		,	_lowerCAmelCase							)

         UpperCAmelCase_           =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(_lowerCAmelCase							)

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



      @slow
      def 						lowerCAmelCase__     (						self:    Optional[int]							)    ->     Any:
         '''simple docstring'''

         UpperCAmelCase_           =BeitForImageClassification.from_pretrained("microsoft/beit-base-patch16-224"							).to(_lowerCAmelCase							)

         UpperCAmelCase_           =self.default_image_processor
         UpperCAmelCase_           =prepare_img()
         UpperCAmelCase_           =image_processor(images=_lowerCAmelCase		,	return_tensors="pt"							).to(_lowerCAmelCase							)

         # forward pass
         with torch.no_grad():
            UpperCAmelCase_           =model(**_lowerCAmelCase							)
         UpperCAmelCase_           =outputs.logits

         # verify the logits
         UpperCAmelCase_           =torch.Size((1, 1000)							)
         self.assertEqual(logits.shape		,	_lowerCAmelCase							)

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

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

         UpperCAmelCase_           =281
         self.assertEqual(logits.argmax(-1							).item()		,	_lowerCAmelCase							)



      @slow
      def 						lowerCAmelCase__     (						self:    str							)    ->     Optional[int]:
         '''simple docstring'''

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

         UpperCAmelCase_           =self.default_image_processor
         UpperCAmelCase_           =prepare_img()
         UpperCAmelCase_           =image_processor(images=_lowerCAmelCase		,	return_tensors="pt"							).to(_lowerCAmelCase							)

         # forward pass
         with torch.no_grad():
            UpperCAmelCase_           =model(**_lowerCAmelCase							)
         UpperCAmelCase_           =outputs.logits

         # verify the logits
         UpperCAmelCase_           =torch.Size((1, 2_1841)							)
         self.assertEqual(logits.shape		,	_lowerCAmelCase							)

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

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

         UpperCAmelCase_           =2396
         self.assertEqual(logits.argmax(-1							).item()		,	_lowerCAmelCase							)



      @slow
      def 						lowerCAmelCase__     (						self:    str							)    ->     str:
         '''simple docstring'''

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

         UpperCAmelCase_           =BeitImageProcessor(do_resize=_lowerCAmelCase		,	size=640		,	do_center_crop=_lowerCAmelCase							)

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

         # forward pass
         with torch.no_grad():
            UpperCAmelCase_           =model(**_lowerCAmelCase							)
         UpperCAmelCase_           =outputs.logits

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

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

         if is_pillow_less_than_a:
            UpperCAmelCase_           =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=_lowerCAmelCase		,	)
         else:
            UpperCAmelCase_           =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=_lowerCAmelCase		,	)

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






      @slow
      def 						lowerCAmelCase__     (						self:    int							)    ->     Union[str, Any]:
         '''simple docstring'''

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

         UpperCAmelCase_           =BeitImageProcessor(do_resize=_lowerCAmelCase		,	size=640		,	do_center_crop=_lowerCAmelCase							)

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

         # forward pass
         with torch.no_grad():
            UpperCAmelCase_           =model(**_lowerCAmelCase							)

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

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

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








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


lowerCamelCase		   =			logging.get_logger(__name__)

lowerCamelCase		   =			{
    'sayakpaul/vit-msn-base': 'https://huggingface.co/sayakpaul/vit-msn-base/resolve/main/config.json',
    # See all ViT MSN models at https://huggingface.co/models?filter=vit_msn
}




class A    (  UpperCamelCase_	):
      UpperCamelCase__				:    Union[str, Any] ='vit_msn'






      def __init__(   self		:	Union[str, Any]     ,  lowercase_		:	List[str]=768     ,  lowercase_		:	Optional[int]=12     ,  lowercase_		:	List[str]=12     ,  lowercase_		:	List[Any]=3072     ,  lowercase_		:	int="gelu"     ,  lowercase_		:	List[Any]=0.0     ,  lowercase_		:	Optional[int]=0.0     ,  lowercase_		:	Dict=0.02     ,  lowercase_		:	Any=1E-06     ,  lowercase_		:	Union[str, Any]=224     ,  lowercase_		:	Optional[int]=16     ,  lowercase_		:	List[Any]=3     ,  lowercase_		:	Any=True     ,  **lowercase_		:	Tuple     ,  )   ->		Dict:
             """simple docstring"""




             super().__init__(**lowercase_					)

             _lowerCamelCase			:						Dict            =hidden_size
             _lowerCamelCase			:						Any            =num_hidden_layers
             _lowerCamelCase			:						Union[str, Any]            =num_attention_heads
             _lowerCamelCase			:						List[Any]            =intermediate_size
             _lowerCamelCase			:						Tuple            =hidden_act
             _lowerCamelCase			:						Any            =hidden_dropout_prob
             _lowerCamelCase			:						Dict            =attention_probs_dropout_prob
             _lowerCamelCase			:						Any            =initializer_range
             _lowerCamelCase			:						List[Any]            =layer_norm_eps
             _lowerCamelCase			:						Optional[int]            =image_size
             _lowerCamelCase			:						Optional[int]            =patch_size
             _lowerCamelCase			:						List[Any]            =num_channels
             _lowerCamelCase			:						Optional[Any]            =qkv_bias


