




"""simple docstring"""






import os
import pickle
import unittest

from transformers import AutoTokenizer
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.models.bert_japanese.tokenization_bert_japanese import (
    VOCAB_FILES_NAMES,
    BertJapaneseTokenizer,
    CharacterTokenizer,
    JumanppTokenizer,
    MecabTokenizer,
    SudachiTokenizer,
    WordpieceTokenizer,
)
from transformers.testing_utils import custom_tokenizers, require_jumanpp, require_sudachi

from ...test_tokenization_common import TokenizerTesterMixin






@custom_tokenizers
class lowerCAmelCase__			(  __lowercase,			unittest.TestCase		):






			'''simple docstring'''



			lowerCamelCase__   =    BertJapaneseTokenizer
			lowerCamelCase__   =    False
			lowerCamelCase__   =    True
			def       A_					(						self						):
							super().setUp()

							_lowerCamelCase  :    List[Any]					=					[
							    "[UNK]",
							    "[CLS]",
							    "[SEP]",
							    "こんにちは",
							    "こん",
							    "にちは",
							    "ばんは",
							    "##こん",
							    "##にちは",
							    "##ばんは",
							    "世界",
							    "##世界",
							    "、",
							    "##、",
							    "。",
							    "##。",
							]

							_lowerCamelCase  :    Tuple					=					os.path.join(self.tmpdirname						,   VOCAB_FILES_NAMES['vocab_file']						)
							with open(self.vocab_file						,   'w'						,   encoding='utf-8'						) as vocab_writer:
											vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]						)						)
			def       A_					(						self						,   lowercase						):
							_lowerCamelCase  :    Optional[int]					=					"こんにちは、世界。 \nこんばんは、世界。"
							_lowerCamelCase  :    Union[str, Any]					=					"こんにちは 、 世界 。 こんばんは 、 世界 。"
							return input_text, output_text
			def       A_					(						self						,   lowercase						):
							_lowerCamelCase  :    Dict					=					self.get_input_output_texts(lowercase						)
							_lowerCamelCase  :    str					=					tokenizer.encode(lowercase						,   add_special_tokens=lowercase						)
							_lowerCamelCase  :    Any					=					tokenizer.decode(lowercase						,   clean_up_tokenization_spaces=lowercase						)
							return text, ids
			def       A_					(						self						):
							pass  # TODO add if relevant
			def       A_					(						self						):
							pass  # TODO add if relevant
			def       A_					(						self						):
							pass  # TODO add if relevant
			def       A_					(						self						):
							_lowerCamelCase  :    List[str]					=					self.tokenizer_class(self.vocab_file						)

							_lowerCamelCase  :    Tuple					=					tokenizer.tokenize('こんにちは、世界。\nこんばんは、世界。'						)
							self.assertListEqual(lowercase						,   ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']						)
							self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase						)						,   [3, 12, 10, 14, 4, 9, 12, 10, 14]						)
			def       A_					(						self						):
							_lowerCamelCase  :    List[Any]					=					self.tokenizer_class(self.vocab_file						,   word_tokenizer_type='mecab'						)
							self.assertIsNotNone(lowercase						)

							_lowerCamelCase  :    Any					=					"こんにちは、世界。\nこんばんは、世界。"
							_lowerCamelCase  :    Any					=					tokenizer.tokenize(lowercase						)
							self.assertListEqual(lowercase						,   ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']						)
							self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase						)						,   [3, 12, 10, 14, 4, 9, 12, 10, 14]						)

							_lowerCamelCase  :    Union[str, Any]					=					os.path.join(self.tmpdirname						,   'tokenizer.bin'						)
							with open(lowercase						,   'wb'						) as handle:
											pickle.dump(lowercase						,   lowercase						)

							with open(lowercase						,   'rb'						) as handle:
											_lowerCamelCase  :    Union[str, Any]					=					pickle.load(lowercase						)

							_lowerCamelCase  :    Any					=					tokenizer_new.tokenize(lowercase						)

							self.assertListEqual(lowercase						,   lowercase						)
			def       A_					(						self						):
							_lowerCamelCase  :    List[Any]					=					MecabTokenizer(mecab_dic='ipadic'						)

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   ['アップルストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']						,   )
			def       A_					(						self						):
							try:
											_lowerCamelCase  :    int					=					MecabTokenizer(mecab_dic='unidic_lite'						)
							except ModuleNotFoundError:
											return

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']						,   )
			def       A_					(						self						):
							try:
											_lowerCamelCase  :    List[Any]					=					MecabTokenizer(mecab_dic='unidic'						)
							except ModuleNotFoundError:
											return

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']						,   )
			def       A_					(						self						):
							_lowerCamelCase  :    str					=					MecabTokenizer(do_lower_case=lowercase						,   mecab_dic='ipadic'						)

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   ['アップルストア', 'で', 'iphone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']						,   )
			def       A_					(						self						):
							try:
											_lowerCamelCase  :    Tuple					=					MecabTokenizer(
											    do_lower_case=lowercase						,   normalize_text=lowercase						,   mecab_option='-d /usr/local/lib/mecab/dic/jumandic'						)
							except RuntimeError:
											# if dict doesn't exist in the system, previous code raises this error.
											return

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   ['ｱｯﾌﾟﾙストア', 'で', 'iPhone', '８', 'が', '発売', 'さ', 'れた', '\u3000', '。']						,   )
			def       A_					(						self						):
							_lowerCamelCase  :    Dict					=					MecabTokenizer(normalize_text=lowercase						,   mecab_dic='ipadic'						)

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   ['ｱｯﾌﾟﾙストア', 'で', 'iPhone', '８', 'が', '発売', 'さ', 'れ', 'た', '　', '。']						,   )
			@require_sudachi
			def       A_					(						self						):
							_lowerCamelCase  :    List[Any]					=					self.tokenizer_class(self.vocab_file						,   word_tokenizer_type='sudachi'						)
							self.assertIsNotNone(lowercase						)

							_lowerCamelCase  :    str					=					"こんにちは、世界。\nこんばんは、世界。"
							_lowerCamelCase  :    Tuple					=					tokenizer.tokenize(lowercase						)
							self.assertListEqual(lowercase						,   ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']						)
							self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase						)						,   [3, 12, 10, 14, 4, 9, 12, 10, 14]						)

							_lowerCamelCase  :    Optional[Any]					=					os.path.join(self.tmpdirname						,   'tokenizer.bin'						)
							with open(lowercase						,   'wb'						) as handle:
											pickle.dump(lowercase						,   lowercase						)

							with open(lowercase						,   'rb'						) as handle:
											_lowerCamelCase  :    Optional[int]					=					pickle.load(lowercase						)

							_lowerCamelCase  :    str					=					tokenizer_new.tokenize(lowercase						)

							self.assertListEqual(lowercase						,   lowercase						)
			@require_sudachi
			def       A_					(						self						):
							_lowerCamelCase  :    Any					=					SudachiTokenizer(sudachi_dict_type='core'						)

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   [' ', '\t', 'アップル', 'ストア', 'で', 'iPhone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', ' ', '。', ' ', ' ']						,   )
			@require_sudachi
			def       A_					(						self						):
							_lowerCamelCase  :    Any					=					SudachiTokenizer(sudachi_dict_type='core'						,   sudachi_split_mode='A'						)

							self.assertListEqual(tokenizer.tokenize('外国人参政権'						)						,   ['外国', '人', '参政', '権']						)
			@require_sudachi
			def       A_					(						self						):
							_lowerCamelCase  :    Optional[Any]					=					SudachiTokenizer(sudachi_dict_type='core'						,   sudachi_split_mode='B'						)

							self.assertListEqual(tokenizer.tokenize('外国人参政権'						)						,   ['外国人', '参政権']						)
			@require_sudachi
			def       A_					(						self						):
							_lowerCamelCase  :    List[str]					=					SudachiTokenizer(sudachi_dict_type='core'						,   sudachi_split_mode='C'						)

							self.assertListEqual(tokenizer.tokenize('外国人参政権'						)						,   ['外国人参政権']						)
			@require_sudachi
			def       A_					(						self						):
							_lowerCamelCase  :    Optional[int]					=					SudachiTokenizer(do_lower_case=lowercase						,   sudachi_dict_type='core'						)

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   [' ', '\t', 'アップル', 'ストア', 'で', 'iphone', '8', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', ' ', '。', ' ', ' ']						,   )
			@require_sudachi
			def       A_					(						self						):
							_lowerCamelCase  :    Dict					=					SudachiTokenizer(normalize_text=lowercase						,   sudachi_dict_type='core'						)

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   [' ', '\t', 'ｱｯﾌﾟﾙ', 'ストア', 'で', 'iPhone', '８', ' ', 'が', ' ', ' ', '\n ', '発売', 'さ', 'れ', 'た', '\u3000', '。', ' ', ' ']						,   )
			@require_sudachi
			def       A_					(						self						):
							_lowerCamelCase  :    int					=					SudachiTokenizer(trim_whitespace=lowercase						,   sudachi_dict_type='core'						)

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れ', 'た', '。']						,   )
			@require_jumanpp
			def       A_					(						self						):
							_lowerCamelCase  :    Tuple					=					self.tokenizer_class(self.vocab_file						,   word_tokenizer_type='jumanpp'						)
							self.assertIsNotNone(lowercase						)

							_lowerCamelCase  :    int					=					"こんにちは、世界。\nこんばんは、世界。"
							_lowerCamelCase  :    Dict					=					tokenizer.tokenize(lowercase						)
							self.assertListEqual(lowercase						,   ['こんにちは', '、', '世界', '。', 'こん', '##ばんは', '、', '世界', '。']						)
							self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase						)						,   [3, 12, 10, 14, 4, 9, 12, 10, 14]						)

							_lowerCamelCase  :    Optional[int]					=					os.path.join(self.tmpdirname						,   'tokenizer.bin'						)
							with open(lowercase						,   'wb'						) as handle:
											pickle.dump(lowercase						,   lowercase						)

							with open(lowercase						,   'rb'						) as handle:
											_lowerCamelCase  :    Any					=					pickle.load(lowercase						)

							_lowerCamelCase  :    List[Any]					=					tokenizer_new.tokenize(lowercase						)

							self.assertListEqual(lowercase						,   lowercase						)
			@require_jumanpp
			def       A_					(						self						):
							_lowerCamelCase  :    List[Any]					=					JumanppTokenizer()

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   ['アップル', 'ストア', 'で', 'iPhone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。']						,   )
			@require_jumanpp
			def       A_					(						self						):
							_lowerCamelCase  :    Any					=					JumanppTokenizer(do_lower_case=lowercase						)

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   ['アップル', 'ストア', 'で', 'iphone', '8', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。']						,   )
			@require_jumanpp
			def       A_					(						self						):
							_lowerCamelCase  :    Union[str, Any]					=					JumanppTokenizer(normalize_text=lowercase						)

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   ['ｱ', 'ｯ', 'ﾌ', 'ﾟ', 'ﾙ', 'ストア', 'で', 'iPhone', '８', '\u3000', 'が', '\u3000', '\u3000', '\u3000', '発売', 'さ', 'れた', '\u3000', '。']						,   )
			@require_jumanpp
			def       A_					(						self						):
							_lowerCamelCase  :    List[str]					=					JumanppTokenizer(trim_whitespace=lowercase						)

							self.assertListEqual(
							    tokenizer.tokenize(' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '						)						,   ['アップル', 'ストア', 'で', 'iPhone', '8', 'が', '発売', 'さ', 'れた', '。']						,   )
			@require_jumanpp
			def       A_					(						self						):
							_lowerCamelCase  :    Union[str, Any]					=					JumanppTokenizer()

							self.assertListEqual(
							    tokenizer.tokenize('ありがとうございますm(_ _)ｍ見つけるのが大変です。'						)						,   ['ありがとう', 'ございます', 'm(_ _)m', '見つける', 'の', 'が', '大変です', '。']						,   )
			def       A_					(						self						):
							_lowerCamelCase  :    str					=					["[UNK]", "[CLS]", "[SEP]", "こんにちは", "こん", "にちは", "ばんは", "##こん", "##にちは", "##ばんは"]

							_lowerCamelCase  :    str					=					{}
							for i, token in enumerate(lowercase						):
											_lowerCamelCase  :    Tuple					=					i
							_lowerCamelCase  :    Optional[Any]					=					WordpieceTokenizer(vocab=lowercase						,   unk_token='[UNK]'						)

							self.assertListEqual(tokenizer.tokenize(''						)						,   []						)

							self.assertListEqual(tokenizer.tokenize('こんにちは'						)						,   ['こんにちは']						)

							self.assertListEqual(tokenizer.tokenize('こんばんは'						)						,   ['こん', '##ばんは']						)

							self.assertListEqual(tokenizer.tokenize('こんばんは こんばんにちは こんにちは'						)						,   ['こん', '##ばんは', '[UNK]', 'こんにちは']						)
			def       A_					(						self						):
							_lowerCamelCase  :    Any					=					BertJapaneseTokenizer.from_pretrained('nlp-waseda/roberta-base-japanese-with-auto-jumanpp'						)
							_lowerCamelCase  :    int					=					tokenizer.subword_tokenizer

							_lowerCamelCase  :    int					=					subword_tokenizer.tokenize('国境 の 長い トンネル を 抜ける と 雪国 であった 。'						)
							self.assertListEqual(lowercase						,   ['▁国境', '▁の', '▁長い', '▁トンネル', '▁を', '▁抜ける', '▁と', '▁雪', '国', '▁であった', '▁。']						)

							_lowerCamelCase  :    List[Any]					=					subword_tokenizer.tokenize('こんばんは こんばん にち は こんにちは'						)
							self.assertListEqual(lowercase						,   ['▁こん', 'ばん', 'は', '▁こん', 'ばん', '▁に', 'ち', '▁は', '▁こんにちは']						)






			def       A_					(						self						):
							_lowerCamelCase  :    Dict					=					self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese'						)

							_lowerCamelCase  :    Any					=					tokenizer.encode('ありがとう。'						,   add_special_tokens=lowercase						)
							_lowerCamelCase  :    int					=					tokenizer.encode('どういたしまして。'						,   add_special_tokens=lowercase						)

							_lowerCamelCase  :    str					=					tokenizer.build_inputs_with_special_tokens(lowercase						)
							_lowerCamelCase  :    Union[str, Any]					=					tokenizer.build_inputs_with_special_tokens(lowercase						,   lowercase						)

							# 2 is for "[CLS]", 3 is for "[SEP]"
							assert encoded_sentence == [2] + text + [3]
							assert encoded_pair == [2] + text + [3] + text_a + [3]






