






from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


lowerCamelCase : Optional[Any]						   =       logging.get_logger(__name__)

lowerCamelCase : Optional[Any]						   =       {
    '''microsoft/beit-base-patch16-224-pt22k''': (
        '''https://huggingface.co/microsoft/beit-base-patch16-224-pt22k/resolve/main/config.json'''
    ),
    # See all BEiT models at https://huggingface.co/models?filter=beit
}

class 		lowerCAmelCase     ( __a			):

					'''simple docstring'''

					_A						:			Dict									=      '''beit'''



					def __init__(  self				:	str		,     __a				:	int=8192		,     __a				:	Tuple=768		,     __a				:	Optional[Any]=12		,     __a				:	List[Any]=12		,     __a				:	Dict=3072		,     __a				:	int="gelu"		,     __a				:	str=0.0		,     __a				:	List[str]=0.0		,     __a				:	List[Any]=0.02		,     __a				:	List[str]=1E-12		,     __a				:	Tuple=224		,     __a				:	List[str]=16		,     __a				:	Optional[Any]=3		,     __a				:	Dict=False		,     __a				:	Union[str, Any]=False		,     __a				:	str=False		,     __a				:	Any=False		,     __a				:	Union[str, Any]=0.1		,     __a				:	List[str]=0.1		,     __a				:	Any=True		,     __a				:	int=[3, 5, 7, 11]		,     __a				:	str=[1, 2, 3, 6]		,     __a				:	int=True		,     __a				:	Tuple=0.4		,     __a				:	int=256		,     __a				:	int=1		,     __a				:	Optional[Any]=False		,     __a				:	Dict=255		,     **__a				:	int		,     )			->  List[Any]:


												"""simple docstring"""

												super().__init__(**__a							)

												__lowercase      :							Optional[int]				=     vocab_size
												__lowercase      :							List[Any]				=     hidden_size
												__lowercase      :							Union[str, Any]				=     num_hidden_layers
												__lowercase      :							int				=     num_attention_heads
												__lowercase      :							Union[str, Any]				=     intermediate_size
												__lowercase      :							int				=     hidden_act
												__lowercase      :							Optional[int]				=     hidden_dropout_prob
												__lowercase      :							Dict				=     attention_probs_dropout_prob
												__lowercase      :							Union[str, Any]				=     initializer_range
												__lowercase      :							Optional[int]				=     layer_norm_eps

												__lowercase      :							Dict				=     image_size
												__lowercase      :							Any				=     patch_size
												__lowercase      :							List[str]				=     num_channels
												__lowercase      :							Any				=     use_mask_token
												__lowercase      :							Optional[Any]				=     use_absolute_position_embeddings
												__lowercase      :							str				=     use_relative_position_bias
												__lowercase      :							List[Any]				=     use_shared_relative_position_bias
												__lowercase      :							Tuple				=     layer_scale_init_value
												__lowercase      :							int				=     drop_path_rate
												__lowercase      :							Optional[Any]				=     use_mean_pooling
												# decode head attributes (semantic segmentation)
												__lowercase      :							Optional[Any]				=     out_indices
												__lowercase      :							List[Any]				=     pool_scales
												# auxiliary head attributes (semantic segmentation)
												__lowercase      :							int				=     use_auxiliary_head
												__lowercase      :							Any				=     auxiliary_loss_weight
												__lowercase      :							Any				=     auxiliary_channels
												__lowercase      :							List[Any]				=     auxiliary_num_convs
												__lowercase      :							str				=     auxiliary_concat_input
												__lowercase      :							Optional[int]				=     semantic_loss_ignore_index







class 		lowerCAmelCase     ( __a			):

					'''simple docstring'''

					_A						:			int									=      version.parse('''1.11'''			)



					@property
					def       lowerCAmelCase				(  self				:	Optional[Any]							)			->  Mapping[str, Mapping[int, str]]:


												"""simple docstring"""

												return OrderedDict(
												    [
												        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
												    ]							)



					@property
					def       lowerCAmelCase				(  self				:	Tuple							)			->  float:


												"""simple docstring"""

												return 1E-4







def       snake_case_		(     lowerCAmelCase_       :						int       ,       lowerCAmelCase_       :						int      ):
							return int((input_a, input_a).count(1      ) != 0      )
def       snake_case_		(     ):
							assert or_gate(0       ,       0      ) == 0
							assert or_gate(0       ,       1      ) == 1
							assert or_gate(1       ,       0      ) == 1
							assert or_gate(1       ,       1      ) == 1


if __name__ == "__main__":
	print(or_gate(0, 1))
	print(or_gate(1, 0))
	print(or_gate(0, 0))
	print(or_gate(1, 1))