



import unittest
from unittest.util import safe_repr

from transformers import AutoTokenizer, RwkvConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
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 (
		    RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
		    RwkvForCausalLM,
		    RwkvModel,
		)
		from transformers.pytorch_utils import is_torch_greater_or_equal_than_2_0
else:
		a_								=   False



class 	__lowerCAmelCase       :




	def __init__(  self		,			__UpperCAmelCase		,			__UpperCAmelCase=14		,			__UpperCAmelCase=7		,			__UpperCAmelCase=True		,			__UpperCAmelCase=False		,			__UpperCAmelCase=True		,			__UpperCAmelCase=True		,			__UpperCAmelCase=True		,			__UpperCAmelCase=99		,			__UpperCAmelCase=32		,			__UpperCAmelCase=5		,			__UpperCAmelCase=37		,			__UpperCAmelCase="gelu"		,			__UpperCAmelCase=0.1		,			__UpperCAmelCase=0.1		,			__UpperCAmelCase=512		,			__UpperCAmelCase=16		,			__UpperCAmelCase=2		,			__UpperCAmelCase=3		,			__UpperCAmelCase=4		,			__UpperCAmelCase=None		,			):



				'''simple docstring'''
				__lowerCamelCase  							=      parent
				__lowerCamelCase  							=      batch_size
				__lowerCamelCase  							=      seq_length
				__lowerCamelCase  							=      is_training
				__lowerCamelCase  							=      use_token_type_ids
				__lowerCamelCase  							=      use_input_mask
				__lowerCamelCase  							=      use_labels
				__lowerCamelCase  							=      use_mc_token_ids
				__lowerCamelCase  							=      vocab_size
				__lowerCamelCase  							=      hidden_size
				__lowerCamelCase  							=      num_hidden_layers
				__lowerCamelCase  							=      intermediate_size
				__lowerCamelCase  							=      hidden_act
				__lowerCamelCase  							=      hidden_dropout_prob
				__lowerCamelCase  							=      attention_probs_dropout_prob
				__lowerCamelCase  							=      max_position_embeddings
				__lowerCamelCase  							=      type_vocab_size
				__lowerCamelCase  							=      type_sequence_label_size
				__lowerCamelCase  							=      num_labels
				__lowerCamelCase  							=      num_choices
				__lowerCamelCase  							=      scope
				__lowerCamelCase  							=      vocab_size - 1
				__lowerCamelCase  							=      vocab_size - 1
				__lowerCamelCase  							=      vocab_size - 1




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				return RwkvConfig.from_pretrained('''sgugger/rwkv-4-pile-7b'''			)




	def     lowerCamelCase (  self		,			__UpperCAmelCase=False		,			__UpperCAmelCase=False		,			__UpperCAmelCase=False			):



				'''simple docstring'''
				__lowerCamelCase  							=      ids_tensor([self.batch_size, self.seq_length]		,			self.vocab_size			)

				__lowerCamelCase  							=      None
				if self.use_input_mask:
							__lowerCamelCase  							=      random_attention_mask([self.batch_size, self.seq_length]			)

				__lowerCamelCase  							=      None
				if self.use_token_type_ids:
							__lowerCamelCase  							=      ids_tensor([self.batch_size, self.seq_length]		,			self.type_vocab_size			)

				__lowerCamelCase  							=      None
				if self.use_mc_token_ids:
							__lowerCamelCase  							=      ids_tensor([self.batch_size, self.num_choices]		,			self.seq_length			)

				__lowerCamelCase  							=      None
				__lowerCamelCase  							=      None
				__lowerCamelCase  							=      None
				if self.use_labels:
							__lowerCamelCase  							=      ids_tensor([self.batch_size]		,			self.type_sequence_label_size			)
							__lowerCamelCase  							=      ids_tensor([self.batch_size, self.seq_length]		,			self.num_labels			)
							__lowerCamelCase  							=      ids_tensor([self.batch_size]		,			self.num_choices			)

				__lowerCamelCase  							=      self.get_config(
				    gradient_checkpointing=__UpperCAmelCase		,			scale_attn_by_inverse_layer_idx=__UpperCAmelCase		,			reorder_and_upcast_attn=__UpperCAmelCase		,			)

				return (
				    config,
				    input_ids,
				    input_mask,
				    None,
				    token_type_ids,
				    mc_token_ids,
				    sequence_labels,
				    token_labels,
				    choice_labels,
				)




	def     lowerCamelCase (  self		,			__UpperCAmelCase=False		,			__UpperCAmelCase=False		,			__UpperCAmelCase=False			):



				'''simple docstring'''
				return RwkvConfig(
				    vocab_size=self.vocab_size		,			hidden_size=self.hidden_size		,			num_hidden_layers=self.num_hidden_layers		,			intermediate_size=self.intermediate_size		,			activation_function=self.hidden_act		,			resid_pdrop=self.hidden_dropout_prob		,			attn_pdrop=self.attention_probs_dropout_prob		,			n_positions=self.max_position_embeddings		,			type_vocab_size=self.type_vocab_size		,			use_cache=__UpperCAmelCase		,			bos_token_id=self.bos_token_id		,			eos_token_id=self.eos_token_id		,			pad_token_id=self.pad_token_id		,			gradient_checkpointing=__UpperCAmelCase		,			scale_attn_by_inverse_layer_idx=__UpperCAmelCase		,			reorder_and_upcast_attn=__UpperCAmelCase		,			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      self.get_config()
				__lowerCamelCase  							=      300
				return config




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				(
				    __lowerCamelCase       
				)  							=      self.prepare_config_and_inputs()

				__lowerCamelCase  							=      floats_tensor([self.batch_size, self.seq_length, self.hidden_size]			)
				__lowerCamelCase  							=      ids_tensor([self.batch_size, self.seq_length]		,			vocab_size=2			)

				return (
				    config,
				    input_ids,
				    input_mask,
				    head_mask,
				    token_type_ids,
				    sequence_labels,
				    token_labels,
				    choice_labels,
				    encoder_hidden_states,
				    encoder_attention_mask,
				)




	def     lowerCamelCase (  self		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			*__UpperCAmelCase			):



				'''simple docstring'''
				__lowerCamelCase  							=      True
				__lowerCamelCase  							=      RwkvModel(config=__UpperCAmelCase			)
				model.to(__UpperCAmelCase			)
				model.eval()

				__lowerCamelCase  							=      model(__UpperCAmelCase			)

				self.parent.assertEqual(result.last_hidden_state.shape		,			(self.batch_size, self.seq_length, self.hidden_size)			)
				self.parent.assertEqual(len(result.hidden_states			)		,			config.num_hidden_layers + 1			)




	def     lowerCamelCase (  self		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			*__UpperCAmelCase			):



				'''simple docstring'''
				__lowerCamelCase  							=      RwkvForCausalLM(__UpperCAmelCase			)
				model.to(__UpperCAmelCase			)
				model.eval()

				__lowerCamelCase  							=      model(__UpperCAmelCase		,			labels=__UpperCAmelCase			)
				self.parent.assertEqual(result.loss.shape		,			()			)
				self.parent.assertEqual(result.logits.shape		,			(self.batch_size, self.seq_length, self.vocab_size)			)




	def     lowerCamelCase (  self		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			*__UpperCAmelCase			):



				'''simple docstring'''
				__lowerCamelCase  							=      RwkvModel(config=__UpperCAmelCase			)
				model.to(__UpperCAmelCase			)
				model.eval()

				__lowerCamelCase  							=      model(__UpperCAmelCase			)
				__lowerCamelCase  							=      outputs.last_hidden_state

				__lowerCamelCase  							=      model(input_ids[:, :2]			)
				__lowerCamelCase  							=      outputs.last_hidden_state

				# Using the state computed on the first inputs, we will get the same output
				__lowerCamelCase  							=      model(input_ids[:, 2:]		,			state=outputs.state			)
				__lowerCamelCase  							=      outputs.last_hidden_state

				self.parent.assertTrue(torch.allclose(torch.cat([output_one, output_two]		,			dim=1			)		,			__UpperCAmelCase		,			atol=1E-5			)			)




	def     lowerCamelCase (  self		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase		,			*__UpperCAmelCase		,			__UpperCAmelCase=False			):



				'''simple docstring'''
				__lowerCamelCase  							=      RwkvForCausalLM(__UpperCAmelCase			)
				model.to(__UpperCAmelCase			)
				if gradient_checkpointing:
							model.gradient_checkpointing_enable()

				__lowerCamelCase  							=      model(__UpperCAmelCase		,			labels=__UpperCAmelCase			)
				self.parent.assertEqual(result.loss.shape		,			()			)
				self.parent.assertEqual(result.logits.shape		,			(self.batch_size, self.seq_length, self.vocab_size)			)
				result.loss.backward()




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      self.prepare_config_and_inputs()

				(
				    __lowerCamelCase       
				)  							=      config_and_inputs

				__lowerCamelCase  							=      {"input_ids": input_ids}

				return config, inputs_dict



@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0					,		reason="""See https://github.com/huggingface/transformers/pull/24204"""				)
@require_torch
class 	__lowerCAmelCase       (		snake_case_					,		snake_case_					,		snake_case_					,		unittest.TestCase				):
	lowerCAmelCase__       =					(RwkvModel, RwkvForCausalLM) if is_torch_available() else ()
	lowerCAmelCase__       =					(
	    {"""feature-extraction""": RwkvModel, """text-generation""": RwkvForCausalLM} if is_torch_available() else {}
	)
	# all_generative_model_classes = (RwkvForCausalLM,) if is_torch_available() else ()
	lowerCAmelCase__       =					False
	lowerCAmelCase__       =					False
	lowerCAmelCase__       =					False
	lowerCAmelCase__       =					False
	lowerCAmelCase__       =					False  # Rwkv does not support head masking




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      RwkvModelTester(self			)
				__lowerCamelCase  							=      ConfigTester(
				    self		,			config_class=__UpperCAmelCase		,			n_embd=37		,			common_properties=['''hidden_size''', '''num_hidden_layers''']			)




	def     lowerCamelCase (  self		,			__UpperCAmelCase		,			__UpperCAmelCase		,			__UpperCAmelCase=None			):



				'''simple docstring'''


				if isinstance(__UpperCAmelCase		,			torch.Tensor			):
							__lowerCamelCase  							=      member.max().item(), member.min().item()
				elif isinstance(__UpperCAmelCase		,			__UpperCAmelCase			) or isinstance(__UpperCAmelCase		,			__UpperCAmelCase			):
							__lowerCamelCase  							=      max(__UpperCAmelCase			), min(__UpperCAmelCase			)

				if not isinstance(__UpperCAmelCase		,			__UpperCAmelCase			):
							raise TypeError('''container should be a list or tuple'''			)
				elif len(__UpperCAmelCase			) != 2:
							raise ValueError('''container should have 2 elements'''			)

				__lowerCamelCase  							=      container

				__lowerCamelCase  							=      (min_value >= expected_min) and (max_value <= expected_max)

				if not is_inside_interval:
							__lowerCamelCase  							=      "%s not found in %s" % (safe_repr(__UpperCAmelCase			), safe_repr(__UpperCAmelCase			))
							self.fail(self._formatMessage(__UpperCAmelCase		,			__UpperCAmelCase			)			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				self.config_tester.run_common_tests()




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_rwkv_model(*__UpperCAmelCase			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_causl_lm(*__UpperCAmelCase			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_state_equivalency(*__UpperCAmelCase			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							__lowerCamelCase  							=      model_class(config=__UpperCAmelCase			)
							for name, param in model.named_parameters():
										if "time_decay" in name:
													if param.requires_grad:
																self.assertTrue(param.data.max().item() == 3.0			)
																self.assertTrue(param.data.min().item() == -5.0			)
										elif "time_first" in name:
													if param.requires_grad:
																# check if it's a ones like
																self.assertTrue(torch.allclose(param.data		,			torch.ones_like(param.data			)		,			atol=1E-5		,			rtol=1E-5			)			)
										elif any(x in name for x in ['''time_mix_key''', '''time_mix_receptance''']			):
													if param.requires_grad:
																self.assertInterval(
																    param.data		,			[0.0, 1.0]		,			msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""		,			)
										elif "time_mix_value" in name:
													if param.requires_grad:
																self.assertInterval(
																    param.data		,			[0.0, 1.3]		,			msg=F"""Parameter {name} of model {model_class} seems not properly initialized"""		,			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      self.model_tester.prepare_config_and_inputs_for_common()
				__lowerCamelCase  							=      True

				__lowerCamelCase  							=      getattr(self.model_tester		,			'''seq_length'''		,			__UpperCAmelCase			)

				for model_class in self.all_model_classes:
							__lowerCamelCase  							=      True
							__lowerCamelCase  							=      False
							__lowerCamelCase  							=      True
							__lowerCamelCase  							=      model_class(__UpperCAmelCase			)
							model.to(__UpperCAmelCase			)
							model.eval()

							__lowerCamelCase  							=      self._prepare_for_class(__UpperCAmelCase		,			__UpperCAmelCase			)
							__lowerCamelCase  							=      inputs["input_ids"].shape[0]
							with torch.no_grad():
										__lowerCamelCase  							=      model(**__UpperCAmelCase			)
							__lowerCamelCase  							=      outputs.attentions
							self.assertEqual(len(__UpperCAmelCase			)		,			self.model_tester.num_hidden_layers			)

							# check that output_attentions also work using config
							del inputs_dict["output_attentions"]
							__lowerCamelCase  							=      True
							__lowerCamelCase  							=      model_class(__UpperCAmelCase			)
							model.to(__UpperCAmelCase			)
							model.eval()

							__lowerCamelCase  							=      self._prepare_for_class(__UpperCAmelCase		,			__UpperCAmelCase			)
							__lowerCamelCase  							=      inputs["input_ids"].shape[0]
							with torch.no_grad():
										__lowerCamelCase  							=      model(**__UpperCAmelCase			)
							__lowerCamelCase  							=      outputs.attentions
							self.assertEqual(len(__UpperCAmelCase			)		,			self.model_tester.num_hidden_layers			)

							self.assertListEqual(
							    list(attentions[0].shape[-3:]			)		,			[batch_size, seq_len, config.hidden_size]		,			)
							__lowerCamelCase  							=      len(__UpperCAmelCase			)

							# Check attention is always last and order is fine
							__lowerCamelCase  							=      True
							__lowerCamelCase  							=      True
							__lowerCamelCase  							=      model_class(__UpperCAmelCase			)
							model.to(__UpperCAmelCase			)
							model.eval()

							__lowerCamelCase  							=      self._prepare_for_class(__UpperCAmelCase		,			__UpperCAmelCase			)
							__lowerCamelCase  							=      inputs["input_ids"].shape[0]
							with torch.no_grad():
										__lowerCamelCase  							=      model(**__UpperCAmelCase			)

							__lowerCamelCase  							=      1
							self.assertEqual(out_len + added_hidden_states		,			len(__UpperCAmelCase			)			)

							__lowerCamelCase  							=      outputs.attentions

							self.assertEqual(len(__UpperCAmelCase			)		,			self.model_tester.num_hidden_layers			)
							self.assertListEqual(
							    list(self_attentions[0].shape[-3:]			)		,			[batch_size, seq_len, config.hidden_size]		,			)




	@slow
	def     lowerCamelCase (  self			):



				'''simple docstring'''


				for model_name in RWKV_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							__lowerCamelCase  							=      RwkvModel.from_pretrained(__UpperCAmelCase			)
							self.assertIsNotNone(__UpperCAmelCase			)



@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0					,		reason="""See https://github.com/huggingface/transformers/pull/24204"""				)
@slow
class 	__lowerCAmelCase       (		unittest.TestCase				):




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      "RWKV/rwkv-4-169m-pile"
				__lowerCamelCase  							=      AutoTokenizer.from_pretrained(self.model_id			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      "Hello my name is Jasmine and I am a newbie to the"
				__lowerCamelCase  							=      RwkvForCausalLM.from_pretrained(self.model_id			).to(__UpperCAmelCase			)

				__lowerCamelCase  							=      self.tokenizer('''Hello my name is'''		,			return_tensors='''pt'''			).input_ids.to(__UpperCAmelCase			)
				__lowerCamelCase  							=      model.generate(__UpperCAmelCase		,			max_new_tokens=10			)
				__lowerCamelCase  							=      self.tokenizer.decode(output[0].tolist()			)

				self.assertEqual(__UpperCAmelCase		,			__UpperCAmelCase			)




	def     lowerCamelCase (  self			):



				'''simple docstring'''
				__lowerCamelCase  							=      "Hello my name is Jasmine and I am a newbie to the"

				__lowerCamelCase  							=      self.tokenizer('''Hello my name is'''		,			return_tensors='''pt'''			).input_ids.to(__UpperCAmelCase			)
				__lowerCamelCase  							=      RwkvForCausalLM.from_pretrained(self.model_id		,			torch_dtype=torch.bfloataa			).to(__UpperCAmelCase			)

				__lowerCamelCase  							=      model.generate(__UpperCAmelCase		,			max_new_tokens=10			)
				__lowerCamelCase  							=      self.tokenizer.decode(output[0].tolist()			)

				self.assertEqual(__UpperCAmelCase		,			__UpperCAmelCase			)











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 	__lowerCAmelCase       (		unittest.TestCase				):




 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.02		,			__UpperCAmelCase=4		,			):



    '''simple docstring'''
    __lowerCamelCase  							=      parent
    __lowerCamelCase  							=      batch_size
    __lowerCamelCase  							=      seq_length
    __lowerCamelCase  							=      is_training
    __lowerCamelCase  							=      use_attention_mask
    __lowerCamelCase  							=      use_token_type_ids
    __lowerCamelCase  							=      use_labels
    __lowerCamelCase  							=      vocab_size
    __lowerCamelCase  							=      hidden_size
    __lowerCamelCase  							=      embedding_size
    __lowerCamelCase  							=      num_hidden_layers
    __lowerCamelCase  							=      num_attention_heads
    __lowerCamelCase  							=      intermediate_size
    __lowerCamelCase  							=      hidden_act
    __lowerCamelCase  							=      hidden_dropout_prob
    __lowerCamelCase  							=      attention_probs_dropout_prob
    __lowerCamelCase  							=      max_position_embeddings
    __lowerCamelCase  							=      type_vocab_size
    __lowerCamelCase  							=      type_sequence_label_size
    __lowerCamelCase  							=      initializer_range
    __lowerCamelCase  							=      num_choices




 def     lowerCamelCase (  self			):



    '''simple docstring'''
    __lowerCamelCase  							=      ids_tensor([self.batch_size, self.seq_length]		,			self.vocab_size			)

    __lowerCamelCase  							=      None
    if self.use_attention_mask:
       __lowerCamelCase  							=      random_attention_mask([self.batch_size, self.seq_length]			)

    __lowerCamelCase  							=      None
    if self.use_token_type_ids:
       __lowerCamelCase  							=      ids_tensor([self.batch_size, self.seq_length]		,			self.type_vocab_size			)

    __lowerCamelCase  							=      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     lowerCamelCase (  self			):



    '''simple docstring'''
    __lowerCamelCase  							=      self.prepare_config_and_inputs()
    __lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase							,__lowerCamelCase  							=      config_and_inputs
    __lowerCamelCase  							=      {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
    return config, inputs_dict



@require_flax
class 	__lowerCAmelCase       (		lowerCAmelCase__					,		unittest.TestCase				):
 lowerCAmelCase__       =					True

 lowerCAmelCase__       =					(
     (
         FlaxElectraModel,
         FlaxElectraForCausalLM,
         FlaxElectraForMaskedLM,
         FlaxElectraForPreTraining,
         FlaxElectraForTokenClassification,
         FlaxElectraForQuestionAnswering,
         FlaxElectraForMultipleChoice,
         FlaxElectraForSequenceClassification,
     )
     if is_flax_available()
     else ()
 )




 def     lowerCamelCase (  self			):



    '''simple docstring'''
    __lowerCamelCase  							=      FlaxElectraModelTester(self			)




 @slow
 def     lowerCamelCase (  self			):



    '''simple docstring'''
    for model_class_name in self.all_model_classes:
       if model_class_name == FlaxElectraForMaskedLM:
          __lowerCamelCase  							=      model_class_name.from_pretrained('''google/electra-small-generator'''			)
       else:
          __lowerCamelCase  							=      model_class_name.from_pretrained('''google/electra-small-discriminator'''			)
       __lowerCamelCase  							=      model(np.ones((1, 1)			)			)
       self.assertIsNotNone(__UpperCAmelCase			)