@custom_tokenizers
class lowerCAmelCase__			(  __lowercase,			unittest.TestCase		):






			'''simple docstring'''



			lowerCamelCase__   =    BertJapaneseTokenizer
			lowerCamelCase__   =    False
			def       A_					(						self						):
							super().setUp()

							_lowerCamelCase  :    int					=					["[UNK]", "[CLS]", "[SEP]", "こ", "ん", "に", "ち", "は", "ば", "世", "界", "、", "。"]

							_lowerCamelCase  :    Union[str, Any]					=					os.path.join(self.tmpdirname						,   VOCAB_FILES_NAMES['vocab_file']						)
							with open(self.vocab_file						,   'w'						,   encoding='utf-8'						) as vocab_writer:
											vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]						)						)
			def       A_					(						self						,   **lowercase						):
							return BertJapaneseTokenizer.from_pretrained(self.tmpdirname						,   subword_tokenizer_type='character'						,   **lowercase						)
			def       A_					(						self						,   lowercase						):
							_lowerCamelCase  :    int					=					"こんにちは、世界。 \nこんばんは、世界。"
							_lowerCamelCase  :    Tuple					=					"こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。"
							return input_text, output_text
			def       A_					(						self						):
							pass  # TODO add if relevant
			def       A_					(						self						):
							pass  # TODO add if relevant
			def       A_					(						self						):
							pass  # TODO add if relevant
			def       A_					(						self						):
							_lowerCamelCase  :    Tuple					=					self.tokenizer_class(self.vocab_file						,   subword_tokenizer_type='character'						)

							_lowerCamelCase  :    Optional[int]					=					tokenizer.tokenize('こんにちは、世界。 \nこんばんは、世界。'						)
							self.assertListEqual(
							    lowercase						,   ['こ', 'ん', 'に', 'ち', 'は', '、', '世', '界', '。', 'こ', 'ん', 'ば', 'ん', 'は', '、', '世', '界', '。']						)
							self.assertListEqual(
							    tokenizer.convert_tokens_to_ids(lowercase						)						,   [3, 4, 5, 6, 7, 11, 9, 10, 12, 3, 4, 8, 4, 7, 11, 9, 10, 12]						)
			def       A_					(						self						):
							_lowerCamelCase  :    str					=					["[UNK]", "[CLS]", "[SEP]", "こ", "ん", "に", "ち", "は", "ば", "世", "界", "、", "。"]

							_lowerCamelCase  :    Union[str, Any]					=					{}
							for i, token in enumerate(lowercase						):
											_lowerCamelCase  :    Optional[int]					=					i
							_lowerCamelCase  :    List[str]					=					CharacterTokenizer(vocab=lowercase						,   unk_token='[UNK]'						)

							self.assertListEqual(tokenizer.tokenize(''						)						,   []						)

							self.assertListEqual(tokenizer.tokenize('こんにちは'						)						,   ['こ', 'ん', 'に', 'ち', 'は']						)

							self.assertListEqual(tokenizer.tokenize('こんにちほ'						)						,   ['こ', 'ん', 'に', 'ち', '[UNK]']						)






			def       A_					(						self						):
							_lowerCamelCase  :    Tuple					=					self.tokenizer_class.from_pretrained('cl-tohoku/bert-base-japanese-char'						)

							_lowerCamelCase  :    Union[str, Any]					=					tokenizer.encode('ありがとう。'						,   add_special_tokens=lowercase						)
							_lowerCamelCase  :    Tuple					=					tokenizer.encode('どういたしまして。'						,   add_special_tokens=lowercase						)

							_lowerCamelCase  :    Tuple					=					tokenizer.build_inputs_with_special_tokens(lowercase						)
							_lowerCamelCase  :    Optional[Any]					=					tokenizer.build_inputs_with_special_tokens(lowercase						,   lowercase						)

							# 2 is for "[CLS]", 3 is for "[SEP]"
							assert encoded_sentence == [2] + text + [3]
							assert encoded_pair == [2] + text + [3] + text_a + [3]






