
"""simple docstring"""

import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


SCREAMING_SNAKE_CASE_            =    get_tests_dir('''fixtures/test_sentencepiece.model''')


if is_torch_available():
   from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

SCREAMING_SNAKE_CASE_            =    25_6047
SCREAMING_SNAKE_CASE_            =    25_6145
@require_sentencepiece
@require_tokenizers
class   _UpperCAmelCase				(		SCREAMING_SNAKE_CASE_  ,      unittest.TestCase				):
      __SCREAMING_SNAKE_CASE :				Any				   =						NllbTokenizer
      __SCREAMING_SNAKE_CASE :				Union[str, Any]				   =						NllbTokenizerFast
      __SCREAMING_SNAKE_CASE :				Dict				   =						True
      __SCREAMING_SNAKE_CASE :				int				   =						True
      __SCREAMING_SNAKE_CASE :				Optional[Any]				   =						{}




      def      a_   (				self				)    ->       Optional[Any]:
          super().setUp()

          # We have a SentencePiece fixture for testing
          UpperCAmelCase          =       NllbTokenizer(lowercase_ ,							keep_accents=lowercase_				)
          tokenizer.save_pretrained(self.tmpdirname				)




      def      a_   (				self				)    ->       Optional[int]:
          UpperCAmelCase          =       NllbTokenizer(lowercase_ ,							keep_accents=lowercase_				)

          UpperCAmelCase          =       tokenizer.tokenize('This is a test'				)
          self.assertListEqual(lowercase_ ,							['▁This', '▁is', '▁a', '▁t', 'est']				)

          self.assertListEqual(
              tokenizer.convert_tokens_to_ids(lowercase_				) ,							[value + tokenizer.fairseq_offset for value in [2_8_5, 4_6, 1_0, 1_7_0, 3_8_2]] ,							)

          UpperCAmelCase          =       tokenizer.tokenize('I was born in 92000, and this is falsé.'				)
          self.assertListEqual(
              lowercase_ ,							[
                  SPIECE_UNDERLINE + 'I',
                  SPIECE_UNDERLINE + 'was',
                  SPIECE_UNDERLINE + 'b',
                  'or',
                  'n',
                  SPIECE_UNDERLINE + 'in',
                  SPIECE_UNDERLINE + '',
                  '9',
                  '2',
                  '0',
                  '0',
                  '0',
                  ',',
                  SPIECE_UNDERLINE + 'and',
                  SPIECE_UNDERLINE + 'this',
                  SPIECE_UNDERLINE + 'is',
                  SPIECE_UNDERLINE + 'f',
                  'al',
                  's',
                  'é',
                  '.',
              ] ,							)
          UpperCAmelCase          =       tokenizer.convert_tokens_to_ids(lowercase_				)
          self.assertListEqual(
              lowercase_ ,							[
                  value + tokenizer.fairseq_offset
                  for value in [8, 2_1, 8_4, 5_5, 2_4, 1_9, 7, 2, 6_0_2, 3_4_7, 3_4_7, 3_4_7, 3, 1_2, 6_6, 4_6, 7_2, 8_0, 6, 2, 4]
              ] ,							)

          UpperCAmelCase          =       tokenizer.convert_ids_to_tokens(lowercase_				)
          self.assertListEqual(
              lowercase_ ,							[
                  SPIECE_UNDERLINE + 'I',
                  SPIECE_UNDERLINE + 'was',
                  SPIECE_UNDERLINE + 'b',
                  'or',
                  'n',
                  SPIECE_UNDERLINE + 'in',
                  SPIECE_UNDERLINE + '',
                  '<unk>',
                  '2',
                  '0',
                  '0',
                  '0',
                  ',',
                  SPIECE_UNDERLINE + 'and',
                  SPIECE_UNDERLINE + 'this',
                  SPIECE_UNDERLINE + 'is',
                  SPIECE_UNDERLINE + 'f',
                  'al',
                  's',
                  '<unk>',
                  '.',
              ] ,							)




      def      a_   (				self				)    ->       List[str]:
          UpperCAmelCase          =       (self.rust_tokenizer_class, 'hf-internal-testing/tiny-random-nllb', {})
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"				):
                  UpperCAmelCase          =       self.rust_tokenizer_class.from_pretrained(lowercase_ ,							**lowercase_				)
                  UpperCAmelCase          =       self.tokenizer_class.from_pretrained(lowercase_ ,							**lowercase_				)

                  UpperCAmelCase          =       tempfile.mkdtemp()

                  UpperCAmelCase          =       tokenizer_r.save_pretrained(lowercase_				)
                  UpperCAmelCase          =       tokenizer_p.save_pretrained(lowercase_				)

                  # Checks it save with the same files + the tokenizer.json file for the fast one
                  self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files				)				)
                  UpperCAmelCase          =       tuple(f for f in tokenizer_r_files if 'tokenizer.json' not in f				)
                  self.assertSequenceEqual(lowercase_ ,							lowercase_				)

                  # Checks everything loads correctly in the same way
                  UpperCAmelCase          =       tokenizer_r.from_pretrained(lowercase_				)
                  UpperCAmelCase          =       tokenizer_p.from_pretrained(lowercase_				)

                  # Check special tokens are set accordingly on Rust and Python
                  for key in tokenizer_pp.special_tokens_map:
                      self.assertTrue(hasattr(lowercase_ ,							lowercase_				)				)

                  shutil.rmtree(lowercase_				)

                  # Save tokenizer rust, legacy_format=True
                  UpperCAmelCase          =       tempfile.mkdtemp()

                  UpperCAmelCase          =       tokenizer_r.save_pretrained(lowercase_ ,							legacy_format=lowercase_				)
                  UpperCAmelCase          =       tokenizer_p.save_pretrained(lowercase_				)

                  # Checks it save with the same files
                  self.assertSequenceEqual(lowercase_ ,							lowercase_				)

                  # Checks everything loads correctly in the same way
                  UpperCAmelCase          =       tokenizer_r.from_pretrained(lowercase_				)
                  UpperCAmelCase          =       tokenizer_p.from_pretrained(lowercase_				)

                  # Check special tokens are set accordingly on Rust and Python
                  for key in tokenizer_pp.special_tokens_map:
                      self.assertTrue(hasattr(lowercase_ ,							lowercase_				)				)

                  shutil.rmtree(lowercase_				)

                  # Save tokenizer rust, legacy_format=False
                  UpperCAmelCase          =       tempfile.mkdtemp()

                  UpperCAmelCase          =       tokenizer_r.save_pretrained(lowercase_ ,							legacy_format=lowercase_				)
                  UpperCAmelCase          =       tokenizer_p.save_pretrained(lowercase_				)

                  # Checks it saved the tokenizer.json file
                  self.assertTrue(any('tokenizer.json' in f for f in tokenizer_r_files				)				)

                  # Checks everything loads correctly in the same way
                  UpperCAmelCase          =       tokenizer_r.from_pretrained(lowercase_				)
                  UpperCAmelCase          =       tokenizer_p.from_pretrained(lowercase_				)

                  # Check special tokens are set accordingly on Rust and Python
                  for key in tokenizer_pp.special_tokens_map:
                      self.assertTrue(hasattr(lowercase_ ,							lowercase_				)				)

                  shutil.rmtree(lowercase_				)




      @require_torch
      def      a_   (				self				)    ->       List[Any]:
          if not self.test_seqaseq:
              return

          UpperCAmelCase          =       self.get_tokenizers()
          for tokenizer in tokenizers:
              with self.subTest(F"{tokenizer.__class__.__name__}"				):
                  # Longer text that will definitely require truncation.
                  UpperCAmelCase          =       [
                      ' UN Chief Says There Is No Military Solution in Syria',
                      ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for'
                      ' Syria is that \'there is no military solution\' to the nearly five-year conflict and more weapons'
                      ' will only worsen the violence and misery for millions of people.',
                  ]
                  UpperCAmelCase          =       [
                      'Şeful ONU declară că nu există o soluţie militară în Siria',
                      'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al'
                      ' Rusiei pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi'
                      ' că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.',
                  ]
                  try:
                      UpperCAmelCase          =       tokenizer.prepare_seqaseq_batch(
                          src_texts=lowercase_ ,							tgt_texts=lowercase_ ,							max_length=3 ,							max_target_length=1_0 ,							return_tensors='pt' ,							src_lang='eng_Latn' ,							tgt_lang='ron_Latn' ,							)
                  except NotImplementedError:
                      return
                  self.assertEqual(batch.input_ids.shape[1] ,							3				)
                  self.assertEqual(batch.labels.shape[1] ,							1_0				)
                  # max_target_length will default to max_length if not specified
                  UpperCAmelCase          =       tokenizer.prepare_seqaseq_batch(
                      lowercase_ ,							tgt_texts=lowercase_ ,							max_length=3 ,							return_tensors='pt'				)
                  self.assertEqual(batch.input_ids.shape[1] ,							3				)
                  self.assertEqual(batch.labels.shape[1] ,							3				)

                  UpperCAmelCase          =       tokenizer.prepare_seqaseq_batch(
                      src_texts=lowercase_ ,							max_length=3 ,							max_target_length=1_0 ,							return_tensors='pt'				)
                  self.assertEqual(batch_encoder_only.input_ids.shape[1] ,							3				)
                  self.assertEqual(batch_encoder_only.attention_mask.shape[1] ,							3				)
                  self.assertNotIn('decoder_input_ids' ,							lowercase_				)




      @unittest.skip('Unfortunately way too slow to build a BPE with SentencePiece.'				)
      def      a_   (				self				)    ->       List[Any]:
          pass




      def      a_   (				self				)    ->       Optional[int]:
          for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
              with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"				):
                  UpperCAmelCase          =       [AddedToken('<special>' ,							lstrip=lowercase_				)]

                  UpperCAmelCase          =       self.rust_tokenizer_class.from_pretrained(
                      lowercase_ ,							additional_special_tokens=lowercase_ ,							**lowercase_				)
                  UpperCAmelCase          =       tokenizer_r.encode('Hey this is a <special> token'				)

                  UpperCAmelCase          =       tokenizer_r.encode('<special>' ,							add_special_tokens=lowercase_				)[0]

                  self.assertTrue(special_token_id in r_output				)

                  if self.test_slow_tokenizer:
                      UpperCAmelCase          =       self.rust_tokenizer_class.from_pretrained(
                          lowercase_ ,							additional_special_tokens=lowercase_ ,							**lowercase_ ,							)
                      UpperCAmelCase          =       self.tokenizer_class.from_pretrained(
                          lowercase_ ,							additional_special_tokens=lowercase_ ,							**lowercase_				)

                      UpperCAmelCase          =       tokenizer_p.encode('Hey this is a <special> token'				)

                      UpperCAmelCase          =       tokenizer_cr.encode('Hey this is a <special> token'				)

                      self.assertEqual(lowercase_ ,							lowercase_				)
                      self.assertEqual(lowercase_ ,							lowercase_				)
                      self.assertTrue(special_token_id in p_output				)
                      self.assertTrue(special_token_id in cr_output				)

