






'''simple docstring'''







import unittest

from transformers import DebertaVaTokenizer, DebertaVaTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


_A	:			List[str]         =get_tests_dir('''fixtures/spiece.model''')

@require_sentencepiece
@require_tokenizers
class _lowercase	(				lowercase_				,      unittest.TestCase		):
							a				      =       DebertaVaTokenizer
							a				      =       DebertaVaTokenizerFast
							a				      =       True
							a				      =       True




							def 		lowerCamelCase_				(							self:				Tuple     ):
														super().setUp()

														# We have a SentencePiece fixture for testing
														lowerCamelCase__					:	List[Any]         =       DebertaVaTokenizer(UpperCamelCase__			,							unk_token="""<unk>"""     )
														tokenizer.save_pretrained(self.tmpdirname     )




							def 		lowerCamelCase_				(							self:				Union[str, Any]			,							UpperCamelCase__:				str     ):
														lowerCamelCase__					:	str         =       """this is a test"""
														lowerCamelCase__					:	Tuple         =       """this is a test"""
														return input_text, output_text




							def 		lowerCamelCase_				(							self:				Optional[int]     ):
														lowerCamelCase__					:	str         =       """<pad>"""
														lowerCamelCase__					:	Dict         =       0

														self.assertEqual(self.get_tokenizer()._convert_token_to_id(UpperCamelCase__     )			,							UpperCamelCase__     )
														self.assertEqual(self.get_tokenizer()._convert_id_to_token(UpperCamelCase__     )			,							UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				Dict     ):
														lowerCamelCase__					:	Any         =       list(self.get_tokenizer().get_vocab().keys()     )
														self.assertEqual(vocab_keys[0]			,							"""<pad>"""     )
														self.assertEqual(vocab_keys[1]			,							"""<unk>"""     )
														self.assertEqual(vocab_keys[-1]			,							"""[PAD]"""     )
														self.assertEqual(len(UpperCamelCase__     )			,							30_001     )




							def 		lowerCamelCase_				(							self:				int     ):
														self.assertEqual(self.get_tokenizer().vocab_size			,							30_000     )




							def 		lowerCamelCase_				(							self:				Optional[Any]     ):
														lowerCamelCase__					:	List[str]         =       """ \tHeLLo!how  \n Are yoU?  """
														lowerCamelCase__					:	List[str]         =       ["""▁hello""", """!""", """how""", """▁are""", """▁you""", """?"""]
														# fmt: on

														lowerCamelCase__					:	Union[str, Any]         =       DebertaVaTokenizer(UpperCamelCase__			,							do_lower_case=UpperCamelCase__     )
														lowerCamelCase__					:	Tuple         =       tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )

														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	Dict         =       DebertaVaTokenizerFast(UpperCamelCase__			,							do_lower_case=UpperCamelCase__     )
														lowerCamelCase__					:	List[str]         =       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )

														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )




							@unittest.skip("""There is an inconsistency between slow and fast tokenizer due to a bug in the fast one."""     )
							def 		lowerCamelCase_				(							self:				List[Any]     ):
														pass




							@unittest.skip("""There is an inconsistency between slow and fast tokenizer due to a bug in the fast one."""     )
							def 		lowerCamelCase_				(							self:				List[str]     ):
														pass




							def 		lowerCamelCase_				(							self:				Optional[int]     ):
														lowerCamelCase__					:	Optional[int]         =       """I was born in 92000, and this is falsé."""
														lowerCamelCase__					:	str         =       ["""▁""", """<unk>""", """▁was""", """▁born""", """▁in""", """▁9""", """2000""", """▁""", """,""", """▁and""", """▁this""", """▁is""", """▁fal""", """s""", """<unk>""", """▁""", """.""", ]
														# fmt: on

														lowerCamelCase__					:	Any         =       DebertaVaTokenizer(UpperCamelCase__			,							split_by_punct=UpperCamelCase__     )
														lowerCamelCase__					:	str         =       tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )

														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	List[Any]         =       DebertaVaTokenizerFast(UpperCamelCase__			,							split_by_punct=UpperCamelCase__     )
														lowerCamelCase__					:	Dict         =       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )

														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				int     ):
														lowerCamelCase__					:	Dict         =       """I was born in 92000, and this is falsé."""
														lowerCamelCase__					:	Union[str, Any]         =       ["""▁i""", """▁was""", """▁born""", """▁in""", """▁9""", """2000""", """▁""", """,""", """▁and""", """▁this""", """▁is""", """▁fal""", """s""", """<unk>""", """▁""", """.""", ]
														# fmt: on

														lowerCamelCase__					:	str         =       DebertaVaTokenizer(UpperCamelCase__			,							do_lower_case=UpperCamelCase__			,							split_by_punct=UpperCamelCase__     )
														lowerCamelCase__					:	Optional[int]         =       tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	Any         =       DebertaVaTokenizerFast(UpperCamelCase__			,							do_lower_case=UpperCamelCase__			,							split_by_punct=UpperCamelCase__     )
														lowerCamelCase__					:	int         =       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				Optional[Any]     ):
														lowerCamelCase__					:	Optional[Any]         =       """I was born in 92000, and this is falsé."""
														lowerCamelCase__					:	Any         =       ["""▁i""", """▁was""", """▁born""", """▁in""", """▁9""", """2000""", """,""", """▁and""", """▁this""", """▁is""", """▁fal""", """s""", """<unk>""", """.""", ]
														# fmt: on

														lowerCamelCase__					:	List[str]         =       DebertaVaTokenizer(UpperCamelCase__			,							do_lower_case=UpperCamelCase__			,							split_by_punct=UpperCamelCase__     )
														lowerCamelCase__					:	Any         =       tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )

														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	List[Any]         =       DebertaVaTokenizerFast(UpperCamelCase__			,							do_lower_case=UpperCamelCase__			,							split_by_punct=UpperCamelCase__     )
														lowerCamelCase__					:	Dict         =       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )

														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				Union[str, Any]     ):
														lowerCamelCase__					:	Optional[Any]         =       """I was born in 92000, and this is falsé."""
														lowerCamelCase__					:	Dict         =       ["""▁""", """<unk>""", """▁was""", """▁born""", """▁in""", """▁9""", """2000""", """▁""", """,""", """▁and""", """▁this""", """▁is""", """▁fal""", """s""", """<unk>""", """▁""", """.""", ]
														# fmt: on

														lowerCamelCase__					:	Dict         =       DebertaVaTokenizer(UpperCamelCase__			,							do_lower_case=UpperCamelCase__			,							split_by_punct=UpperCamelCase__     )
														lowerCamelCase__					:	int         =       tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )

														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	str         =       DebertaVaTokenizerFast(UpperCamelCase__			,							do_lower_case=UpperCamelCase__			,							split_by_punct=UpperCamelCase__     )
														lowerCamelCase__					:	str         =       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )

														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				Union[str, Any]     ):
														lowerCamelCase__					:	Any         =       """ \tHeLLo!how  \n Are yoU?  """
														lowerCamelCase__					:	List[str]         =       ["""▁""", """<unk>""", """e""", """<unk>""", """o""", """!""", """how""", """▁""", """<unk>""", """re""", """▁yo""", """<unk>""", """?"""]
														# fmt: on

														lowerCamelCase__					:	Any         =       DebertaVaTokenizer(UpperCamelCase__			,							do_lower_case=UpperCamelCase__			,							split_by_punct=UpperCamelCase__     )
														lowerCamelCase__					:	int         =       tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )

														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	str         =       DebertaVaTokenizerFast(UpperCamelCase__			,							do_lower_case=UpperCamelCase__			,							split_by_punct=UpperCamelCase__     )
														lowerCamelCase__					:	int         =       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )

														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				Union[str, Any]     ):
														lowerCamelCase__					:	Any         =       self.get_tokenizer()
														lowerCamelCase__					:	List[str]         =       self.get_rust_tokenizer()

														lowerCamelCase__					:	List[str]         =       """I was born in 92000, and this is falsé."""

														lowerCamelCase__					:	Tuple         =       tokenizer.convert_ids_to_tokens(tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )
														lowerCamelCase__					:	Optional[int]         =       rust_tokenizer.convert_ids_to_tokens(rust_tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	Union[str, Any]         =       tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )
														lowerCamelCase__					:	Dict         =       rust_tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	Optional[Any]         =       self.get_rust_tokenizer()
														lowerCamelCase__					:	str         =       tokenizer.encode(UpperCamelCase__     )
														lowerCamelCase__					:	int         =       rust_tokenizer.encode(UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				int     ):
														lowerCamelCase__					:	Any         =       """This is a test"""
														lowerCamelCase__					:	Optional[int]         =       [13, 1, 4_398, 25, 21, 1_289]
														lowerCamelCase__					:	Tuple         =       ["""▁""", """T""", """his""", """▁is""", """▁a""", """▁test"""]
														lowerCamelCase__					:	Tuple         =       ["""▁""", """<unk>""", """his""", """▁is""", """▁a""", """▁test"""]

														lowerCamelCase__					:	Tuple         =       DebertaVaTokenizer(UpperCamelCase__			,							keep_accents=UpperCamelCase__     )
														lowerCamelCase__					:	int         =       DebertaVaTokenizerFast(UpperCamelCase__			,							keep_accents=UpperCamelCase__     )

														lowerCamelCase__					:	Tuple         =       tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )
														lowerCamelCase__					:	List[Any]         =       tokenizer.tokenize(UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )
														lowerCamelCase__					:	Dict         =       tokenizer.convert_ids_to_tokens(UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	Any         =       rust_tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )
														lowerCamelCase__					:	Optional[Any]         =       rust_tokenizer.tokenize(UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )
														lowerCamelCase__					:	str         =       rust_tokenizer.convert_ids_to_tokens(UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )

														# fmt: off
														lowerCamelCase__					:	Tuple         =       """I was born in 92000, and this is falsé."""
														lowerCamelCase__					:	List[str]         =       [13, 1, 23, 386, 19, 561, 3_050, 15, 17, 48, 25, 8_256, 18, 1, 9]
														lowerCamelCase__					:	Tuple         =       ["""▁""", """I""", """▁was""", """▁born""", """▁in""", """▁9""", """2000""", """,""", """▁and""", """▁this""", """▁is""", """▁fal""", """s""", """é""", """.""", ]
														lowerCamelCase__					:	Optional[Any]         =       ["""▁""", """<unk>""", """▁was""", """▁born""", """▁in""", """▁9""", """2000""", """,""", """▁and""", """▁this""", """▁is""", """▁fal""", """s""", """<unk>""", """.""", ]
														# fmt: on

														lowerCamelCase__					:	List[str]         =       tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )
														lowerCamelCase__					:	Any         =       tokenizer.tokenize(UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )
														lowerCamelCase__					:	Any         =       tokenizer.convert_ids_to_tokens(UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )

														lowerCamelCase__					:	Optional[Any]         =       rust_tokenizer.encode(UpperCamelCase__			,							add_special_tokens=UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )
														lowerCamelCase__					:	List[Any]         =       rust_tokenizer.tokenize(UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )
														lowerCamelCase__					:	Optional[Any]         =       rust_tokenizer.convert_ids_to_tokens(UpperCamelCase__     )
														self.assertListEqual(UpperCamelCase__			,							UpperCamelCase__     )




							def 		lowerCamelCase_				(							self:				int     ):
														lowerCamelCase__					:	Tuple         =       DebertaVaTokenizer(UpperCamelCase__     )

														lowerCamelCase__					:	List[Any]         =       tokenizer.encode("""sequence builders"""     )
														lowerCamelCase__					:	Tuple         =       tokenizer.encode("""multi-sequence build"""     )

														lowerCamelCase__					:	Union[str, Any]         =       tokenizer.build_inputs_with_special_tokens(UpperCamelCase__     )
														lowerCamelCase__					:	Union[str, Any]         =       tokenizer.build_inputs_with_special_tokens(UpperCamelCase__			,							UpperCamelCase__     )

														self.assertEqual([tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]			,							UpperCamelCase__     )
														self.assertEqual(
														    [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + text_a + [tokenizer.sep_token_id]			,							UpperCamelCase__			,							)




							@slow
							def 		lowerCamelCase_				(							self:				int     ):
														lowerCamelCase__					:	Dict         =       {"""input_ids""": [[1, 39_867, 36, 19_390, 486, 27, 35_052, 81_436, 18, 60_685, 1_225, 7, 35_052, 81_436, 18, 9_367, 16_899, 18, 15_937, 53, 594, 773, 18, 16_287, 30_465, 36, 15_937, 6, 41_139, 38, 36_979, 60_763, 191, 6, 34_132, 99, 6, 50_538, 390, 43_230, 6, 34_132, 2_779, 20_850, 14, 699, 1_072, 1_194, 36, 382, 10_901, 53, 7, 699, 1_072, 2_084, 36, 20_422, 630, 53, 19, 105, 3_049, 1_896, 1_053, 16_899, 1_506, 11, 37_978, 4_243, 7, 1_237, 31_869, 200, 16_566, 654, 6, 35_052, 81_436, 7, 55_630, 13_593, 4, 2], [1, 26, 15_011, 13, 667, 8, 1_053, 18, 23_611, 1_237, 72_356, 12_820, 34, 104_134, 1_209, 35, 13_313, 6_627, 21, 202, 347, 7, 164, 2_399, 11, 46, 4_485, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 5, 1_232, 2_864, 15_785, 14_951, 105, 5, 8_581, 1_250, 4, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """token_type_ids""": [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
														# fmt: on

														self.tokenizer_integration_test_util(
														    expected_encoding=UpperCamelCase__			,							model_name="""microsoft/deberta-v2-xlarge"""			,							revision="""ad6e42c1532ddf3a15c39246b63f5559d558b670"""			,							)





'''simple docstring'''

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


lowerCamelCase							:   Tuple  						=	logging.get_logger(__name__)

lowerCamelCase							:   Dict  						=	{
    'microsoft/cvt-13': 'https://huggingface.co/microsoft/cvt-13/resolve/main/config.json',
    # See all Cvt models at https://huggingface.co/models?filter=cvt
}
class   __lowerCAmelCase						(lowercase_     ):





      '''simple docstring'''






      lowerCAmelCase__					:     Tuple  					=							"""cvt"""



      def __init__(self    :    int   ,						UpperCamelCase    :    List[Any]=3   ,						UpperCamelCase    :    int=[7, 3, 3]   ,						UpperCamelCase    :    str=[4, 2, 2]   ,						UpperCamelCase    :    Dict=[2, 1, 1]   ,						UpperCamelCase    :    Dict=[64, 192, 384]   ,						UpperCamelCase    :    Dict=[1, 3, 6]   ,						UpperCamelCase    :    Dict=[1, 2, 10]   ,						UpperCamelCase    :    Any=[4.0, 4.0, 4.0]   ,						UpperCamelCase    :    Optional[int]=[0.0, 0.0, 0.0]   ,						UpperCamelCase    :    Optional[int]=[0.0, 0.0, 0.0]   ,						UpperCamelCase    :    int=[0.0, 0.0, 0.1]   ,						UpperCamelCase    :    Any=[True, True, True]   ,						UpperCamelCase    :    int=[False, False, True]   ,						UpperCamelCase    :    Union[str, Any]=["dw_bn", "dw_bn", "dw_bn"]   ,						UpperCamelCase    :    Optional[int]=[3, 3, 3]   ,						UpperCamelCase    :    Tuple=[1, 1, 1]   ,						UpperCamelCase    :    Any=[2, 2, 2]   ,						UpperCamelCase    :    Dict=[1, 1, 1]   ,						UpperCamelCase    :    List[str]=[1, 1, 1]   ,						UpperCamelCase    :    str=0.02   ,						UpperCamelCase    :    int=1E-12   ,						**UpperCamelCase    :    Union[str, Any]   ,						):

             '''simple docstring'''







             super().__init__(**UpperCamelCase )
             lowercase__      			= num_channels
             lowercase__      			= patch_sizes
             lowercase__      			= patch_stride
             lowercase__      			= patch_padding
             lowercase__      			= embed_dim
             lowercase__      			= num_heads
             lowercase__      			= depth
             lowercase__      			= mlp_ratio
             lowercase__      			= attention_drop_rate
             lowercase__      			= drop_rate
             lowercase__      			= drop_path_rate
             lowercase__      			= qkv_bias
             lowercase__      			= cls_token
             lowercase__      			= qkv_projection_method
             lowercase__      			= kernel_qkv
             lowercase__      			= padding_kv
             lowercase__      			= stride_kv
             lowercase__      			= padding_q
             lowercase__      			= stride_q
             lowercase__      			= initializer_range
             lowercase__      			= layer_norm_eps