@custom_tokenizers
class lowerCAmelCase__			(  unittest.TestCase		):






			'''simple docstring'''



			def       A_					(						self						):
							_lowerCamelCase  :    Tuple					=					"cl-tohoku/bert-base-japanese"
							_lowerCamelCase  :    Optional[int]					=					AutoTokenizer.from_pretrained(lowercase						)
							self.assertIsInstance(lowercase						,   lowercase						)






class lowerCAmelCase__			(  unittest.TestCase		):






			'''simple docstring'''



			def       A_					(						self						):
							_lowerCamelCase  :    Any					=					"cl-tohoku/bert-base-japanese"
							with self.assertLogs('transformers'						,   level='WARNING'						) as cm:
											BertTokenizer.from_pretrained(lowercase						)
											self.assertTrue(
											    cm.records[0].message.startswith(
											        'The tokenizer class you load from this checkpoint is not the same type as the class this function'
											        ' is called from.'						)						)
							_lowerCamelCase  :    Optional[Any]					=					"bert-base-cased"
							with self.assertLogs('transformers'						,   level='WARNING'						) as cm:
											BertJapaneseTokenizer.from_pretrained(lowercase						)
											self.assertTrue(
											    cm.records[0].message.startswith(
											        'The tokenizer class you load from this checkpoint is not the same type as the class this function'
											        ' is called from.'						)						)