@require_torch
@require_sentencepiece
@require_tokenizers
class   _UpperCAmelCase				(		unittest.TestCase				):
      __SCREAMING_SNAKE_CASE :				Tuple				   =						"facebook/nllb-200-distilled-600M"
      __SCREAMING_SNAKE_CASE :				Dict				   =						[
          " UN Chief Says There Is No Military Solution in Syria",
          " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.",
      ]
      __SCREAMING_SNAKE_CASE :				Optional[int]				   =						[
          "Şeful ONU declară că nu există o soluţie militară în Siria",
          "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"
          " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"
          " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.",
      ]
      __SCREAMING_SNAKE_CASE :				Optional[int]				   =						[
          2_5_6_0_4_7,
          1_6_2_9_7,
          1_3_4_4_0_8,
          8_1_6_5,
          2_4_8_0_6_6,
          1_4_7_3_4,
          9_5_0,
          1_1_3_5,
          1_0_5_7_2_1,
          3_5_7_3,
          8_3,
          2_7_3_5_2,
          1_0_8,
          4_9_4_8_6,
          2,
      ]




      @classmethod
      def      a_   (				cls				)    ->       Optional[int]:
          UpperCAmelCase          =       NllbTokenizer.from_pretrained(
              cls.checkpoint_name ,							src_lang='eng_Latn' ,							tgt_lang='ron_Latn'				)
          UpperCAmelCase          =       1
          return cls




      def      a_   (				self				)    ->       List[Any]:
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Arab'] ,							2_5_6_0_0_1				)
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['ace_Latn'] ,							2_5_6_0_0_2				)
          self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['fra_Latn'] ,							2_5_6_0_5_7				)




      def      a_   (				self				)    ->       str:
          UpperCAmelCase          =       self.tokenizer.batch_encode_plus(self.src_text				).input_ids[0]
          self.assertListEqual(self.expected_src_tokens ,							lowercase_				)




      def      a_   (				self				)    ->       Dict:
          self.assertIn(lowercase_ ,							self.tokenizer.all_special_ids				)
          # fmt: off
          UpperCAmelCase          =       [RO_CODE, 4_2_5_4, 9_8_0_6_8, 1_1_2_9_2_3, 3_9_0_7_2, 3_9_0_9, 7_1_3, 1_0_2_7_6_7, 2_6, 1_7_3_1_4, 3_5_6_4_2, 1_4_6_8_3, 3_3_1_1_8, 2_0_2_2, 6_6_9_8_7, 2, 2_5_6_0_4_7]
          # fmt: on

          UpperCAmelCase          =       self.tokenizer.decode(lowercase_ ,							skip_special_tokens=lowercase_				)
          UpperCAmelCase          =       self.tokenizer.decode(generated_ids[1:] ,							skip_special_tokens=lowercase_				)
          self.assertEqual(lowercase_ ,							lowercase_				)
          self.assertNotIn(self.tokenizer.eos_token ,							lowercase_				)




      def      a_   (				self				)    ->       Tuple:
          UpperCAmelCase          =       ['this is gunna be a long sentence ' * 2_0]
          assert isinstance(src_text[0] ,							lowercase_				)
          UpperCAmelCase          =       1_0
          UpperCAmelCase          =       self.tokenizer(lowercase_ ,							max_length=lowercase_ ,							truncation=lowercase_				).input_ids[0]
          self.assertEqual(ids[-1] ,							2				)
          self.assertEqual(ids[0] ,							lowercase_				)
          self.assertEqual(len(lowercase_				) ,							lowercase_				)




      def      a_   (				self				)    ->       Any:
          self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['<mask>', 'ar_AR']				) ,							[2_5_6_2_0_3, 3]				)




      def      a_   (				self				)    ->       str:
          UpperCAmelCase          =       tempfile.mkdtemp()
          UpperCAmelCase          =       self.tokenizer.fairseq_tokens_to_ids
          self.tokenizer.save_pretrained(lowercase_				)
          UpperCAmelCase          =       NllbTokenizer.from_pretrained(lowercase_				)
          self.assertDictEqual(new_tok.fairseq_tokens_to_ids ,							lowercase_				)




      @require_torch
      def      a_   (				self				)    ->       Optional[int]:
          UpperCAmelCase          =       self.tokenizer(
              self.src_text ,							text_target=self.tgt_text ,							padding=lowercase_ ,							truncation=lowercase_ ,							max_length=len(self.expected_src_tokens				) ,							return_tensors='pt' ,							)
          UpperCAmelCase          =       shift_tokens_right(
              batch['labels'] ,							self.tokenizer.pad_token_id ,							self.tokenizer.lang_code_to_id['ron_Latn']				)

          self.assertIsInstance(lowercase_ ,							lowercase_				)

          self.assertEqual((2, 1_5) ,							batch.input_ids.shape				)
          self.assertEqual((2, 1_5) ,							batch.attention_mask.shape				)
          UpperCAmelCase          =       batch.input_ids.tolist()[0]
          self.assertListEqual(self.expected_src_tokens ,							lowercase_				)
          self.assertEqual(lowercase_ ,							batch.decoder_input_ids[0, 0]				)  # EOS
          # Test that special tokens are reset
          self.assertEqual(self.tokenizer.prefix_tokens ,							[EN_CODE]				)
          self.assertEqual(self.tokenizer.suffix_tokens ,							[self.tokenizer.eos_token_id]				)




      def      a_   (				self				)    ->       List[Any]:
          UpperCAmelCase          =       self.tokenizer(self.src_text ,							padding=lowercase_ ,							truncation=lowercase_ ,							max_length=3 ,							return_tensors='pt'				)
          UpperCAmelCase          =       self.tokenizer(
              text_target=self.tgt_text ,							padding=lowercase_ ,							truncation=lowercase_ ,							max_length=1_0 ,							return_tensors='pt'				)
          UpperCAmelCase          =       targets['input_ids']
          UpperCAmelCase          =       shift_tokens_right(
              lowercase_ ,							self.tokenizer.pad_token_id ,							decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang] ,							)

          self.assertEqual(batch.input_ids.shape[1] ,							3				)
          self.assertEqual(batch.decoder_input_ids.shape[1] ,							1_0				)




      @require_torch
      def      a_   (				self				)    ->       Union[str, Any]:
          UpperCAmelCase          =       self.tokenizer._build_translation_inputs(
              'A test' ,							return_tensors='pt' ,							src_lang='eng_Latn' ,							tgt_lang='fra_Latn'				)

          self.assertEqual(
              nested_simplify(lowercase_				) ,							{
                  # A, test, EOS, en_XX
                  'input_ids': [[2_5_6_0_4_7, 7_0, 7_3_5_6, 2]],
                  'attention_mask': [[1, 1, 1, 1]],
                  # ar_AR
                  'forced_bos_token_id': 2_5_6_0_5_7,
              } ,							)




      @require_torch
      def      a_   (				self				)    ->       Dict:
          UpperCAmelCase          =       True
          UpperCAmelCase          =       self.tokenizer(
              'UN Chief says there is no military solution in Syria' ,							src_lang='eng_Latn' ,							tgt_lang='fra_Latn'				)
          self.assertEqual(
              inputs.input_ids ,							[1_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2, 2_5_6_0_4_7]				)

          UpperCAmelCase          =       False
          UpperCAmelCase          =       self.tokenizer(
              'UN Chief says there is no military solution in Syria' ,							src_lang='eng_Latn' ,							tgt_lang='fra_Latn'				)
          self.assertEqual(
              inputs.input_ids ,							[2_5_6_0_4_7, 1_6_2_9_7, 1_3_4_4_0_8, 2_5_6_5_3, 6_3_7_0, 2_4_8, 2_5_4, 1_0_3_9_2_9, 9_4_9_9_5, 1_0_8, 4_9_4_8_6, 2]				)





