






import unittest

import numpy as np

from transformers import BertConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
	from transformers.models.bert.modeling_flax_bert import (
	    FlaxBertForMaskedLM,
	    FlaxBertForMultipleChoice,
	    FlaxBertForNextSentencePrediction,
	    FlaxBertForPreTraining,
	    FlaxBertForQuestionAnswering,
	    FlaxBertForSequenceClassification,
	    FlaxBertForTokenClassification,
	    FlaxBertModel,
	)




class  UpperCamelCase_      (			unittest.TestCase				):



	'''simple docstring'''




	def __init__(       self       ,			a       ,			a=13       ,			a=7       ,			a=True       ,			a=True       ,			a=True       ,			a=True       ,			a=99       ,			a=32       ,			a=5       ,			a=4       ,			a=37       ,			a="gelu"       ,			a=0.1       ,			a=0.1       ,			a=5_12       ,			a=16       ,			a=2       ,			a=0.02       ,			a=4       ,			)       ->    Tuple:
								snake_case_				=							parent
								snake_case_				=							batch_size
								snake_case_				=							seq_length
								snake_case_				=							is_training
								snake_case_				=							use_attention_mask
								snake_case_				=							use_token_type_ids
								snake_case_				=							use_labels
								snake_case_				=							vocab_size
								snake_case_				=							hidden_size
								snake_case_				=							num_hidden_layers
								snake_case_				=							num_attention_heads
								snake_case_				=							intermediate_size
								snake_case_				=							hidden_act
								snake_case_				=							hidden_dropout_prob
								snake_case_				=							attention_probs_dropout_prob
								snake_case_				=							max_position_embeddings
								snake_case_				=							type_vocab_size
								snake_case_				=							type_sequence_label_size
								snake_case_				=							initializer_range
								snake_case_				=							num_choices




	def 							_UpperCamelCase			(       self					)       ->    Any:
								snake_case_				=							ids_tensor([self.batch_size, self.seq_length]       ,			self.vocab_size					)

								snake_case_				=							None
								if self.use_attention_mask:
															snake_case_				=							random_attention_mask([self.batch_size, self.seq_length]					)

								snake_case_				=							None
								if self.use_token_type_ids:
															snake_case_				=							ids_tensor([self.batch_size, self.seq_length]       ,			self.type_vocab_size					)

								snake_case_				=							BertConfig(
								    vocab_size=self.vocab_size       ,			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       ,			max_position_embeddings=self.max_position_embeddings       ,			type_vocab_size=self.type_vocab_size       ,			is_decoder=_snake_case       ,			initializer_range=self.initializer_range       ,			)

								return config, input_ids, token_type_ids, attention_mask




	def 							_UpperCamelCase			(       self					)       ->    Union[str, Any]:
								snake_case_				=							self.prepare_config_and_inputs()
								snake_case_			,		snake_case_			,		snake_case_			,		snake_case_				=							config_and_inputs
								snake_case_				=							{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': attention_mask}
								return config, inputs_dict






	def 							_UpperCamelCase			(       self					)       ->    Dict:
								snake_case_				=							self.prepare_config_and_inputs()
								snake_case_			,		snake_case_			,		snake_case_			,		snake_case_				=							config_and_inputs

								snake_case_				=							True
								snake_case_				=							floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
								snake_case_				=							ids_tensor([self.batch_size, self.seq_length]       ,			vocab_size=2					)

								return (
								    config,
								    input_ids,
								    attention_mask,
								    encoder_hidden_states,
								    encoder_attention_mask,
								)






@require_flax
class  UpperCamelCase_      (			snake_case_       ,					unittest.TestCase				):



	'''simple docstring'''




	lowerCAmelCase													= True

	lowerCAmelCase													= (
	    (
	        FlaxBertModel,
	        FlaxBertForPreTraining,
	        FlaxBertForMaskedLM,
	        FlaxBertForMultipleChoice,
	        FlaxBertForQuestionAnswering,
	        FlaxBertForNextSentencePrediction,
	        FlaxBertForSequenceClassification,
	        FlaxBertForTokenClassification,
	        FlaxBertForQuestionAnswering,
	    )
	    if is_flax_available()
	    else ()
	)




	def 							_UpperCamelCase			(       self					)       ->    Tuple:
								snake_case_				=							FlaxBertModelTester(self					)






	@slow
	def 							_UpperCamelCase			(       self					)       ->    List[Any]:
								snake_case_				=							FlaxBertModel.from_pretrained('bert-base-cased'					)
								snake_case_				=							model(np.ones((1, 1)					)					)
								self.assertIsNotNone(_snake_case					)







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


A     :	List[str]    = logging.get_logger(__name__)

A     :	Optional[int]    = {
    'facebook/levit-128S': 'https://huggingface.co/facebook/levit-128S/resolve/main/config.json',
    # See all LeViT models at https://huggingface.co/models?filter=levit
}







class 			__A( a			):
				snake_case_						   =    '''levit'''




				def __init__(     self		,     _snake_case=224		,     _snake_case=3		,     _snake_case=3		,     _snake_case=2		,     _snake_case=1		,     _snake_case=16		,     _snake_case=[128, 256, 384]		,     _snake_case=[4, 8, 12]		,     _snake_case=[4, 4, 4]		,     _snake_case=[16, 16, 16]		,     _snake_case=0		,     _snake_case=[2, 2, 2]		,     _snake_case=[2, 2, 2]		,     _snake_case=0.02		,     **_snake_case		,     )    ->      Optional[Any]:


								'''simple docstring'''




								super().__init__(**_snake_case				)
								__a										=    image_size
								__a										=    num_channels
								__a										=    kernel_size
								__a										=    stride
								__a										=    padding
								__a										=    hidden_sizes
								__a										=    num_attention_heads
								__a										=    depths
								__a										=    key_dim
								__a										=    drop_path_rate
								__a										=    patch_size
								__a										=    attention_ratio
								__a										=    mlp_ratio
								__a										=    initializer_range
								__a										=    [
								    ['''Subsample''', key_dim[0], hidden_sizes[0] // key_dim[0], 4, 2, 2],
								    ['''Subsample''', key_dim[0], hidden_sizes[1] // key_dim[0], 4, 2, 2],
								]







class 			__A( a			):
				snake_case_						   =    version.parse('''1.11'''			)




				@property
				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      Mapping[str, Mapping[int, str]]:


								'''simple docstring'''




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




				@property
				def 				SCREAMING_SNAKE_CASE_		(     self				)    ->      float:


								'''simple docstring'''




								return 1E-4