"""simple docstring"""




import unittest

from transformers import ElectraConfig, is_torch_available
from transformers.models.auto import get_values
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 (
					    MODEL_FOR_PRETRAINING_MAPPING,
					    ElectraForCausalLM,
					    ElectraForMaskedLM,
					    ElectraForMultipleChoice,
					    ElectraForPreTraining,
					    ElectraForQuestionAnswering,
					    ElectraForSequenceClassification,
					    ElectraForTokenClassification,
					    ElectraModel,
					)
					from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST

class        __SCREAMING_SNAKE_CASE     :







				def __init__(    self    :int      ,__UpperCAmelCase    :Tuple      ,__UpperCAmelCase    :Optional[Any]=13      ,__UpperCAmelCase    :str=7      ,__UpperCAmelCase    :Dict=True      ,__UpperCAmelCase    :Dict=True      ,__UpperCAmelCase    :List[str]=True      ,__UpperCAmelCase    :Any=True      ,__UpperCAmelCase    :Optional[int]=99      ,__UpperCAmelCase    :Optional[int]=32      ,__UpperCAmelCase    :Dict=5      ,__UpperCAmelCase    :Dict=4      ,__UpperCAmelCase    :Optional[int]=37      ,__UpperCAmelCase    :str="gelu"      ,__UpperCAmelCase    :Tuple=0.1      ,__UpperCAmelCase    :Dict=0.1      ,__UpperCAmelCase    :Optional[int]=5_12      ,__UpperCAmelCase    :List[str]=16      ,__UpperCAmelCase    :Union[str, Any]=2      ,__UpperCAmelCase    :str=0.02      ,__UpperCAmelCase    :Any=3      ,__UpperCAmelCase    :Optional[Any]=4      ,__UpperCAmelCase    :int=None      ,)      ->					Any:




									"""simple docstring"""



									lowerCamelCase__		:   Dict  				=					parent
									lowerCamelCase__		:   Tuple  				=					batch_size
									lowerCamelCase__		:   int  				=					seq_length
									lowerCamelCase__		:   int  				=					is_training
									lowerCamelCase__		:   Optional[int]  				=					use_input_mask
									lowerCamelCase__		:   Dict  				=					use_token_type_ids
									lowerCamelCase__		:   Dict  				=					use_labels
									lowerCamelCase__		:   Optional[int]  				=					vocab_size
									lowerCamelCase__		:   int  				=					hidden_size
									lowerCamelCase__		:   List[Any]  				=					num_hidden_layers
									lowerCamelCase__		:   Dict  				=					num_attention_heads
									lowerCamelCase__		:   Optional[int]  				=					intermediate_size
									lowerCamelCase__		:   Dict  				=					hidden_act
									lowerCamelCase__		:   str  				=					hidden_dropout_prob
									lowerCamelCase__		:   List[Any]  				=					attention_probs_dropout_prob
									lowerCamelCase__		:   Dict  				=					max_position_embeddings
									lowerCamelCase__		:   List[Any]  				=					type_vocab_size
									lowerCamelCase__		:   Any  				=					type_sequence_label_size
									lowerCamelCase__		:   List[str]  				=					initializer_range
									lowerCamelCase__		:   str  				=					num_labels
									lowerCamelCase__		:   Tuple  				=					num_choices
									lowerCamelCase__		:   Optional[Any]  				=					scope







				def   lowercase_		(    self    :List[Any]  )      ->					int:




									"""simple docstring"""



									lowerCamelCase__		:   Dict  				=					ids_tensor([self.batch_size, self.seq_length]      ,self.vocab_size  )

									lowerCamelCase__		:   Union[str, Any]  				=					None
									if self.use_input_mask:
														lowerCamelCase__		:   Tuple  				=					random_attention_mask([self.batch_size, self.seq_length]  )

									lowerCamelCase__		:   Union[str, Any]  				=					None
									if self.use_token_type_ids:
														lowerCamelCase__		:   Dict  				=					ids_tensor([self.batch_size, self.seq_length]      ,self.type_vocab_size  )

									lowerCamelCase__		:   str  				=					None
									lowerCamelCase__		:   Dict  				=					None
									lowerCamelCase__		:   List[Any]  				=					None
									if self.use_labels:
														lowerCamelCase__		:   Dict  				=					ids_tensor([self.batch_size]      ,self.type_sequence_label_size  )
														lowerCamelCase__		:   Optional[Any]  				=					ids_tensor([self.batch_size, self.seq_length]      ,self.num_labels  )
														lowerCamelCase__		:   int  				=					ids_tensor([self.batch_size]      ,self.num_choices  )
														lowerCamelCase__		:   List[str]  				=					ids_tensor([self.batch_size, self.seq_length]      ,1  )

									lowerCamelCase__		:   Optional[int]  				=					self.get_config()

									return (
									    config,
									    input_ids,
									    token_type_ids,
									    input_mask,
									    sequence_labels,
									    token_labels,
									    choice_labels,
									    fake_token_labels,
									)







				def   lowercase_		(    self    :List[str]  )      ->					Optional[Any]:




									"""simple docstring"""



									return ElectraConfig(
									    vocab_size=self.vocab_size      ,hidden_size=self.hidden_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=__UpperCAmelCase      ,initializer_range=self.initializer_range      ,)







				def   lowercase_		(    self    :Union[str, Any]  )      ->					Optional[int]:




									"""simple docstring"""



									(
									    (
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						
									)		:   Union[str, Any]  				=					self.prepare_config_and_inputs()

									lowerCamelCase__		:   Tuple  				=					True
									lowerCamelCase__		:   Optional[int]  				=					floats_tensor([self.batch_size, self.seq_length, self.hidden_size]  )
									lowerCamelCase__		:   str  				=					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    :Optional[int]      ,__UpperCAmelCase    :Any      ,__UpperCAmelCase    :List[str]      ,__UpperCAmelCase    :Tuple      ,__UpperCAmelCase    :Union[str, Any]      ,__UpperCAmelCase    :Dict      ,__UpperCAmelCase    :List[Any]      ,__UpperCAmelCase    :Any      ,__UpperCAmelCase    :Optional[Any]      ,)      ->					Any:




									"""simple docstring"""



									lowerCamelCase__		:   int  				=					ElectraModel(config=__UpperCAmelCase  )
									model.to(__UpperCAmelCase  )
									model.eval()
									lowerCamelCase__		:   Any  				=					model(__UpperCAmelCase      ,attention_mask=__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase  )
									lowerCamelCase__		:   Union[str, Any]  				=					model(__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase  )
									lowerCamelCase__		:   Optional[Any]  				=					model(__UpperCAmelCase  )
									self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, self.seq_length, self.hidden_size)  )







				def   lowercase_		(    self    :Optional[int]      ,__UpperCAmelCase    :Any      ,__UpperCAmelCase    :Optional[int]      ,__UpperCAmelCase    :List[str]      ,__UpperCAmelCase    :Optional[Any]      ,__UpperCAmelCase    :Tuple      ,__UpperCAmelCase    :str      ,__UpperCAmelCase    :List[Any]      ,__UpperCAmelCase    :Optional[Any]      ,__UpperCAmelCase    :Optional[int]      ,)      ->					Any:




									"""simple docstring"""



									lowerCamelCase__		:   Dict  				=					True
									lowerCamelCase__		:   Dict  				=					ElectraModel(__UpperCAmelCase  )
									model.to(__UpperCAmelCase  )
									model.eval()
									lowerCamelCase__		:   List[Any]  				=					model(
									    __UpperCAmelCase      ,attention_mask=__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase      ,encoder_hidden_states=__UpperCAmelCase      ,encoder_attention_mask=__UpperCAmelCase      ,)
									lowerCamelCase__		:   List[str]  				=					model(
									    __UpperCAmelCase      ,attention_mask=__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase      ,encoder_hidden_states=__UpperCAmelCase      ,)
									lowerCamelCase__		:   Optional[Any]  				=					model(__UpperCAmelCase      ,attention_mask=__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase  )
									self.parent.assertEqual(result.last_hidden_state.shape      ,(self.batch_size, self.seq_length, self.hidden_size)  )







				def   lowercase_		(    self    :int      ,__UpperCAmelCase    :List[str]      ,__UpperCAmelCase    :List[Any]      ,__UpperCAmelCase    :Optional[int]      ,__UpperCAmelCase    :Dict      ,__UpperCAmelCase    :List[Any]      ,__UpperCAmelCase    :List[Any]      ,__UpperCAmelCase    :str      ,__UpperCAmelCase    :Union[str, Any]      ,)      ->					Union[str, Any]:




									"""simple docstring"""



									lowerCamelCase__		:   Tuple  				=					ElectraForMaskedLM(config=__UpperCAmelCase  )
									model.to(__UpperCAmelCase  )
									model.eval()
									lowerCamelCase__		:   Any  				=					model(__UpperCAmelCase      ,attention_mask=__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase      ,labels=__UpperCAmelCase  )
									self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.vocab_size)  )







				def   lowercase_		(    self    :Dict      ,__UpperCAmelCase    :List[str]      ,__UpperCAmelCase    :List[Any]      ,__UpperCAmelCase    :List[str]      ,__UpperCAmelCase    :Union[str, Any]      ,__UpperCAmelCase    :Optional[int]      ,__UpperCAmelCase    :Optional[Any]      ,__UpperCAmelCase    :Optional[Any]      ,__UpperCAmelCase    :List[Any]      ,__UpperCAmelCase    :Tuple      ,)      ->					Union[str, Any]:




									"""simple docstring"""



									lowerCamelCase__		:   Union[str, Any]  				=					ElectraForCausalLM(config=__UpperCAmelCase  )
									model.to(__UpperCAmelCase  )
									model.eval()
									lowerCamelCase__		:   List[Any]  				=					model(__UpperCAmelCase      ,attention_mask=__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase      ,labels=__UpperCAmelCase  )
									self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.vocab_size)  )







				def   lowercase_		(    self    :List[Any]      ,__UpperCAmelCase    :Any      ,__UpperCAmelCase    :List[str]      ,__UpperCAmelCase    :str      ,__UpperCAmelCase    :Dict      ,__UpperCAmelCase    :int      ,__UpperCAmelCase    :Optional[int]      ,__UpperCAmelCase    :int      ,__UpperCAmelCase    :Tuple      ,)      ->					List[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   str  				=					self.num_labels
									lowerCamelCase__		:   Any  				=					ElectraForTokenClassification(config=__UpperCAmelCase  )
									model.to(__UpperCAmelCase  )
									model.eval()
									lowerCamelCase__		:   Union[str, Any]  				=					model(__UpperCAmelCase      ,attention_mask=__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase      ,labels=__UpperCAmelCase  )
									self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length, self.num_labels)  )







				def   lowercase_		(    self    :Any      ,__UpperCAmelCase    :List[Any]      ,__UpperCAmelCase    :Union[str, Any]      ,__UpperCAmelCase    :Dict      ,__UpperCAmelCase    :List[str]      ,__UpperCAmelCase    :Optional[int]      ,__UpperCAmelCase    :int      ,__UpperCAmelCase    :List[str]      ,__UpperCAmelCase    :Optional[Any]      ,)      ->					List[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   List[Any]  				=					self.num_labels
									lowerCamelCase__		:   Union[str, Any]  				=					ElectraForPreTraining(config=__UpperCAmelCase  )
									model.to(__UpperCAmelCase  )
									model.eval()
									lowerCamelCase__		:   Optional[int]  				=					model(__UpperCAmelCase      ,attention_mask=__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase      ,labels=__UpperCAmelCase  )
									self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.seq_length)  )







				def   lowercase_		(    self    :Optional[int]      ,__UpperCAmelCase    :List[str]      ,__UpperCAmelCase    :Optional[Any]      ,__UpperCAmelCase    :str      ,__UpperCAmelCase    :List[str]      ,__UpperCAmelCase    :Union[str, Any]      ,__UpperCAmelCase    :Dict      ,__UpperCAmelCase    :Union[str, Any]      ,__UpperCAmelCase    :Any      ,)      ->					Tuple:




									"""simple docstring"""



									lowerCamelCase__		:   List[Any]  				=					self.num_labels
									lowerCamelCase__		:   Any  				=					ElectraForSequenceClassification(__UpperCAmelCase  )
									model.to(__UpperCAmelCase  )
									model.eval()
									lowerCamelCase__		:   Optional[Any]  				=					model(__UpperCAmelCase      ,attention_mask=__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase      ,labels=__UpperCAmelCase  )
									self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.num_labels)  )







				def   lowercase_		(    self    :Optional[int]      ,__UpperCAmelCase    :Dict      ,__UpperCAmelCase    :int      ,__UpperCAmelCase    :Union[str, Any]      ,__UpperCAmelCase    :Any      ,__UpperCAmelCase    :Optional[int]      ,__UpperCAmelCase    :int      ,__UpperCAmelCase    :Tuple      ,__UpperCAmelCase    :List[Any]      ,)      ->					Optional[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   List[str]  				=					ElectraForQuestionAnswering(config=__UpperCAmelCase  )
									model.to(__UpperCAmelCase  )
									model.eval()
									lowerCamelCase__		:   Union[str, Any]  				=					model(
									    __UpperCAmelCase      ,attention_mask=__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase      ,start_positions=__UpperCAmelCase      ,end_positions=__UpperCAmelCase      ,)
									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    :Optional[int]      ,__UpperCAmelCase    :Optional[int]      ,__UpperCAmelCase    :int      ,__UpperCAmelCase    :List[Any]      ,__UpperCAmelCase    :Optional[Any]      ,__UpperCAmelCase    :List[str]      ,__UpperCAmelCase    :Tuple      ,__UpperCAmelCase    :Tuple      ,__UpperCAmelCase    :Dict      ,)      ->					int:




									"""simple docstring"""



									lowerCamelCase__		:   List[Any]  				=					self.num_choices
									lowerCamelCase__		:   Union[str, Any]  				=					ElectraForMultipleChoice(config=__UpperCAmelCase  )
									model.to(__UpperCAmelCase  )
									model.eval()
									lowerCamelCase__		:   Dict  				=					input_ids.unsqueeze(1  ).expand(-1      ,self.num_choices      ,-1  ).contiguous()
									lowerCamelCase__		:   Optional[Any]  				=					token_type_ids.unsqueeze(1  ).expand(-1      ,self.num_choices      ,-1  ).contiguous()
									lowerCamelCase__		:   Optional[Any]  				=					input_mask.unsqueeze(1  ).expand(-1      ,self.num_choices      ,-1  ).contiguous()
									lowerCamelCase__		:   Optional[Any]  				=					model(
									    __UpperCAmelCase      ,attention_mask=__UpperCAmelCase      ,token_type_ids=__UpperCAmelCase      ,labels=__UpperCAmelCase      ,)
									self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.num_choices)  )







				def   lowercase_		(    self    :int  )      ->					Any:




									"""simple docstring"""



									lowerCamelCase__		:   List[str]  				=					self.prepare_config_and_inputs()
									(
									    (
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						(
									    lowerCamelCase__
									)				,						
									)		:   List[Any]  				=					config_and_inputs
									lowerCamelCase__		:   Optional[Any]  				=					{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
									return config, inputs_dict





@require_torch
class        __SCREAMING_SNAKE_CASE     (   _lowerCAmelCase						,       _lowerCAmelCase						,       unittest.TestCase							):
				UpperCAmelCase	=      (
				    (
				        ElectraModel,
				        ElectraForPreTraining,
				        ElectraForMaskedLM,
				        ElectraForCausalLM,
				        ElectraForMultipleChoice,
				        ElectraForTokenClassification,
				        ElectraForSequenceClassification,
				        ElectraForQuestionAnswering,
				    )
				    if is_torch_available()
				    else ()
				)
				UpperCAmelCase	=      (
				    {
				        '''feature-extraction''': ElectraModel,
				        '''fill-mask''': ElectraForMaskedLM,
				        '''question-answering''': ElectraForQuestionAnswering,
				        '''text-classification''': ElectraForSequenceClassification,
				        '''text-generation''': ElectraForCausalLM,
				        '''token-classification''': ElectraForTokenClassification,
				        '''zero-shot''': ElectraForSequenceClassification,
				    }
				    if is_torch_available()
				    else {}
				)
				UpperCAmelCase	=      True







				def   lowercase_		(    self    :str      ,__UpperCAmelCase    :Dict      ,__UpperCAmelCase    :Union[str, Any]      ,__UpperCAmelCase    :List[str]=False  )      ->					Dict:




									"""simple docstring"""



									lowerCamelCase__		:   List[Any]  				=					super()._prepare_for_class(__UpperCAmelCase      ,__UpperCAmelCase      ,return_labels=__UpperCAmelCase  )

									if return_labels:
														if model_class in get_values(__UpperCAmelCase  ):
																			lowerCamelCase__		:   List[str]  				=					torch.zeros(
																			    (self.model_tester.batch_size, self.model_tester.seq_length)      ,dtype=torch.long      ,device=__UpperCAmelCase  )
									return inputs_dict







				def   lowercase_		(    self    :Tuple  )      ->					List[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   str  				=					ElectraModelTester(self  )
									lowerCamelCase__		:   Any  				=					ConfigTester(self      ,config_class=__UpperCAmelCase      ,hidden_size=37  )







				def   lowercase_		(    self    :Union[str, Any]  )      ->					Optional[int]:




									"""simple docstring"""



									self.config_tester.run_common_tests()







				def   lowercase_		(    self    :int  )      ->					Any:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_model(*__UpperCAmelCase  )







				def   lowercase_		(    self    :Union[str, Any]  )      ->					int:




									"""simple docstring"""



									lowerCamelCase__		:   Dict  				=					self.model_tester.prepare_config_and_inputs_for_decoder()
									self.model_tester.create_and_check_electra_model_as_decoder(*__UpperCAmelCase  )







				def   lowercase_		(    self    :Union[str, Any]  )      ->					Optional[int]:




									"""simple docstring"""



									lowerCamelCase__		:   str  				=					self.model_tester.prepare_config_and_inputs()
									for type in ["absolute", "relative_key", "relative_key_query"]:
														lowerCamelCase__		:   int  				=					type
														self.model_tester.create_and_check_electra_model(*__UpperCAmelCase  )







				def   lowercase_		(    self    :int  )      ->					List[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   List[Any]  				=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_masked_lm(*__UpperCAmelCase  )







				def   lowercase_		(    self    :Tuple  )      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_token_classification(*__UpperCAmelCase  )







				def   lowercase_		(    self    :Tuple  )      ->					List[str]:




									"""simple docstring"""



									lowerCamelCase__		:   int  				=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_pretraining(*__UpperCAmelCase  )







				def   lowercase_		(    self    :int  )      ->					Dict:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_sequence_classification(*__UpperCAmelCase  )







				def   lowercase_		(    self    :str  )      ->					Tuple:




									"""simple docstring"""



									lowerCamelCase__		:   Union[str, Any]  				=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_question_answering(*__UpperCAmelCase  )







				def   lowercase_		(    self    :int  )      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   Any  				=					self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_electra_for_multiple_choice(*__UpperCAmelCase  )







				@slow
				def   lowercase_		(    self    :Any  )      ->					Union[str, Any]:




									"""simple docstring"""



									for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
														lowerCamelCase__		:   int  				=					ElectraModel.from_pretrained(__UpperCAmelCase  )
														self.assertIsNotNone(__UpperCAmelCase  )







				def   lowercase_		(    self    :Optional[int]  )      ->					Dict:




									"""simple docstring"""



									lowerCamelCase__		:   List[Any]  				=					self.model_tester.prepare_config_and_inputs_for_decoder()
									self.model_tester.create_and_check_electra_for_causal_lm(*__UpperCAmelCase  )





@require_torch
class        __SCREAMING_SNAKE_CASE     (   unittest.TestCase							):







				@slow
				def   lowercase_		(    self    :Any  )      ->					List[str]:




									"""simple docstring"""



									lowerCamelCase__		:   List[str]  				=					ElectraModel.from_pretrained('''google/electra-small-discriminator'''  )
									lowerCamelCase__		:   Optional[Any]  				=					torch.tensor([[0, 3_45, 2_32, 3_28, 7_40, 1_40, 16_95, 69, 60_78, 15_88, 2]]  )
									lowerCamelCase__		:   Optional[Any]  				=					torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]  )
									lowerCamelCase__		:   Any  				=					model(__UpperCAmelCase      ,attention_mask=__UpperCAmelCase  )[0]
									lowerCamelCase__		:   Optional[Any]  				=					torch.Size((1, 11, 2_56)  )
									self.assertEqual(output.shape      ,__UpperCAmelCase  )
									lowerCamelCase__		:   str  				=					torch.tensor(
									    [[[0.4_471, 0.6_821, -0.3_265], [0.4_627, 0.5_255, -0.3_668], [0.4_532, 0.3_313, -0.4_344]]]  )

									self.assertTrue(torch.allclose(output[:, 1:4, 1:4]      ,__UpperCAmelCase      ,atol=1E-4  )  )







"""simple docstring"""




import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
					from tokenizers import Tokenizer
					from tokenizers.models import WordPiece

class        __SCREAMING_SNAKE_CASE     (   unittest.TestCase							):







				def   lowercase_		(    self    :Optional[Any]      ,__UpperCAmelCase    :Dict  )      ->					Optional[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   Dict  				=					list(tokenizer_class.max_model_input_sizes.keys()  )
									for model_name in sa_models[:1]:
														lowerCamelCase__		:   Tuple  				=					tokenizer_class.from_pretrained(__UpperCAmelCase  )
														self.assertIsNotNone(__UpperCAmelCase  )
														self.assertIsInstance(__UpperCAmelCase      ,__UpperCAmelCase  )
														self.assertIsInstance(__UpperCAmelCase      ,__UpperCAmelCase  )

														for special_tok in tokenizer.all_special_tokens:
																			self.assertIsInstance(__UpperCAmelCase      ,__UpperCAmelCase  )
																			lowerCamelCase__		:   str  				=					tokenizer.convert_tokens_to_ids(__UpperCAmelCase  )
																			self.assertIsInstance(__UpperCAmelCase      ,__UpperCAmelCase  )







				def   lowercase_		(    self    :Any      ,__UpperCAmelCase    :BatchEncoding      ,__UpperCAmelCase    :Optional[Callable] = None  )      ->					Optional[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   List[str]  				=					pickle.dumps(__UpperCAmelCase  )
									self.assertIsNotNone(__UpperCAmelCase  )

									lowerCamelCase__		:   int  				=					pickle.loads(__UpperCAmelCase  )

									# Ensure is_fast is correctly restored
									self.assertEqual(be_restored.is_fast      ,be_original.is_fast  )

									# Ensure encodings are potentially correctly restored
									if be_original.is_fast:
														self.assertIsNotNone(be_restored.encodings  )
									else:
														self.assertIsNone(be_restored.encodings  )

									# Ensure the keys are the same
									for original_v, restored_v in zip(be_original.values()      ,be_restored.values()  ):
														if equal_op:
																			self.assertTrue(equal_op(__UpperCAmelCase      ,__UpperCAmelCase  )  )
														else:
																			self.assertEqual(__UpperCAmelCase      ,__UpperCAmelCase  )







				@slow
				def   lowercase_		(    self    :Tuple  )      ->					List[str]:




									"""simple docstring"""



									self.check_tokenizer_from_pretrained(__UpperCAmelCase  )







				def   lowercase_		(    self    :Optional[int]  )      ->					int:




									"""simple docstring"""



									self.assertEqual(TensorType('''tf'''  )      ,TensorType.TENSORFLOW  )
									self.assertEqual(TensorType('''pt'''  )      ,TensorType.PYTORCH  )
									self.assertEqual(TensorType('''np'''  )      ,TensorType.NUMPY  )







				@require_tokenizers
				def   lowercase_		(    self    :List[Any]  )      ->					Optional[Any]:




									"""simple docstring"""



									import numpy as np

									lowerCamelCase__		:   Any  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )
									lowerCamelCase__		:   Optional[int]  				=					BertTokenizerFast.from_pretrained('''bert-base-cased'''  )

									# Python no tensor
									with self.subTest('''BatchEncoding (Python, return_tensors=None)'''  ):
														self.assert_dump_and_restore(tokenizer_p('''Small example to encode'''  )  )

									with self.subTest('''BatchEncoding (Python, return_tensors=NUMPY)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_p('''Small example to encode'''      ,return_tensors=TensorType.NUMPY  )      ,np.array_equal  )

									with self.subTest('''BatchEncoding (Rust, return_tensors=None)'''  ):
														self.assert_dump_and_restore(tokenizer_r('''Small example to encode'''  )  )

									with self.subTest('''BatchEncoding (Rust, return_tensors=NUMPY)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_r('''Small example to encode'''      ,return_tensors=TensorType.NUMPY  )      ,np.array_equal  )







				@require_tf
				@require_tokenizers
				def   lowercase_		(    self    :Optional[int]  )      ->					int:




									"""simple docstring"""



									import tensorflow as tf

									def tf_array_equals(__UpperCAmelCase    :List[Any]      ,__UpperCAmelCase    :List[Any]  ):
														return tf.reduce_all(tf.equal(__UpperCAmelCase      ,__UpperCAmelCase  )  )

									lowerCamelCase__		:   str  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )
									lowerCamelCase__		:   List[Any]  				=					BertTokenizerFast.from_pretrained('''bert-base-cased'''  )

									with self.subTest('''BatchEncoding (Python, return_tensors=TENSORFLOW)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_p('''Small example to encode'''      ,return_tensors=TensorType.TENSORFLOW  )      ,__UpperCAmelCase  )

									with self.subTest('''BatchEncoding (Rust, return_tensors=TENSORFLOW)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_r('''Small example to encode'''      ,return_tensors=TensorType.TENSORFLOW  )      ,__UpperCAmelCase  )







				@require_torch
				@require_tokenizers
				def   lowercase_		(    self    :Dict  )      ->					Optional[int]:




									"""simple docstring"""



									import torch

									lowerCamelCase__		:   Optional[int]  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )
									lowerCamelCase__		:   List[str]  				=					BertTokenizerFast.from_pretrained('''bert-base-cased'''  )

									with self.subTest('''BatchEncoding (Python, return_tensors=PYTORCH)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_p('''Small example to encode'''      ,return_tensors=TensorType.PYTORCH  )      ,torch.equal  )

									with self.subTest('''BatchEncoding (Rust, return_tensors=PYTORCH)'''  ):
														self.assert_dump_and_restore(
														    tokenizer_r('''Small example to encode'''      ,return_tensors=TensorType.PYTORCH  )      ,torch.equal  )







				@require_tokenizers
				def   lowercase_		(    self    :Tuple  )      ->					List[str]:




									"""simple docstring"""



									lowerCamelCase__		:   Dict  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )
									lowerCamelCase__		:   Any  				=					BertTokenizerFast.from_pretrained('''bert-base-cased'''  )

									with self.subTest('''Python Tokenizer'''  ):
														self.assertFalse(tokenizer_p('''Small example to_encode'''  ).is_fast  )

									with self.subTest('''Rust Tokenizer'''  ):
														self.assertTrue(tokenizer_r('''Small example to_encode'''  ).is_fast  )







				@require_tokenizers
				def   lowercase_		(    self    :List[str]  )      ->					str:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					BertTokenizerFast.from_pretrained('''bert-base-cased'''  )
									lowerCamelCase__		:   str  				=					tokenizer_r(['''Test''', '''\xad''', '''test''']      ,is_split_into_words=__UpperCAmelCase  )

									self.assertEqual(encoded.word_to_tokens(0  )      ,TokenSpan(start=1      ,end=2  )  )
									self.assertEqual(encoded.word_to_tokens(1  )      ,__UpperCAmelCase  )
									self.assertEqual(encoded.word_to_tokens(2  )      ,TokenSpan(start=2      ,end=3  )  )







				def   lowercase_		(    self    :Dict  )      ->					Optional[int]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[int]  				=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}  )
									lowerCamelCase__		:   Tuple  				=					batch.convert_to_tensors(tensor_type='''np'''  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(2, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(2,)  )
									# test converting the converted
									with CaptureStderr() as cs:
														lowerCamelCase__		:   List[str]  				=					batch.convert_to_tensors(tensor_type='''np'''  )
									self.assertFalse(len(cs.err  )      ,msg=F"""should have no warning, but got {cs.err}"""  )

									lowerCamelCase__		:   Union[str, Any]  				=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}  )
									lowerCamelCase__		:   Dict  				=					batch.convert_to_tensors(tensor_type='''np'''      ,prepend_batch_axis=__UpperCAmelCase  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(1, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(1,)  )







				@require_torch
				def   lowercase_		(    self    :Optional[int]  )      ->					List[Any]:




									"""simple docstring"""



									lowerCamelCase__		:   List[Any]  				=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}  )
									lowerCamelCase__		:   Any  				=					batch.convert_to_tensors(tensor_type='''pt'''  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(2, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(2,)  )
									# test converting the converted
									with CaptureStderr() as cs:
														lowerCamelCase__		:   Optional[int]  				=					batch.convert_to_tensors(tensor_type='''pt'''  )
									self.assertFalse(len(cs.err  )      ,msg=F"""should have no warning, but got {cs.err}"""  )

									lowerCamelCase__		:   Optional[int]  				=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}  )
									lowerCamelCase__		:   Optional[Any]  				=					batch.convert_to_tensors(tensor_type='''pt'''      ,prepend_batch_axis=__UpperCAmelCase  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(1, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(1,)  )







				@require_tf
				def   lowercase_		(    self    :Optional[Any]  )      ->					Union[str, Any]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}  )
									lowerCamelCase__		:   Union[str, Any]  				=					batch.convert_to_tensors(tensor_type='''tf'''  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(2, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(2,)  )
									# test converting the converted
									with CaptureStderr() as cs:
														lowerCamelCase__		:   Optional[Any]  				=					batch.convert_to_tensors(tensor_type='''tf'''  )
									self.assertFalse(len(cs.err  )      ,msg=F"""should have no warning, but got {cs.err}"""  )

									lowerCamelCase__		:   int  				=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}  )
									lowerCamelCase__		:   Dict  				=					batch.convert_to_tensors(tensor_type='''tf'''      ,prepend_batch_axis=__UpperCAmelCase  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(1, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(1,)  )







				@require_flax
				def   lowercase_		(    self    :Optional[int]  )      ->					List[str]:




									"""simple docstring"""



									lowerCamelCase__		:   Optional[Any]  				=					BatchEncoding({'''inputs''': [[1, 2, 3], [4, 5, 6]], '''labels''': [0, 1]}  )
									lowerCamelCase__		:   str  				=					batch.convert_to_tensors(tensor_type='''jax'''  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(2, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(2,)  )
									# test converting the converted
									with CaptureStderr() as cs:
														lowerCamelCase__		:   Any  				=					batch.convert_to_tensors(tensor_type='''jax'''  )
									self.assertFalse(len(cs.err  )      ,msg=F"""should have no warning, but got {cs.err}"""  )

									lowerCamelCase__		:   List[Any]  				=					BatchEncoding({'''inputs''': [1, 2, 3], '''labels''': 0}  )
									lowerCamelCase__		:   Tuple  				=					batch.convert_to_tensors(tensor_type='''jax'''      ,prepend_batch_axis=__UpperCAmelCase  )
									self.assertEqual(tensor_batch['''inputs'''].shape      ,(1, 3)  )
									self.assertEqual(tensor_batch['''labels'''].shape      ,(1,)  )







				def   lowercase_		(    self    :str  )      ->					Union[str, Any]:




									"""simple docstring"""



									lowerCamelCase__		:   str  				=					[{'''input_ids''': np.array([0, 1, 2]  )}, {'''input_ids''': np.array([0, 1, 2, 3]  )}]
									lowerCamelCase__		:   Optional[Any]  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )

									lowerCamelCase__		:   Dict  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,np.ndarray  )  )
									self.assertEqual(batch['''input_ids'''].tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
									lowerCamelCase__		:   Optional[Any]  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase      ,return_tensors='''np'''  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,np.ndarray  )  )
									self.assertEqual(batch['''input_ids'''].tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )







				@require_torch
				def   lowercase_		(    self    :Tuple  )      ->					List[str]:




									"""simple docstring"""



									import torch

									lowerCamelCase__		:   Union[str, Any]  				=					[{'''input_ids''': torch.tensor([0, 1, 2]  )}, {'''input_ids''': torch.tensor([0, 1, 2, 3]  )}]
									lowerCamelCase__		:   Any  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )

									lowerCamelCase__		:   Tuple  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,torch.Tensor  )  )
									self.assertEqual(batch['''input_ids'''].tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
									lowerCamelCase__		:   Optional[int]  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase      ,return_tensors='''pt'''  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,torch.Tensor  )  )
									self.assertEqual(batch['''input_ids'''].tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )







				@require_tf
				def   lowercase_		(    self    :int  )      ->					Optional[int]:




									"""simple docstring"""



									import tensorflow as tf

									lowerCamelCase__		:   List[Any]  				=					[{'''input_ids''': tf.constant([0, 1, 2]  )}, {'''input_ids''': tf.constant([0, 1, 2, 3]  )}]
									lowerCamelCase__		:   str  				=					BertTokenizer.from_pretrained('''bert-base-cased'''  )

									lowerCamelCase__		:   Tuple  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,tf.Tensor  )  )
									self.assertEqual(batch['''input_ids'''].numpy().tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
									lowerCamelCase__		:   Tuple  				=					tokenizer.pad(__UpperCAmelCase      ,padding=__UpperCAmelCase      ,return_tensors='''tf'''  )
									self.assertTrue(isinstance(batch['''input_ids''']      ,tf.Tensor  )  )
									self.assertEqual(batch['''input_ids'''].numpy().tolist()      ,[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )







				@require_tokenizers
				def   lowercase_		(    self    :Dict  )      ->					Optional[int]:




									"""simple docstring"""



									lowerCamelCase__		:   List[Any]  				=					Tokenizer(WordPiece(unk_token='''[UNK]'''  )  )
									PreTrainedTokenizerFast(tokenizer_object=__UpperCAmelCase  )







				@require_tokenizers
				def   lowercase_		(    self    :str  )      ->					Union[str, Any]:




									"""simple docstring"""



									lowerCamelCase__		:   int  				=					Tokenizer(WordPiece(unk_token='''[UNK]'''  )  )
									with tempfile.TemporaryDirectory() as tmpdirname:
														bert_tokenizer.save(os.path.join(__UpperCAmelCase      ,'''tokenizer.json'''  )  )
														PreTrainedTokenizerFast(tokenizer_file=os.path.join(__UpperCAmelCase      ,'''tokenizer.json'''  )  )