"""simple docstring"""






import functools
import operator

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


lowercase__  		=		logging.get_logger(__name__)

lowercase__  		=		{
    """asapp/sew-d-tiny-100k""": """https://huggingface.co/asapp/sew-d-tiny-100k/resolve/main/config.json""",
    # See all SEW-D models at https://huggingface.co/models?filter=sew-d
}






class lowerCAmelCase__			(  lowercase		):






			'''simple docstring'''



			lowerCamelCase__   =    """sew-d"""
			def __init__(						self						,   lowercase=32						,   lowercase=768						,   lowercase=12						,   lowercase=12						,   lowercase=3072						,   lowercase=2						,   lowercase=512						,   lowercase=256						,   lowercase=True						,   lowercase=True						,   lowercase=("p2c", "c2p")						,   lowercase="layer_norm"						,   lowercase="gelu_python"						,   lowercase=0.1						,   lowercase=0.1						,   lowercase=0.1						,   lowercase=0.0						,   lowercase=0.1						,   lowercase=0.02						,   lowercase=1E-7						,   lowercase=1E-5						,   lowercase="group"						,   lowercase="gelu"						,   lowercase=(64, 128, 128, 128, 128, 256, 256, 256, 256, 512, 512, 512, 512)						,   lowercase=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1)						,   lowercase=(10, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1)						,   lowercase=False						,   lowercase=128						,   lowercase=16						,   lowercase=True						,   lowercase=0.05						,   lowercase=10						,   lowercase=2						,   lowercase=0.0						,   lowercase=10						,   lowercase=0						,   lowercase="mean"						,   lowercase=False						,   lowercase=False						,   lowercase=256						,   lowercase=0						,   lowercase=1						,   lowercase=2						,   **lowercase						,   ):
							super().__init__(**lowercase						,   pad_token_id=lowercase						,   bos_token_id=lowercase						,   eos_token_id=lowercase						)
							_lowerCamelCase  :    List[str]					=					hidden_size
							_lowerCamelCase  :    int					=					feat_extract_norm
							_lowerCamelCase  :    Optional[Any]					=					feat_extract_activation
							_lowerCamelCase  :    Optional[Any]					=					list(lowercase						)
							_lowerCamelCase  :    Union[str, Any]					=					list(lowercase						)
							_lowerCamelCase  :    Optional[Any]					=					list(lowercase						)
							_lowerCamelCase  :    List[str]					=					conv_bias
							_lowerCamelCase  :    str					=					num_conv_pos_embeddings
							_lowerCamelCase  :    Optional[Any]					=					num_conv_pos_embedding_groups
							_lowerCamelCase  :    Tuple					=					len(self.conv_dim						)
							_lowerCamelCase  :    Optional[int]					=					num_hidden_layers
							_lowerCamelCase  :    List[str]					=					intermediate_size
							_lowerCamelCase  :    Dict					=					squeeze_factor
							_lowerCamelCase  :    Any					=					max_position_embeddings
							_lowerCamelCase  :    List[str]					=					position_buckets
							_lowerCamelCase  :    Dict					=					share_att_key
							_lowerCamelCase  :    List[str]					=					relative_attention
							_lowerCamelCase  :    Optional[Any]					=					norm_rel_ebd
							_lowerCamelCase  :    List[Any]					=					list(lowercase						)
							_lowerCamelCase  :    List[Any]					=					hidden_act
							_lowerCamelCase  :    Optional[Any]					=					num_attention_heads
							_lowerCamelCase  :    Optional[int]					=					hidden_dropout
							_lowerCamelCase  :    Optional[int]					=					attention_dropout
							_lowerCamelCase  :    Any					=					activation_dropout
							_lowerCamelCase  :    Tuple					=					feat_proj_dropout
							_lowerCamelCase  :    Any					=					final_dropout
							_lowerCamelCase  :    str					=					layer_norm_eps
							_lowerCamelCase  :    Tuple					=					feature_layer_norm_eps
							_lowerCamelCase  :    Any					=					initializer_range
							_lowerCamelCase  :    Dict					=					vocab_size

							if (
							    (len(self.conv_stride						) != self.num_feat_extract_layers)
							    or (len(self.conv_kernel						) != self.num_feat_extract_layers)
							    or (len(self.conv_dim						) != self.num_feat_extract_layers)
							):
											raise ValueError(
											    'Configuration for convolutional layers is incorrect.'
											    'It is required that `len(config.conv_dim)` == `len(config.conv_stride)` == `len(config.conv_kernel)`,'
											    F'''but is `len(config.conv_dim) = {len(self.conv_dim						)}`, `len(config.conv_stride)'''
											    F'''= {len(self.conv_stride						)}`, `len(config.conv_kernel) = {len(self.conv_kernel						)}`.'''						)

							# fine-tuning config parameters for SpecAugment: https://arxiv.org/abs/1904.08779
							_lowerCamelCase  :    Dict					=					apply_spec_augment
							_lowerCamelCase  :    int					=					mask_time_prob
							_lowerCamelCase  :    Union[str, Any]					=					mask_time_length
							_lowerCamelCase  :    Optional[Any]					=					mask_time_min_masks
							_lowerCamelCase  :    List[Any]					=					mask_feature_prob
							_lowerCamelCase  :    Union[str, Any]					=					mask_feature_length
							_lowerCamelCase  :    List[Any]					=					mask_feature_min_masks

							# ctc loss
							_lowerCamelCase  :    List[str]					=					ctc_loss_reduction
							_lowerCamelCase  :    List[str]					=					ctc_zero_infinity

							# sequence classification
							_lowerCamelCase  :    Dict					=					use_weighted_layer_sum
							_lowerCamelCase  :    List[Any]					=					classifier_proj_size






			@property
			def       A_					(						self						):
							return functools.reduce(operator.mul						,   self.conv_stride						,   1						)