code: 
  
  
  import unittest
  
  import numpy as np
  
  from transformers import ElectraConfig, is_flax_available
  from transformers.testing_utils import require_flax, slow
  
  from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask
  
  
  if is_flax_available():
   from transformers.models.electra.modeling_flax_electra import (
       FlaxElectraForCausalLM,
       FlaxElectraForMaskedLM,
       FlaxElectraForMultipleChoice,
       FlaxElectraForPreTraining,
       FlaxElectraForQuestionAnswering,
       FlaxElectraForSequenceClassification,
       FlaxElectraForTokenClassification,
       FlaxElectraModel,
   )
  
  
  
  
  
  class        lowercase_				( unittest.TestCase):
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         def __init__(   self			,    _UpperCAmelCase			,    _UpperCAmelCase=13			,    _UpperCAmelCase=7			,    _UpperCAmelCase=True			,    _UpperCAmelCase=True			,    _UpperCAmelCase=True			,    _UpperCAmelCase=True			,    _UpperCAmelCase=99			,    _UpperCAmelCase=24			,    _UpperCAmelCase=32			,    _UpperCAmelCase=5			,    _UpperCAmelCase=4			,    _UpperCAmelCase=37			,    _UpperCAmelCase="gelu"			,    _UpperCAmelCase=0.1			,    _UpperCAmelCase=0.1			,    _UpperCAmelCase=512			,    _UpperCAmelCase=16			,    _UpperCAmelCase=2			,    _UpperCAmelCase=0.0_2			,    _UpperCAmelCase=4			,    ):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		parent
               a_					=		batch_size
               a_					=		seq_length
               a_					=		is_training
               a_					=		use_attention_mask
               a_					=		use_token_type_ids
               a_					=		use_labels
               a_					=		vocab_size
               a_					=		hidden_size
               a_					=		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_choices
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		ids_tensor([self.batch_size, self.seq_length]			,    self.vocab_size		)
  
               a_					=		None
               if self.use_attention_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_					=		ElectraConfig(
                   vocab_size=self.vocab_size			,    hidden_size=self.hidden_size			,    embedding_size=self.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			,    initializer_range=self.initializer_range			,    )
  
               return config, input_ids, token_type_ids, attention_mask
  
  
  
  
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		self.prepare_config_and_inputs()
               a_			,   a_			,   a_			,   a_					=		config_and_inputs
               a_					=		{"""input_ids""": input_ids, """token_type_ids""": token_type_ids, """attention_mask""": attention_mask}
               return config, inputs_dict
  
  
  
  
  
  @require_flax
  class        lowercase_				( UpperCAmelCase_			,unittest.TestCase):
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         snake_case_        =		True
  
         snake_case_        =		(
             (
                 FlaxElectraModel,
                 FlaxElectraForCausalLM,
                 FlaxElectraForMaskedLM,
                 FlaxElectraForPreTraining,
                 FlaxElectraForTokenClassification,
                 FlaxElectraForQuestionAnswering,
                 FlaxElectraForMultipleChoice,
                 FlaxElectraForSequenceClassification,
             )
             if is_flax_available()
             else ()
         )
  
  
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               a_					=		FlaxElectraModelTester(self		)
  
  
  
  
  
  
         @slow
         def 						lowercase__     (   self		):
  
  
  
  
  
  
  
               """simple docstring"""
  
  
               for model_class_name in self.all_model_classes:
                     if model_class_name == FlaxElectraForMaskedLM:
                           a_					=		model_class_name.from_pretrained("""google/electra-small-generator"""		)
                     else:
                           a_					=		model_class_name.from_pretrained("""google/electra-small-discriminator"""		)
                     a_					=		model(np.ones((1, 1)		)		)
                     self.assertIsNotNone(_UpperCAmelCase		)