"""simple docstring"""

import functools
import operator

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


SCREAMING_SNAKE_CASE_            =    logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_            =    {
    '''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   _UpperCAmelCase				(		SCREAMING_SNAKE_CASE_				):
      __SCREAMING_SNAKE_CASE :				List[str]				   =						"sew-d"




      def __init__(				self ,							lowercase_=3_2 ,							lowercase_=7_6_8 ,							lowercase_=1_2 ,							lowercase_=1_2 ,							lowercase_=3_0_7_2 ,							lowercase_=2 ,							lowercase_=5_1_2 ,							lowercase_=2_5_6 ,							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.0_2 ,							lowercase_=1E-7 ,							lowercase_=1E-5 ,							lowercase_="group" ,							lowercase_="gelu" ,							lowercase_=(6_4, 1_2_8, 1_2_8, 1_2_8, 1_2_8, 2_5_6, 2_5_6, 2_5_6, 2_5_6, 5_1_2, 5_1_2, 5_1_2, 5_1_2) ,							lowercase_=(5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1) ,							lowercase_=(1_0, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1) ,							lowercase_=False ,							lowercase_=1_2_8 ,							lowercase_=1_6 ,							lowercase_=True ,							lowercase_=0.0_5 ,							lowercase_=1_0 ,							lowercase_=2 ,							lowercase_=0.0 ,							lowercase_=1_0 ,							lowercase_=0 ,							lowercase_="mean" ,							lowercase_=False ,							lowercase_=False ,							lowercase_=2_5_6 ,							lowercase_=0 ,							lowercase_=1 ,							lowercase_=2 ,							**lowercase_ ,							)    ->       Dict:
          super().__init__(**lowercase_ ,							pad_token_id=lowercase_ ,							bos_token_id=lowercase_ ,							eos_token_id=lowercase_				)
          UpperCAmelCase          =       hidden_size
          UpperCAmelCase          =       feat_extract_norm
          UpperCAmelCase          =       feat_extract_activation
          UpperCAmelCase          =       list(lowercase_				)
          UpperCAmelCase          =       list(lowercase_				)
          UpperCAmelCase          =       list(lowercase_				)
          UpperCAmelCase          =       conv_bias
          UpperCAmelCase          =       num_conv_pos_embeddings
          UpperCAmelCase          =       num_conv_pos_embedding_groups
          UpperCAmelCase          =       len(self.conv_dim				)
          UpperCAmelCase          =       num_hidden_layers
          UpperCAmelCase          =       intermediate_size
          UpperCAmelCase          =       squeeze_factor
          UpperCAmelCase          =       max_position_embeddings
          UpperCAmelCase          =       position_buckets
          UpperCAmelCase          =       share_att_key
          UpperCAmelCase          =       relative_attention
          UpperCAmelCase          =       norm_rel_ebd
          UpperCAmelCase          =       list(lowercase_				)
          UpperCAmelCase          =       hidden_act
          UpperCAmelCase          =       num_attention_heads
          UpperCAmelCase          =       hidden_dropout
          UpperCAmelCase          =       attention_dropout
          UpperCAmelCase          =       activation_dropout
          UpperCAmelCase          =       feat_proj_dropout
          UpperCAmelCase          =       final_dropout
          UpperCAmelCase          =       layer_norm_eps
          UpperCAmelCase          =       feature_layer_norm_eps
          UpperCAmelCase          =       initializer_range
          UpperCAmelCase          =       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
          UpperCAmelCase          =       apply_spec_augment
          UpperCAmelCase          =       mask_time_prob
          UpperCAmelCase          =       mask_time_length
          UpperCAmelCase          =       mask_time_min_masks
          UpperCAmelCase          =       mask_feature_prob
          UpperCAmelCase          =       mask_feature_length
          UpperCAmelCase          =       mask_feature_min_masks

          # ctc loss
          UpperCAmelCase          =       ctc_loss_reduction
          UpperCAmelCase          =       ctc_zero_infinity

          # sequence classification
          UpperCAmelCase          =       use_weighted_layer_sum
          UpperCAmelCase          =       classifier_proj_size




      @property
      def      a_   (				self				)    ->       Tuple:
          return functools.reduce(operator.mul ,							self.conv_stride ,							1				)



