code: 
  
  
  
  '''simple docstring'''
  
  
  
  
  
  import unittest
  
  from transformers import is_torch_available
  from transformers.testing_utils import require_torch, slow, torch_device
  
  from ...test_configuration_common import ConfigTester
  from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
  from ...test_pipeline_mixin import PipelineTesterMixin
  
  
  if is_torch_available():
      import torch
  
      from transformers import (
          RemBertConfig,
          RemBertForCausalLM,
          RemBertForMaskedLM,
          RemBertForMultipleChoice,
          RemBertForQuestionAnswering,
          RemBertForSequenceClassification,
          RemBertForTokenClassification,
          RemBertModel,
      )
      from transformers.models.rembert.modeling_rembert import REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST
  
  
  
  class 		_snake_case      :
  
  
  
  
  
   """simple docstring"""
  
  
  
   def __init__(						self	,    a	,    a=1_3	,    a=7	,    a=True	,    a=True	,    a=True	,    a=True	,    a=9_9	,    a=3_2	,    a=1_8	,    a=4_3	,    a=5	,    a=4	,    a=3_7	,    a="gelu"	,    a=0.1	,    a=0.1	,    a=5_1_2	,    a=1_6	,    a=2	,    a=0.02	,    a=3	,    a=4	,    a=None	,    )	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    parent
     _A           =    batch_size
     _A           =    seq_length
     _A           =    is_training
     _A           =    use_input_mask
     _A           =    use_token_type_ids
     _A           =    use_labels
     _A           =    vocab_size
     _A           =    hidden_size
     _A           =    input_embedding_size
     _A           =    output_embedding_size
     _A           =    num_hidden_layers
     _A           =    num_attention_heads
     _A           =    intermediate_size
     _A           =    hidden_act
     _A           =    hidden_dropout_prob
     _A           =    attention_probs_dropout_prob
     _A           =    max_position_embeddings
     _A           =    type_vocab_size
     _A           =    type_sequence_label_size
     _A           =    initializer_range
     _A           =    num_labels
     _A           =    num_choices
     _A           =    scope
   def lowercase_		(						self					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    ids_tensor([self.batch_size, self.seq_length]	,    self.vocab_size					)
  
     _A           =    None
     if self.use_input_mask:
       _A           =    random_attention_mask([self.batch_size, self.seq_length]					)
  
     _A           =    None
     if self.use_token_type_ids:
       _A           =    ids_tensor([self.batch_size, self.seq_length]	,    self.type_vocab_size					)
  
     _A           =    None
     _A           =    None
     _A           =    None
     if self.use_labels:
       _A           =    ids_tensor([self.batch_size]	,    self.type_sequence_label_size					)
       _A           =    ids_tensor([self.batch_size, self.seq_length]	,    self.num_labels					)
       _A           =    ids_tensor([self.batch_size]	,    self.num_choices					)
  
     _A           =    RemBertConfig(
         vocab_size=self.vocab_size	,    hidden_size=self.hidden_size	,    input_embedding_size=self.input_embedding_size	,    output_embedding_size=self.output_embedding_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=a	,    initializer_range=self.initializer_range	,    )
  
     return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
   def lowercase_		(						self					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     (
         (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,          
     )           =    self.prepare_config_and_inputs()
  
     _A           =    True
     _A           =    floats_tensor([self.batch_size, self.seq_length, self.hidden_size]					)
     _A           =    ids_tensor([self.batch_size, self.seq_length]	,    vocab_size=2					)
  
     return (
         config,
         input_ids,
         token_type_ids,
         input_mask,
         sequence_labels,
         token_labels,
         choice_labels,
         encoder_hidden_states,
         encoder_attention_mask,
     )
   def lowercase_		(						self	,    a	,    a	,    a	,    a	,    a	,    a	,    a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    RemBertModel(config=a					)
     model.to(a					)
     model.eval()
     _A           =    model(a	,    attention_mask=a	,    token_type_ids=a					)
     _A           =    model(a	,    token_type_ids=a					)
     _A           =    model(a					)
     self.parent.assertEqual(result.last_hidden_state.shape	,    (self.batch_size, self.seq_length, self.hidden_size)					)
   def lowercase_		(						self	,    a	,    a	,    a	,    a	,    a	,    a	,    a	,    a	,    a	,    )	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    True
     _A           =    RemBertModel(a					)
     model.to(a					)
     model.eval()
     _A           =    model(
         a	,    attention_mask=a	,    token_type_ids=a	,    encoder_hidden_states=a	,    encoder_attention_mask=a	,    )
     _A           =    model(
         a	,    attention_mask=a	,    token_type_ids=a	,    encoder_hidden_states=a	,    )
     _A           =    model(a	,    attention_mask=a	,    token_type_ids=a					)
     self.parent.assertEqual(result.last_hidden_state.shape	,    (self.batch_size, self.seq_length, self.hidden_size)					)
   def lowercase_		(						self	,    a	,    a	,    a	,    a	,    a	,    a	,    a	,    a	,    a	,    )	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    RemBertForCausalLM(config=a					)
     model.to(a					)
     model.eval()
     _A           =    model(a	,    attention_mask=a	,    token_type_ids=a	,    labels=a					)
     self.parent.assertEqual(result.logits.shape	,    (self.batch_size, self.seq_length, self.vocab_size)					)
   def lowercase_		(						self	,    a	,    a	,    a	,    a	,    a	,    a	,    a					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    RemBertForMaskedLM(config=a					)
     model.to(a					)
     model.eval()
     _A           =    model(a	,    attention_mask=a	,    token_type_ids=a	,    labels=a					)
     self.parent.assertEqual(result.logits.shape	,    (self.batch_size, self.seq_length, self.vocab_size)					)
   def lowercase_		(						self	,    a	,    a	,    a	,    a	,    a	,    a	,    a	,    a	,    a	,    )	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    True
     _A           =    True
     _A           =    RemBertForCausalLM(config=a					)
     model.to(a					)
     model.eval()
  
     # first forward pass
     _A           =    model(
         a	,    attention_mask=a	,    encoder_hidden_states=a	,    encoder_attention_mask=a	,    use_cache=a	,    )
     _A           =    outputs.past_key_values
  
     # create hypothetical multiple next token and extent to next_input_ids
     _A           =    ids_tensor((self.batch_size, 3)	,    config.vocab_size					)
     _A           =    ids_tensor((self.batch_size, 3)	,    vocab_size=2					)
  
     # append to next input_ids and
     _A           =    torch.cat([input_ids, next_tokens]	,    dim=-1					)
     _A           =    torch.cat([input_mask, next_mask]	,    dim=-1					)
  
     _A           =    model(
         a	,    attention_mask=a	,    encoder_hidden_states=a	,    encoder_attention_mask=a	,    output_hidden_states=a	,    )['''hidden_states'''][0]
     _A           =    model(
         a	,    attention_mask=a	,    encoder_hidden_states=a	,    encoder_attention_mask=a	,    past_key_values=a	,    output_hidden_states=a	,    )['''hidden_states'''][0]
  
     # select random slice
     _A           =    ids_tensor((1,)	,    output_from_past.shape[-1]					).item()
     _A           =    output_from_no_past[:, -3:, random_slice_idx].detach()
     _A           =    output_from_past[:, :, random_slice_idx].detach()
  
     self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]					)
  
     # test that outputs are equal for slice
     self.parent.assertTrue(torch.allclose(a	,    a	,    atol=1e-3					)					)
   def lowercase_		(						self	,    a	,    a	,    a	,    a	,    a	,    a	,    a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    RemBertForQuestionAnswering(config=a					)
     model.to(a					)
     model.eval()
     _A           =    model(
         a	,    attention_mask=a	,    token_type_ids=a	,    start_positions=a	,    end_positions=a	,    )
     self.parent.assertEqual(result.start_logits.shape	,    (self.batch_size, self.seq_length)					)
     self.parent.assertEqual(result.end_logits.shape	,    (self.batch_size, self.seq_length)					)
   def lowercase_		(						self	,    a	,    a	,    a	,    a	,    a	,    a	,    a					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.num_labels
     _A           =    RemBertForSequenceClassification(a					)
     model.to(a					)
     model.eval()
     _A           =    model(a	,    attention_mask=a	,    token_type_ids=a	,    labels=a					)
     self.parent.assertEqual(result.logits.shape	,    (self.batch_size, self.num_labels)					)
   def lowercase_		(						self	,    a	,    a	,    a	,    a	,    a	,    a	,    a					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.num_labels
     _A           =    RemBertForTokenClassification(config=a					)
     model.to(a					)
     model.eval()
     _A           =    model(a	,    attention_mask=a	,    token_type_ids=a	,    labels=a					)
     self.parent.assertEqual(result.logits.shape	,    (self.batch_size, self.seq_length, self.num_labels)					)
   def lowercase_		(						self	,    a	,    a	,    a	,    a	,    a	,    a	,    a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.num_choices
     _A           =    RemBertForMultipleChoice(config=a					)
     model.to(a					)
     model.eval()
     _A           =    input_ids.unsqueeze(1					).expand(-1	,    self.num_choices	,    -1					).contiguous()
     _A           =    token_type_ids.unsqueeze(1					).expand(-1	,    self.num_choices	,    -1					).contiguous()
     _A           =    input_mask.unsqueeze(1					).expand(-1	,    self.num_choices	,    -1					).contiguous()
     _A           =    model(
         a	,    attention_mask=a	,    token_type_ids=a	,    labels=a	,    )
     self.parent.assertEqual(result.logits.shape	,    (self.batch_size, self.num_choices)					)
  
  
  
   def lowercase_		(						self					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.prepare_config_and_inputs()
     (
         (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,          
     )           =    config_and_inputs
     _A           =    {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
     return config, inputs_dict
  
  
  
  
  
  
  
  @require_torch
  class 		_snake_case      (			__lowerCamelCase					,__lowerCamelCase					,unittest.TestCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			(
       (
           RemBertModel,
           RemBertForMaskedLM,
           RemBertForCausalLM,
           RemBertForMultipleChoice,
           RemBertForQuestionAnswering,
           RemBertForSequenceClassification,
           RemBertForTokenClassification,
       )
       if is_torch_available()
       else ()
   )
   lowerCamelCase_          =			(RemBertForCausalLM,) if is_torch_available() else ()
   lowerCamelCase_          =			(
       {
           'feature-extraction': RemBertModel,
           'fill-mask': RemBertForMaskedLM,
           'question-answering': RemBertForQuestionAnswering,
           'text-classification': RemBertForSequenceClassification,
           'text-generation': RemBertForCausalLM,
           'token-classification': RemBertForTokenClassification,
           'zero-shot': RemBertForSequenceClassification,
       }
       if is_torch_available()
       else {}
   )
   def lowercase_		(						self					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    RemBertModelTester(self					)
     _A           =    ConfigTester(self	,    config_class=a	,    hidden_size=3_7					)
   def lowercase_		(						self					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     self.config_tester.run_common_tests()
   def lowercase_		(						self					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*a					)
   def lowercase_		(						self					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.model_tester.prepare_config_and_inputs()
     for type in ["absolute", "relative_key", "relative_key_query"]:
       _A           =    type
       self.model_tester.create_and_check_model(*a					)
   def lowercase_		(						self					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_masked_lm(*a					)
   def lowercase_		(						self					)	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_multiple_choice(*a					)
   def lowercase_		(						self					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.model_tester.prepare_config_and_inputs_for_decoder()
     self.model_tester.create_and_check_decoder_model_past_large_inputs(*a					)
   def lowercase_		(						self					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_question_answering(*a					)
   def lowercase_		(						self					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_sequence_classification(*a					)
   def lowercase_		(						self					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_token_classification(*a					)
   def lowercase_		(						self					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    self.model_tester.prepare_config_and_inputs_for_decoder()
     self.model_tester.create_and_check_model_as_decoder(*a					)
   def lowercase_		(						self					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     (
         (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,   (
         _A       
     )    ,          
     )           =    self.model_tester.prepare_config_and_inputs_for_decoder()
  
     _A           =    None
  
     self.model_tester.create_and_check_model_as_decoder(
         a	,    a	,    a	,    a	,    a	,    a	,    a	,    a	,    a	,    )
  
  
  
   @slow
   def lowercase_		(						self					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     for model_name in REMBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       _A           =    RemBertModel.from_pretrained(a					)
       self.assertIsNotNone(a					)
  
  
  
  
  
  
  
  @require_torch
  class 		_snake_case      (			unittest.TestCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   @slow
   def lowercase_		(						self					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     _A           =    RemBertModel.from_pretrained('''google/rembert'''					)
     _A           =    torch.tensor([[3_1_2, 5_6_4_9_8, 3_1_3, 2_1_2_5, 3_1_3]]					)
     _A           =    torch.tensor([[0, 0, 0, 1, 1]]					)
     with torch.no_grad():
       _A           =    model(a	,    token_type_ids=a	,    output_hidden_states=a					)
  
     _A           =    1_1_5_2
  
     _A           =    torch.Size((1, 5, hidden_size)					)
     self.assertEqual(output['''last_hidden_state'''].shape	,    a					)
  
     _A           =    torch.tensor(
         [
             [
                 [0.0_754, -0.2_022, 0.1_904],
                 [-0.3_354, -0.3_692, -0.4_791],
                 [-0.2_314, -0.6_729, -0.0_749],
                 [-0.0_396, -0.3_105, -0.4_234],
                 [-0.1_571, -0.0_525, 0.5_353],
             ]
         ]					)
  
     # Running on the original tf implementation gives slightly different results here.
     # Not clear why this variations is present
     # TODO: Find reason for discrepancy
     # expected_original_implementation = [[
     #     [0.07630594074726105, -0.20146065950393677, 0.19107051193714142],
     #     [-0.3405614495277405, -0.36971670389175415, -0.4808273911476135],
     #     [-0.22587086260318756, -0.6656315922737122, -0.07844287157058716],
     #     [-0.04145475849509239, -0.3077218234539032, -0.42316967248916626],
     #     [-0.15887849032878876, -0.054529931396245956, 0.5356100797653198]
     # ]]
  
     self.assertTrue(torch.allclose(output['''last_hidden_state'''][:, :, :3]	,    a	,    atol=1e-4					)					)
style_context: 
  
  
  
  from ..utils import DummyObject, requires_backends
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[str]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Tuple:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							List[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							str:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Dict:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[int]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Optional[Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Union[str, Any]:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							int:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)
  
  
  
  
  
  
  
  class 		_snake_case      (			metaclass=lowerCamelCase				):
  
  
  
  
  
   """simple docstring"""
  
  
  
   lowerCamelCase_          =			['''tokenizers''']
   def __init__(						self	,    *a	,    **a					)	->							Any:
  
  
  
  
     """simple docstring"""
  
  
  
  
  
  
  
     requires_backends(self	,    ['''tokenizers''']					)