style_context: 
  
  
  import json
  import os
  import unittest
  
  from transformers import BartTokenizer, BartTokenizerFast, BatchEncoding
  from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES
  from transformers.testing_utils import require_tokenizers, require_torch
  from transformers.utils import cached_property
  
  from ...test_tokenization_common import TokenizerTesterMixin, filter_roberta_detectors
  
  
  
  
  
  @require_tokenizers
  class        lowercase_				( UpperCamelCase__			,unittest.TestCase):
  
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  
  
  							snake_case_        =		BartTokenizer
  							snake_case_        =		BartTokenizerFast
  							snake_case_        =		True
  							snake_case_        =		filter_roberta_detectors
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													super().setUp()
  													a_					=		[
  													    """l""",
  													    """o""",
  													    """w""",
  													    """e""",
  													    """r""",
  													    """s""",
  													    """t""",
  													    """i""",
  													    """d""",
  													    """n""",
  													    """\u0120""",
  													    """\u0120l""",
  													    """\u0120n""",
  													    """\u0120lo""",
  													    """\u0120low""",
  													    """er""",
  													    """\u0120lowest""",
  													    """\u0120newer""",
  													    """\u0120wider""",
  													    """<unk>""",
  													]
  													a_					=		dict(zip(_UpperCAmelCase			,    range(len(_UpperCAmelCase		)		)		)		)
  													a_					=		["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
  													a_					=		{"""unk_token""": """<unk>"""}
  
  													a_					=		os.path.join(self.tmpdirname			,    VOCAB_FILES_NAMES["""vocab_file"""]		)
  													a_					=		os.path.join(self.tmpdirname			,    VOCAB_FILES_NAMES["""merges_file"""]		)
  													with open(self.vocab_file			,    """w"""			,    encoding="""utf-8"""		) as fp:
  																			fp.write(json.dumps(_UpperCAmelCase		) + """\n"""		)
  													with open(self.merges_file			,    """w"""			,    encoding="""utf-8"""		) as fp:
  																			fp.write("""\n""".join(_UpperCAmelCase		)		)
  
  
  							def 						lowercase__     (   self			,    **_UpperCAmelCase		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													kwargs.update(self.special_tokens_map		)
  													return self.tokenizer_class.from_pretrained(self.tmpdirname			,    **_UpperCAmelCase		)
  
  
  							def 						lowercase__     (   self			,    **_UpperCAmelCase		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													kwargs.update(self.special_tokens_map		)
  													return self.rust_tokenizer_class.from_pretrained(self.tmpdirname			,    **_UpperCAmelCase		)
  
  
  							def 						lowercase__     (   self			,    _UpperCAmelCase		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													return "lower newer", "lower newer"
  
  
  							@cached_property
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													return BartTokenizer.from_pretrained("""facebook/bart-large"""		)
  
  
  							@cached_property
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													return BartTokenizerFast.from_pretrained("""facebook/bart-large"""		)
  
  
  							@require_torch
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
  													a_					=		[0, 250, 251, 17_818, 13, 39_186, 1_938, 4, 2]
  
  													for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
  																			a_					=		tokenizer(_UpperCAmelCase			,    max_length=len(_UpperCAmelCase		)			,    padding=_UpperCAmelCase			,    return_tensors="""pt"""		)
  																			self.assertIsInstance(_UpperCAmelCase			,    _UpperCAmelCase		)
  
  																			self.assertEqual((2, 9)			,    batch.input_ids.shape		)
  																			self.assertEqual((2, 9)			,    batch.attention_mask.shape		)
  																			a_					=		batch.input_ids.tolist()[0]
  																			self.assertListEqual(_UpperCAmelCase			,    _UpperCAmelCase		)
  																			# Test that special tokens are reset
  
  
  							@require_torch
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		["""A long paragraph for summarization.""", """Another paragraph for summarization."""]
  													for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
  																			a_					=		tokenizer(_UpperCAmelCase			,    padding=_UpperCAmelCase			,    return_tensors="""pt"""		)
  																			# check if input_ids are returned and no labels
  																			self.assertIn("""input_ids"""			,    _UpperCAmelCase		)
  																			self.assertIn("""attention_mask"""			,    _UpperCAmelCase		)
  																			self.assertNotIn("""labels"""			,    _UpperCAmelCase		)
  																			self.assertNotIn("""decoder_attention_mask"""			,    _UpperCAmelCase		)
  
  
  							@require_torch
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		[
  													    """Summary of the text.""",
  													    """Another summary.""",
  													]
  													for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
  																			a_					=		tokenizer(text_target=_UpperCAmelCase			,    max_length=32			,    padding="""max_length"""			,    return_tensors="""pt"""		)
  																			self.assertEqual(32			,    targets["""input_ids"""].shape[1]		)
  
  
  							@require_torch
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
  																			a_					=		tokenizer(
  																			    ["""I am a small frog""" * 1_024, """I am a small frog"""]			,    padding=_UpperCAmelCase			,    truncation=_UpperCAmelCase			,    return_tensors="""pt"""		)
  																			self.assertIsInstance(_UpperCAmelCase			,    _UpperCAmelCase		)
  																			self.assertEqual(batch.input_ids.shape			,    (2, 1_024)		)
  
  
  							@require_torch
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													a_					=		["""A long paragraph for summarization."""]
  													a_					=		[
  													    """Summary of the text.""",
  													]
  													for tokenizer in [self.default_tokenizer, self.default_tokenizer_fast]:
  																			a_					=		tokenizer(_UpperCAmelCase			,    return_tensors="""pt"""		)
  																			a_					=		tokenizer(text_target=_UpperCAmelCase			,    return_tensors="""pt"""		)
  																			a_					=		inputs["""input_ids"""]
  																			a_					=		targets["""input_ids"""]
  																			self.assertTrue((input_ids[:, 0] == tokenizer.bos_token_id).all().item()		)
  																			self.assertTrue((labels[:, 0] == tokenizer.bos_token_id).all().item()		)
  																			self.assertTrue((input_ids[:, -1] == tokenizer.eos_token_id).all().item()		)
  																			self.assertTrue((labels[:, -1] == tokenizer.eos_token_id).all().item()		)
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													pass
  
  
  
  
  
  
  							def 						lowercase__     (   self		):
  
  
  
  
  
  
  
  													"""simple docstring"""
  
  
  													for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
  																			with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"		):
  																									a_					=		self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase			,    **_UpperCAmelCase		)
  																									a_					=		self.tokenizer_class.from_pretrained(_UpperCAmelCase			,    **_UpperCAmelCase		)
  																									a_					=		"""A, <mask> AllenNLP sentence."""
  																									a_					=		tokenizer_r.encode_plus(_UpperCAmelCase			,    add_special_tokens=_UpperCAmelCase			,    return_token_type_ids=_UpperCAmelCase		)
  																									a_					=		tokenizer_p.encode_plus(_UpperCAmelCase			,    add_special_tokens=_UpperCAmelCase			,    return_token_type_ids=_UpperCAmelCase		)
  
  																									# token_type_ids should put 0 everywhere
  																									self.assertEqual(sum(tokens_r["""token_type_ids"""]		)			,    sum(tokens_p["""token_type_ids"""]		)		)
  
  																									# attention_mask should put 1 everywhere, so sum over length should be 1
  																									self.assertEqual(
  																									    sum(tokens_r["""attention_mask"""]		) / len(tokens_r["""attention_mask"""]		)			,    sum(tokens_p["""attention_mask"""]		) / len(tokens_p["""attention_mask"""]		)			,    )
  
  																									a_					=		tokenizer_r.convert_ids_to_tokens(tokens_r["""input_ids"""]		)
  																									a_					=		tokenizer_p.convert_ids_to_tokens(tokens_p["""input_ids"""]		)
  
  																									# Rust correctly handles the space before the mask while python doesnt
  																									self.assertSequenceEqual(tokens_p["""input_ids"""]			,    [0, 250, 6, 50_264, 3_823, 487, 21_992, 3_645, 4, 2]		)
  																									self.assertSequenceEqual(tokens_r["""input_ids"""]			,    [0, 250, 6, 50_264, 3_823, 487, 21_992, 3_645, 4, 2]		)
  
  																									self.assertSequenceEqual(
  																									    _UpperCAmelCase			,    ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]		)
  																									self.assertSequenceEqual(
  																									    _UpperCAmelCase			,    ["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]		)