




"""simple docstring"""







import unittest

from transformers import FunnelConfig, FunnelTokenizer, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch

		from transformers import (
		    MODEL_FOR_PRETRAINING_MAPPING,
		    FunnelBaseModel,
		    FunnelForMaskedLM,
		    FunnelForMultipleChoice,
		    FunnelForPreTraining,
		    FunnelForQuestionAnswering,
		    FunnelForSequenceClassification,
		    FunnelForTokenClassification,
		    FunnelModel,
		)

class 							snake_case_ :







			"""simple docstring"""




			def __init__(		self					,				lowerCamelCase_					,				lowerCamelCase_=1_3					,				lowerCamelCase_=7					,				lowerCamelCase_=True					,				lowerCamelCase_=True					,				lowerCamelCase_=True					,				lowerCamelCase_=True					,				lowerCamelCase_=9_9					,				lowerCamelCase_=[1, 1, 2]					,				lowerCamelCase_=1					,				lowerCamelCase_=3_2					,				lowerCamelCase_=4					,				lowerCamelCase_=8					,				lowerCamelCase_=3_7					,				lowerCamelCase_="gelu_new"					,				lowerCamelCase_=0.1					,				lowerCamelCase_=0.1					,				lowerCamelCase_=0.0					,				lowerCamelCase_=5_1_2					,				lowerCamelCase_=3					,				lowerCamelCase_=0.02					,				lowerCamelCase_=3					,				lowerCamelCase_=4					,				lowerCamelCase_=None					,				lowerCamelCase_=False					,				)							->      Any:
							UpperCamelCase										=  parent
							UpperCamelCase										=  batch_size
							UpperCamelCase										=  seq_length
							UpperCamelCase										=  is_training
							UpperCamelCase										=  use_input_mask
							UpperCamelCase										=  use_token_type_ids
							UpperCamelCase										=  use_labels
							UpperCamelCase										=  vocab_size
							UpperCamelCase										=  block_sizes
							UpperCamelCase										=  num_decoder_layers
							UpperCamelCase										=  d_model
							UpperCamelCase										=  n_head
							UpperCamelCase										=  d_head
							UpperCamelCase										=  d_inner
							UpperCamelCase										=  hidden_act
							UpperCamelCase										=  hidden_dropout
							UpperCamelCase										=  attention_dropout
							UpperCamelCase										=  activation_dropout
							UpperCamelCase										=  max_position_embeddings
							UpperCamelCase										=  type_vocab_size
							UpperCamelCase										=  2
							UpperCamelCase										=  num_labels
							UpperCamelCase										=  num_choices
							UpperCamelCase										=  scope
							UpperCamelCase										=  initializer_std

							# Used in the tests to check the size of the first attention layer
							UpperCamelCase										=  n_head
							# Used in the tests to check the size of the first hidden state
							UpperCamelCase										=  self.d_model
							# Used in the tests to check the number of output hidden states/attentions
							UpperCamelCase										=  sum(self.block_sizes) + (0 if base else self.num_decoder_layers)
							# FunnelModel adds two hidden layers: input embeddings and the sum of the upsampled encoder hidden state with
							# the last hidden state of the first block (which is the first hidden state of the decoder).
							if not base:
											UpperCamelCase										=  self.num_hidden_layers + 2







			def      UpperCAmelCase__ (		self)							->      Any:
							UpperCamelCase										=  ids_tensor([self.batch_size, self.seq_length]					,				self.vocab_size)

							UpperCamelCase										=  None
							if self.use_input_mask:
											UpperCamelCase										=  ids_tensor([self.batch_size, self.seq_length]					,				vocab_size=2)

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

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

							UpperCamelCase										=  self.get_config()

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







			def      UpperCAmelCase__ (		self)							->      Any:
							return FunnelConfig(
							    vocab_size=self.vocab_size					,				block_sizes=self.block_sizes					,				num_decoder_layers=self.num_decoder_layers					,				d_model=self.d_model					,				n_head=self.n_head					,				d_head=self.d_head					,				d_inner=self.d_inner					,				hidden_act=self.hidden_act					,				hidden_dropout=self.hidden_dropout					,				attention_dropout=self.attention_dropout					,				activation_dropout=self.activation_dropout					,				max_position_embeddings=self.max_position_embeddings					,				type_vocab_size=self.type_vocab_size					,				initializer_std=self.initializer_std					,				)







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				)							->      Optional[int]:
							UpperCamelCase										=  FunnelModel(config=__SCREAMING_SNAKE_CASE)
							model.to(__SCREAMING_SNAKE_CASE)
							model.eval()
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE					,				attention_mask=__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE)
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE)
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.last_hidden_state.shape					,				(self.batch_size, self.seq_length, self.d_model))

							UpperCamelCase										=  False
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.last_hidden_state.shape					,				(self.batch_size, self.seq_length, self.d_model))

							UpperCamelCase										=  False
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.last_hidden_state.shape					,				(self.batch_size, self.seq_length, self.d_model))







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				)							->      Dict:
							UpperCamelCase										=  FunnelBaseModel(config=__SCREAMING_SNAKE_CASE)
							model.to(__SCREAMING_SNAKE_CASE)
							model.eval()
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE					,				attention_mask=__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE)
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE)
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.last_hidden_state.shape					,				(self.batch_size, 2, self.d_model))

							UpperCamelCase										=  False
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.last_hidden_state.shape					,				(self.batch_size, 3, self.d_model))

							UpperCamelCase										=  False
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.last_hidden_state.shape					,				(self.batch_size, 2, self.d_model))







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				)							->      List[str]:
							UpperCamelCase										=  self.num_labels
							UpperCamelCase										=  FunnelForPreTraining(config=__SCREAMING_SNAKE_CASE)
							model.to(__SCREAMING_SNAKE_CASE)
							model.eval()
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE					,				attention_mask=__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE					,				labels=__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.logits.shape					,				(self.batch_size, self.seq_length))







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				)							->      Tuple:
							UpperCamelCase										=  FunnelForMaskedLM(config=__SCREAMING_SNAKE_CASE)
							model.to(__SCREAMING_SNAKE_CASE)
							model.eval()
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE					,				attention_mask=__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE					,				labels=__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.logits.shape					,				(self.batch_size, self.seq_length, self.vocab_size))







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				)							->      Union[str, Any]:
							UpperCamelCase										=  self.num_labels
							UpperCamelCase										=  FunnelForSequenceClassification(__SCREAMING_SNAKE_CASE)
							model.to(__SCREAMING_SNAKE_CASE)
							model.eval()
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE					,				attention_mask=__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE					,				labels=__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.logits.shape					,				(self.batch_size, self.num_labels))







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				)							->      Dict:
							UpperCamelCase										=  self.num_choices
							UpperCamelCase										=  FunnelForMultipleChoice(config=__SCREAMING_SNAKE_CASE)
							model.to(__SCREAMING_SNAKE_CASE)
							model.eval()
							UpperCamelCase										=  input_ids.unsqueeze(1).expand(-1					,				self.num_choices					,				-1).contiguous()
							UpperCamelCase										=  token_type_ids.unsqueeze(1).expand(-1					,				self.num_choices					,				-1).contiguous()
							UpperCamelCase										=  input_mask.unsqueeze(1).expand(-1					,				self.num_choices					,				-1).contiguous()
							UpperCamelCase										=  model(
							    __SCREAMING_SNAKE_CASE					,				attention_mask=__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE					,				labels=__SCREAMING_SNAKE_CASE					,				)
							self.parent.assertEqual(result.logits.shape					,				(self.batch_size, self.num_choices))







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				)							->      int:
							UpperCamelCase										=  self.num_labels
							UpperCamelCase										=  FunnelForTokenClassification(config=__SCREAMING_SNAKE_CASE)
							model.to(__SCREAMING_SNAKE_CASE)
							model.eval()
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE					,				attention_mask=__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE					,				labels=__SCREAMING_SNAKE_CASE)
							self.parent.assertEqual(result.logits.shape					,				(self.batch_size, self.seq_length, self.num_labels))







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_					,				)							->      str:
							UpperCamelCase										=  FunnelForQuestionAnswering(config=__SCREAMING_SNAKE_CASE)
							model.to(__SCREAMING_SNAKE_CASE)
							model.eval()
							UpperCamelCase										=  model(
							    __SCREAMING_SNAKE_CASE					,				attention_mask=__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE					,				start_positions=__SCREAMING_SNAKE_CASE					,				end_positions=__SCREAMING_SNAKE_CASE					,				)
							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      UpperCAmelCase__ (		self)							->      Any:
							UpperCamelCase										=  self.prepare_config_and_inputs()
							(
							    (
							    UpperCamelCase 
							)					,  (
							    UpperCamelCase 
							)					,  (
							    UpperCamelCase 
							)					,  (
							    UpperCamelCase 
							)					,  (
							    UpperCamelCase 
							)					,  (
							    UpperCamelCase 
							)					,  (
							    UpperCamelCase 
							)					,  (
							    UpperCamelCase 
							)					,   
							)										=  config_and_inputs
							UpperCamelCase										=  {'''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"""




			A_										=					False
			A_										=					False
			A_										=					(
			    (
			        FunnelModel,
			        FunnelForMaskedLM,
			        FunnelForPreTraining,
			        FunnelForQuestionAnswering,
			        FunnelForTokenClassification,
			    )
			    if is_torch_available()
			    else ()
			)
			A_										=					(
			    {
			        """feature-extraction""": (FunnelBaseModel, FunnelModel),
			        """fill-mask""": FunnelForMaskedLM,
			        """question-answering""": FunnelForQuestionAnswering,
			        """text-classification""": FunnelForSequenceClassification,
			        """token-classification""": FunnelForTokenClassification,
			        """zero-shot""": FunnelForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_					,				lowerCamelCase_					,				lowerCamelCase_=False)							->      Union[str, Any]:
							UpperCamelCase										=  super()._prepare_for_class(__SCREAMING_SNAKE_CASE					,				__SCREAMING_SNAKE_CASE					,				return_labels=__SCREAMING_SNAKE_CASE)

							if return_labels:
											if model_class in get_values(__SCREAMING_SNAKE_CASE):
															UpperCamelCase										=  torch.zeros(
															    (self.model_tester.batch_size, self.model_tester.seq_length)					,				dtype=torch.long					,				device=__SCREAMING_SNAKE_CASE)
							return inputs_dict







			def      UpperCAmelCase__ (		self)							->      List[Any]:
							UpperCamelCase										=  FunnelModelTester(self)
							UpperCamelCase										=  ConfigTester(self					,				config_class=__SCREAMING_SNAKE_CASE)







			def      UpperCAmelCase__ (		self)							->      Union[str, Any]:
							self.config_tester.run_common_tests()







			def      UpperCAmelCase__ (		self)							->      Dict:
							UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE)







			def      UpperCAmelCase__ (		self)							->      int:
							UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_pretraining(*__SCREAMING_SNAKE_CASE)







			def      UpperCAmelCase__ (		self)							->      str:
							UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_lm(*__SCREAMING_SNAKE_CASE)







			def      UpperCAmelCase__ (		self)							->      Optional[Any]:
							UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_token_classification(*__SCREAMING_SNAKE_CASE)







			def      UpperCAmelCase__ (		self)							->      List[Any]:
							UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_question_answering(*__SCREAMING_SNAKE_CASE)







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_)							->      Dict:

							if hasattr(__SCREAMING_SNAKE_CASE					,				'''weight''') and module.weight is not None:
											module.weight.data.fill_(3)
							if hasattr(__SCREAMING_SNAKE_CASE					,				'''bias''') and module.bias is not None:
											module.bias.data.fill_(3)

							for param in ["r_w_bias", "r_r_bias", "r_kernel", "r_s_bias", "seg_embed"]:
											if hasattr(__SCREAMING_SNAKE_CASE					,				__SCREAMING_SNAKE_CASE) and getattr(__SCREAMING_SNAKE_CASE					,				__SCREAMING_SNAKE_CASE) is not None:
															UpperCamelCase										=  getattr(__SCREAMING_SNAKE_CASE					,				__SCREAMING_SNAKE_CASE)
															weight.data.fill_(3)

@require_torch
class 							snake_case_ (				lowerCAmelCase_  ,   unittest.TestCase ):







			"""simple docstring"""




			A_										=					False
			A_										=					False
			A_										=					(
			    (FunnelBaseModel, FunnelForMultipleChoice, FunnelForSequenceClassification) if is_torch_available() else ()
			)







			def      UpperCAmelCase__ (		self)							->      Optional[Any]:
							UpperCamelCase										=  FunnelModelTester(self					,				base=__SCREAMING_SNAKE_CASE)
							UpperCamelCase										=  ConfigTester(self					,				config_class=__SCREAMING_SNAKE_CASE)







			def      UpperCAmelCase__ (		self)							->      int:
							self.config_tester.run_common_tests()







			def      UpperCAmelCase__ (		self)							->      Dict:
							UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_base_model(*__SCREAMING_SNAKE_CASE)







			def      UpperCAmelCase__ (		self)							->      Optional[int]:
							UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_sequence_classification(*__SCREAMING_SNAKE_CASE)







			def      UpperCAmelCase__ (		self)							->      Dict:
							UpperCamelCase										=  self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_multiple_choice(*__SCREAMING_SNAKE_CASE)







			def      UpperCAmelCase__ (		self)							->      Union[str, Any]:
							UpperCamelCase					,  UpperCamelCase										=  self.model_tester.prepare_config_and_inputs_for_common()
							UpperCamelCase										=  True

							for model_class in self.all_model_classes:
											if model_class.__name__ == "FunnelBaseModel":
															continue
											UpperCamelCase										=  model_class(__SCREAMING_SNAKE_CASE)
											model.to(__SCREAMING_SNAKE_CASE)
											model.train()
											UpperCamelCase										=  self._prepare_for_class(__SCREAMING_SNAKE_CASE					,				__SCREAMING_SNAKE_CASE					,				return_labels=__SCREAMING_SNAKE_CASE)
											UpperCamelCase										=  model(**__SCREAMING_SNAKE_CASE).loss
											loss.backward()







			def      UpperCAmelCase__ (		self					,				lowerCamelCase_)							->      Any:

							if hasattr(__SCREAMING_SNAKE_CASE					,				'''weight''') and module.weight is not None:
											module.weight.data.fill_(3)
							if hasattr(__SCREAMING_SNAKE_CASE					,				'''bias''') and module.bias is not None:
											module.bias.data.fill_(3)

							for param in ["r_w_bias", "r_r_bias", "r_kernel", "r_s_bias", "seg_embed"]:
											if hasattr(__SCREAMING_SNAKE_CASE					,				__SCREAMING_SNAKE_CASE) and getattr(__SCREAMING_SNAKE_CASE					,				__SCREAMING_SNAKE_CASE) is not None:
															UpperCamelCase										=  getattr(__SCREAMING_SNAKE_CASE					,				__SCREAMING_SNAKE_CASE)
															weight.data.fill_(3)

@require_torch
@require_sentencepiece
@require_tokenizers
class 							snake_case_ (				unittest.TestCase ):







			"""simple docstring"""




			def      UpperCAmelCase__ (		self)							->      Union[str, Any]:
							UpperCamelCase										=  1_3
							UpperCamelCase										=  7
							UpperCamelCase										=  torch.arange(0					,				batch_size * sequence_length).long().reshape(__SCREAMING_SNAKE_CASE					,				__SCREAMING_SNAKE_CASE)
							UpperCamelCase										=  [0, 1, 2, 3, 4, 5, 6, 4, 1, 3, 5, 0, 1]
							UpperCamelCase										=  torch.tensor([[2] + [0] * a + [1] * (sequence_length - a - 1) for a in lengths])

							UpperCamelCase										=  FunnelModel.from_pretrained('''sgugger/funnel-random-tiny''')
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE)[0].abs()

							UpperCamelCase										=  torch.tensor(2344.8352)
							UpperCamelCase										=  torch.tensor(0.8052)
							self.assertTrue(torch.allclose(output.sum()					,				__SCREAMING_SNAKE_CASE					,				atol=1e-4))
							self.assertTrue(torch.allclose(output.mean()					,				__SCREAMING_SNAKE_CASE					,				atol=1e-4))

							UpperCamelCase										=  torch.tensor([[1] * 7, [1] * 4 + [0] * 3] * 6 + [[0, 1, 1, 0, 0, 1, 1]])
							UpperCamelCase										=  model(__SCREAMING_SNAKE_CASE					,				attention_mask=__SCREAMING_SNAKE_CASE					,				token_type_ids=__SCREAMING_SNAKE_CASE)[0].abs()

							UpperCamelCase										=  torch.tensor(2343.8425)
							UpperCamelCase										=  torch.tensor(0.8049)
							self.assertTrue(torch.allclose(output.sum()					,				__SCREAMING_SNAKE_CASE					,				atol=1e-4))
							self.assertTrue(torch.allclose(output.mean()					,				__SCREAMING_SNAKE_CASE					,				atol=1e-4))







			@slow
			def      UpperCAmelCase__ (		self)							->      List[Any]:
							UpperCamelCase										=  FunnelTokenizer.from_pretrained('''huggingface/funnel-small''')
							UpperCamelCase										=  FunnelModel.from_pretrained('''huggingface/funnel-small''')
							UpperCamelCase										=  tokenizer('''Hello! I am the Funnel Transformer model.'''					,				return_tensors='''pt''')
							UpperCamelCase										=  model(**__SCREAMING_SNAKE_CASE)[0]

							UpperCamelCase										=  torch.tensor(235.7246)
							UpperCamelCase										=  torch.tensor(0.0256)
							self.assertTrue(torch.allclose(output.sum()					,				__SCREAMING_SNAKE_CASE					,				atol=1e-4))
							self.assertTrue(torch.allclose(output.mean()					,				__SCREAMING_SNAKE_CASE					,				atol=1e-4))





"""simple docstring"""







import unittest

from transformers import ErnieMTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


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

@require_sentencepiece
@require_tokenizers
class 							snake_case_ (				lowerCamelCase_  ,   unittest.TestCase ):







   """simple docstring"""




   A_										=					ErnieMTokenizer
   A_										=					False
   A_										=					True
   A_										=					False
   A_										=					False







   def      UpperCAmelCase__ (		self)							->      List[str]:
       super().setUp()

       # We have a SentencePiece fixture for testing
       UpperCamelCase										=  ErnieMTokenizer(lowerCamelCase_					,				unk_token='''<unk>'''					,				pad_token='''<pad>''')
       tokenizer.save_pretrained(self.tmpdirname)







   def      UpperCAmelCase__ (		self					,				lowerCamelCase_)							->      Optional[Any]:
       UpperCamelCase										=  '''this is a test'''
       UpperCamelCase										=  '''this is a test'''
       return input_text, output_text







   def      UpperCAmelCase__ (		self)							->      Optional[Any]:
       UpperCamelCase										=  '''<pad>'''
       UpperCamelCase										=  0

       self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase_)					,				lowerCamelCase_)
       self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase_)					,				lowerCamelCase_)







   def      UpperCAmelCase__ (		self)							->      Optional[Any]:
       UpperCamelCase										=  list(self.get_tokenizer().get_vocab().keys())

       self.assertEqual(vocab_keys[0]					,				'''<pad>''')
       self.assertEqual(vocab_keys[1]					,				'''<unk>''')
       self.assertEqual(vocab_keys[-1]					,				'''▁eloquent''')
       self.assertEqual(len(lowerCamelCase_)					,				3_0_0_0_0)







   def      UpperCAmelCase__ (		self)							->      int:
       self.assertEqual(self.get_tokenizer().vocab_size					,				3_0_0_0_0)







   def      UpperCAmelCase__ (		self)							->      List[Any]:
       if not self.test_rust_tokenizer:
           return

       UpperCamelCase										=  self.get_tokenizer()
       UpperCamelCase										=  self.get_rust_tokenizer()

       UpperCamelCase										=  '''I was born in 92000, and this is falsé.'''

       UpperCamelCase										=  tokenizer.tokenize(lowerCamelCase_)
       UpperCamelCase										=  rust_tokenizer.tokenize(lowerCamelCase_)
       self.assertListEqual(lowerCamelCase_					,				lowerCamelCase_)

       UpperCamelCase										=  tokenizer.encode(lowerCamelCase_					,				add_special_tokens=lowerCamelCase_)
       UpperCamelCase										=  rust_tokenizer.encode(lowerCamelCase_					,				add_special_tokens=lowerCamelCase_)
       self.assertListEqual(lowerCamelCase_					,				lowerCamelCase_)

       UpperCamelCase										=  self.get_rust_tokenizer()
       UpperCamelCase										=  tokenizer.encode(lowerCamelCase_)
       UpperCamelCase										=  rust_tokenizer.encode(lowerCamelCase_)
       self.assertListEqual(lowerCamelCase_					,				lowerCamelCase_)







   def      UpperCAmelCase__ (		self)							->      List[Any]:
       UpperCamelCase										=  ErnieMTokenizer(lowerCamelCase_					,				do_lower_case=lowerCamelCase_					,				unk_token='''<unk>'''					,				pad_token='''<pad>''')

       UpperCamelCase										=  tokenizer.tokenize('''This is a test''')
       self.assertListEqual(lowerCamelCase_					,				['''▁this''', '''▁is''', '''▁a''', '''▁test'''])

       self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCamelCase_)					,				[4_8, 2_5, 2_1, 1_2_8_9])

       UpperCamelCase										=  tokenizer.tokenize('''I was born in 92000, and this is falsé.''')
       # ErnieMTokenizer(paddlenlp implementation) outputs '9' instead of '_9' so to mimic that '_9' is changed to '9'
       self.assertListEqual(
           lowerCamelCase_					,				['''▁i''', '''▁was''', '''▁born''', '''▁in''', '''9''', '''2000''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''é''', '''.'''])
       UpperCamelCase										=  tokenizer.convert_tokens_to_ids(lowerCamelCase_)
       self.assertListEqual(lowerCamelCase_					,				[3_1, 2_3, 3_8_6, 1_9, 5_1_8, 3_0_5_0, 1_5, 1_7, 4_8, 2_5, 8_2_5_6, 1_8, 1, 9])

       UpperCamelCase										=  tokenizer.convert_ids_to_tokens(lowerCamelCase_)
       self.assertListEqual(
           lowerCamelCase_					,				['''▁i''', '''▁was''', '''▁born''', '''▁in''', '''9''', '''2000''', ''',''', '''▁and''', '''▁this''', '''▁is''', '''▁fal''', '''s''', '''<unk>''', '''.''']					,				)







   def      UpperCAmelCase__ (		self)							->      Dict:
       UpperCamelCase										=  ErnieMTokenizer(lowerCamelCase_					,				unk_token='''<unk>'''					,				pad_token='''<pad>''')

       UpperCamelCase										=  tokenizer.encode('''sequence builders''')
       UpperCamelCase										=  tokenizer.encode('''multi-sequence build''')

       UpperCamelCase										=  tokenizer.build_inputs_with_special_tokens(lowerCamelCase_)
       UpperCamelCase										=  tokenizer.build_inputs_with_special_tokens(lowerCamelCase_					,				lowerCamelCase_)

       assert encoded_sentence == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id]
       assert encoded_pair == [tokenizer.cls_token_id] + text + [tokenizer.sep_token_id] + [
           tokenizer.sep_token_id
       ] + text_a + [tokenizer.sep_token_id]







   @slow
   def      UpperCAmelCase__ (		self)							->      List[str]:
       # fmt: off
       UpperCamelCase										=  {'''input_ids''': [[0, 1_1_0_6_2, 8_2_7_7_2, 7, 1_5, 8_2_7_7_2, 5_3_8, 5_1_5_2_9, 2_3_7, 1_7_1_9_8, 1_2_9_0, 2_0_6, 9, 2_1_5_1_7_5, 1_3_1_4, 1_3_6, 1_7_1_9_8, 1_2_9_0, 2_0_6, 9, 5_6_3_5_9, 4_2, 1_2_2_0_0_9, 9, 1_6_4_6_6, 1_6, 8_7_3_4_4, 4_5_3_7, 9, 4_7_1_7, 7_8_3_8_1, 6, 1_5_9_9_5_8, 7, 1_5, 2_4_4_8_0, 6_1_8, 4, 5_2_7, 2_2_6_9_3, 9, 3_0_4, 4, 2_7_7_7, 2_4_4_8_0, 9_8_7_4, 4, 4_3_5_2_3, 5_9_4, 4, 8_0_3, 1_8_3_9_2, 3_3_1_8_9, 1_8, 4, 4_3_5_2_3, 2_4_4_4_7, 5, 5, 5, 1_6, 1_0_0, 2_4_9_5_5, 8_3_6_5_8, 9_6_2_6, 1_4_4_0_5_7, 1_5, 8_3_9, 2_2_3_3_5, 1_6, 1_3_6, 2_4_9_5_5, 8_3_6_5_8, 8_3_4_7_9, 1_5, 3_9_1_0_2, 7_2_4, 1_6, 6_7_8, 6_4_5, 6_4_6_0, 1_3_2_8, 4_5_8_9, 4_2, 1_2_2_0_0_9, 1_1_5_7_7_4, 2_3, 3_5_5_9, 1_3_2_8, 4_6_8_7_6, 7, 1_3_6, 5_3_8_9_4, 1_9_4_0, 4_2_2_2_7, 4_1_1_5_9, 1_7_7_2_1, 8_2_3, 4_2_5, 4, 2_7_5_1_2, 9_8_7_2_2, 2_0_6, 1_3_6, 5_5_3_1, 4_9_7_0, 9_1_9, 1_7_3_3_6, 5, 2], [0, 2_0_0_8_0, 6_1_8, 8_3, 8_2_7_7_5, 4_7, 4_7_9, 9, 1_5_1_7, 7_3, 5_3_8_9_4, 3_3_3, 8_0_5_8_1, 1_1_0_1_1_7, 1_8_8_1_1, 5_2_5_6, 1_2_9_5, 5_1, 1_5_2_5_2_6, 2_9_7, 7_9_8_6, 3_9_0, 1_2_4_4_1_6, 5_3_8, 3_5_4_3_1, 2_1_4, 9_8, 1_5_0_4_4, 2_5_7_3_7, 1_3_6, 7_1_0_8, 4_3_7_0_1, 2_3, 7_5_6, 1_3_5_3_5_5, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 5_8_1, 6_3_7_7_3, 1_1_9_4_5_5, 6, 1_4_7_7_9_7, 8_8_2_0_3, 7, 6_4_5, 7_0, 2_1, 3_2_8_5, 1_0_2_6_9, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}
       # fmt: on

       self.tokenizer_integration_test_util(
           expected_encoding=lowerCamelCase_					,				model_name='''susnato/ernie-m-base_pytorch'''					,				sequences=[
               '''Transformers (formerly known as pytorch-transformers and pytorch-pretrained-bert) provides '''
               '''general-purpose architectures (BERT, GPT-2, RoBERTa, XLM, DistilBert, XLNet...) for Natural '''
               '''Language Understanding (NLU) and Natural Language Generation (NLG) with over32+ pretrained '''
               '''models in100+ languages and deep interoperability between Jax, PyTorch and TensorFlow.''',
               '''BERT is designed to pre-train deep bidirectional representations from unlabeled text by jointly '''
               '''conditioning on both left and right context in all layers.''',
               '''The quick brown fox jumps over the lazy dog.''',
           ]					,				)