



import math
import os
import unittest

from transformers import MegatronBertConfig, 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, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      MODEL_FOR_PRETRAINING_MAPPING,
      MegatronBertForCausalLM,
      MegatronBertForMaskedLM,
      MegatronBertForMultipleChoice,
      MegatronBertForNextSentencePrediction,
      MegatronBertForPreTraining,
      MegatronBertForQuestionAnswering,
      MegatronBertForSequenceClassification,
      MegatronBertForTokenClassification,
      MegatronBertModel,
  )



class  __lowerCAmelCase     :




 def __init__(						self	,				__UpperCAmelCase	,				__UpperCAmelCase=13	,				__UpperCAmelCase=7	,				__UpperCAmelCase=True	,				__UpperCAmelCase=True	,				__UpperCAmelCase=True	,				__UpperCAmelCase=True	,				__UpperCAmelCase=99	,				__UpperCAmelCase=64	,				__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=3	,				__UpperCAmelCase=4	,				__UpperCAmelCase=None	,				):



    '''simple docstring'''
    __lowerCamelCase													=    parent
    __lowerCamelCase													=    batch_size
    __lowerCamelCase													=    seq_length
    __lowerCamelCase													=    is_training
    __lowerCamelCase													=    use_input_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_labels
    __lowerCamelCase													=    num_choices
    __lowerCamelCase													=    scope




 def        lowerCamelCase      (						self				):



    '''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
    __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()

    return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    return MegatronBertConfig(
        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	,				embedding_size=self.embedding_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        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    MegatronBertModel(config=__UpperCAmelCase				)
    model.to(__UpperCAmelCase				)
    model.eval()
    __lowerCamelCase													=    model(__UpperCAmelCase	,				attention_mask=__UpperCAmelCase	,				token_type_ids=__UpperCAmelCase				)
    __lowerCamelCase													=    model(__UpperCAmelCase	,				token_type_ids=__UpperCAmelCase				)
    __lowerCamelCase													=    model(__UpperCAmelCase				)

    self.parent.assertEqual(result.last_hidden_state.shape	,				(self.batch_size, self.seq_length, self.hidden_size)				)
    self.parent.assertEqual(result.pooler_output.shape	,				(self.batch_size, self.hidden_size)				)




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



    '''simple docstring'''
    __lowerCamelCase													=    MegatronBertForMaskedLM(config=__UpperCAmelCase				)
    model.to(__UpperCAmelCase				)
    model.eval()
    __lowerCamelCase													=    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        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    MegatronBertForCausalLM(config=__UpperCAmelCase				)
    model.to(__UpperCAmelCase				)
    model.eval()
    __lowerCamelCase													=    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        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    MegatronBertForNextSentencePrediction(config=__UpperCAmelCase				)
    model.to(__UpperCAmelCase				)
    model.eval()
    __lowerCamelCase													=    model(
        __UpperCAmelCase	,				attention_mask=__UpperCAmelCase	,				token_type_ids=__UpperCAmelCase	,				labels=__UpperCAmelCase	,				)
    self.parent.assertEqual(result.logits.shape	,				(self.batch_size, 2)				)




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



    '''simple docstring'''
    __lowerCamelCase													=    MegatronBertForPreTraining(config=__UpperCAmelCase				)
    model.to(__UpperCAmelCase				)
    model.eval()
    __lowerCamelCase													=    model(
        __UpperCAmelCase	,				attention_mask=__UpperCAmelCase	,				token_type_ids=__UpperCAmelCase	,				labels=__UpperCAmelCase	,				next_sentence_label=__UpperCAmelCase	,				)
    self.parent.assertEqual(result.prediction_logits.shape	,				(self.batch_size, self.seq_length, self.vocab_size)				)
    self.parent.assertEqual(result.seq_relationship_logits.shape	,				(self.batch_size, 2)				)




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



    '''simple docstring'''
    __lowerCamelCase													=    MegatronBertForQuestionAnswering(config=__UpperCAmelCase				)
    model.to(__UpperCAmelCase				)
    model.eval()
    __lowerCamelCase													=    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        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    self.num_labels
    __lowerCamelCase													=    MegatronBertForSequenceClassification(__UpperCAmelCase				)
    model.to(__UpperCAmelCase				)
    model.eval()
    __lowerCamelCase													=    model(__UpperCAmelCase	,				attention_mask=__UpperCAmelCase	,				token_type_ids=__UpperCAmelCase	,				labels=__UpperCAmelCase				)
    self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.num_labels)				)




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



    '''simple docstring'''
    __lowerCamelCase													=    self.num_labels
    __lowerCamelCase													=    MegatronBertForTokenClassification(config=__UpperCAmelCase				)
    model.to(__UpperCAmelCase				)
    model.eval()
    __lowerCamelCase													=    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        lowerCamelCase      (						self	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase				):



    '''simple docstring'''
    __lowerCamelCase													=    self.num_choices
    __lowerCamelCase													=    MegatronBertForMultipleChoice(config=__UpperCAmelCase				)
    model.to(__UpperCAmelCase				)
    model.eval()
    __lowerCamelCase													=    input_ids.unsqueeze(1				).expand(-1	,				self.num_choices	,				-1				).contiguous()
    __lowerCamelCase													=    token_type_ids.unsqueeze(1				).expand(-1	,				self.num_choices	,				-1				).contiguous()
    __lowerCamelCase													=    input_mask.unsqueeze(1				).expand(-1	,				self.num_choices	,				-1				).contiguous()
    __lowerCamelCase													=    model(
        __UpperCAmelCase	,				attention_mask=__UpperCAmelCase	,				token_type_ids=__UpperCAmelCase	,				labels=__UpperCAmelCase	,				)
    self.parent.assertEqual(result.logits.shape	,				(self.batch_size, self.num_choices)				)




 def        lowerCamelCase      (						self				):



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



@require_torch
class  __lowerCAmelCase     (	lowerCAmelCase__  ,	lowerCAmelCase__  ,	unittest.TestCase   ):
 lowerCAmelCase__       					=  (
     (
         MegatronBertModel,
         MegatronBertForMaskedLM,
         MegatronBertForCausalLM,
         MegatronBertForMultipleChoice,
         MegatronBertForNextSentencePrediction,
         MegatronBertForPreTraining,
         MegatronBertForQuestionAnswering,
         MegatronBertForSequenceClassification,
         MegatronBertForTokenClassification,
     )
     if is_torch_available()
     else ()
 )
 lowerCAmelCase__       					=  (
     {
         """feature-extraction""": MegatronBertModel,
         """fill-mask""": MegatronBertForMaskedLM,
         """question-answering""": MegatronBertForQuestionAnswering,
         """text-classification""": MegatronBertForSequenceClassification,
         """text-generation""": MegatronBertForCausalLM,
         """token-classification""": MegatronBertForTokenClassification,
         """zero-shot""": MegatronBertForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 lowerCAmelCase__       					=  True
 # test_resize_embeddings = False
 lowerCAmelCase__       					=  False




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



    '''simple docstring'''
    __lowerCamelCase													=    super()._prepare_for_class(__UpperCAmelCase	,				__UpperCAmelCase	,				return_labels=__UpperCAmelCase				)

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




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    MegatronBertModelTester(self				)
    __lowerCamelCase													=    ConfigTester(self	,				config_class=__UpperCAmelCase	,				hidden_size=37				)




 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_megatron_bert_model(*__UpperCAmelCase				)




 def        lowerCamelCase      (						self				):



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




 def        lowerCamelCase      (						self				):



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




 def        lowerCamelCase      (						self				):



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




 def        lowerCamelCase      (						self				):



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




 def        lowerCamelCase      (						self				):



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




 def        lowerCamelCase      (						self				):



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




 def        lowerCamelCase      (						self				):



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



def 		a__			(		_UpperCamelCase			: str							):
   return torch.tensor(
       _UpperCamelCase ,dtype=torch.long ,device=_UpperCamelCase ,)


a_			=					1E-4





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




 @slow
 @unittest.skip('''Model is not available.'''				)
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    '''nvidia/megatron-bert-uncased-345m'''
    if "MYDIR" in os.environ:
       __lowerCamelCase													=    os.path.join(os.environ['''MYDIR''']	,				__UpperCAmelCase				)
    __lowerCamelCase													=    MegatronBertModel.from_pretrained(__UpperCAmelCase				)
    model.to(__UpperCAmelCase				)
    model.half()
    __lowerCamelCase													=    _long_tensor([[101, 7110, 1005, 1056, 2023, 11333, 17413, 1029, 102]]				)
    with torch.no_grad():
       __lowerCamelCase													=    model(__UpperCAmelCase				)[0]
    __lowerCamelCase													=    torch.Size((1, 9, 1024)				)
    self.assertEqual(output.shape	,				__UpperCAmelCase				)

    __lowerCamelCase													=    [-0.6_040, -0.2_517, -0.1_025, 0.3_420, -0.6_758, -0.0_017, -0.1_089, -0.1_990, 0.5_728]
    for ii in range(3				):
       for jj in range(3				):
          __lowerCamelCase													=    output[0, ii, jj]
          __lowerCamelCase													=    expected[3 * ii + jj]
          __lowerCamelCase													=    '''ii={} jj={} a={} b={}'''.format(__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase	,				__UpperCAmelCase				)
          self.assertTrue(math.isclose(__UpperCAmelCase	,				__UpperCAmelCase	,				rel_tol=__UpperCAmelCase	,				abs_tol=__UpperCAmelCase				)	,				msg=__UpperCAmelCase				)











import unittest

from transformers.models.xlm_prophetnet.tokenization_xlm_prophetnet import SPIECE_UNDERLINE, XLMProphetNetTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


a_			=					get_tests_dir("""fixtures/test_sentencepiece.model""")



@require_sentencepiece
class  __lowerCAmelCase     (	lowerCAmelCase__  ,	unittest.TestCase   ):
 lowerCAmelCase__       					=  XLMProphetNetTokenizer
 lowerCAmelCase__       					=  False
 lowerCAmelCase__       					=  True




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    super().setUp()

    # We have a SentencePiece fixture for testing
    __lowerCamelCase													=    XLMProphetNetTokenizer(__UpperCAmelCase	,				keep_accents=__UpperCAmelCase				)
    tokenizer.save_pretrained(self.tmpdirname				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    '''[PAD]'''
    __lowerCamelCase													=    0

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




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    list(self.get_tokenizer().get_vocab().keys()				)

    self.assertEqual(vocab_keys[0]	,				'''[PAD]'''				)
    self.assertEqual(vocab_keys[1]	,				'''[CLS]'''				)
    self.assertEqual(vocab_keys[-1]	,				'''j'''				)
    self.assertEqual(len(__UpperCAmelCase				)	,				1012				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    self.assertEqual(self.get_tokenizer().vocab_size	,				1012				)




 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    XLMProphetNetTokenizer(__UpperCAmelCase	,				keep_accents=__UpperCAmelCase				)

    __lowerCamelCase													=    tokenizer.tokenize('''This is a test'''				)
    self.assertListEqual(__UpperCAmelCase	,				['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']				)

    self.assertListEqual(
        tokenizer.convert_tokens_to_ids(__UpperCAmelCase				)	,				[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]	,				)

    __lowerCamelCase													=    tokenizer.tokenize('''I was born in 92000, and this is falsé.'''				)
    self.assertListEqual(
        __UpperCAmelCase	,				[
            SPIECE_UNDERLINE + '''I''',
            SPIECE_UNDERLINE + '''was''',
            SPIECE_UNDERLINE + '''b''',
            '''or''',
            '''n''',
            SPIECE_UNDERLINE + '''in''',
            SPIECE_UNDERLINE + '''''',
            '''9''',
            '''2''',
            '''0''',
            '''0''',
            '''0''',
            ''',''',
            SPIECE_UNDERLINE + '''and''',
            SPIECE_UNDERLINE + '''this''',
            SPIECE_UNDERLINE + '''is''',
            SPIECE_UNDERLINE + '''f''',
            '''al''',
            '''s''',
            '''é''',
            '''.''',
        ]	,				)
    __lowerCamelCase													=    tokenizer.convert_tokens_to_ids(__UpperCAmelCase				)
    self.assertListEqual(
        __UpperCAmelCase	,				[
            value + tokenizer.fairseq_offset
            for value in [8, 21, 84, 55, 24, 19, 7, -9, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, -9, 4]
        ]	,				)

    __lowerCamelCase													=    tokenizer.convert_ids_to_tokens(__UpperCAmelCase				)
    self.assertListEqual(
        __UpperCAmelCase	,				[
            SPIECE_UNDERLINE + '''I''',
            SPIECE_UNDERLINE + '''was''',
            SPIECE_UNDERLINE + '''b''',
            '''or''',
            '''n''',
            SPIECE_UNDERLINE + '''in''',
            SPIECE_UNDERLINE + '''''',
            '''[UNK]''',
            '''2''',
            '''0''',
            '''0''',
            '''0''',
            ''',''',
            SPIECE_UNDERLINE + '''and''',
            SPIECE_UNDERLINE + '''this''',
            SPIECE_UNDERLINE + '''is''',
            SPIECE_UNDERLINE + '''f''',
            '''al''',
            '''s''',
            '''[UNK]''',
            '''.''',
        ]	,				)




 @cached_property
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    return XLMProphetNetTokenizer.from_pretrained('''microsoft/xprophetnet-large-wiki100-cased'''				)




 @slow
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    __lowerCamelCase													=    '''Hello World!'''
    __lowerCamelCase													=    [35389, 6672, 49, 2]
    self.assertListEqual(__UpperCAmelCase	,				self.big_tokenizer.encode(__UpperCAmelCase				)				)




 @slow
 def        lowerCamelCase      (						self				):



    '''simple docstring'''
    # fmt: off
    __lowerCamelCase													=    {'''input_ids''': [[11073, 82783, 18, 26, 82783, 549, 51540, 248, 17209, 1301, 217, 20, 215186, 1325, 147, 17209, 1301, 217, 20, 56370, 53, 122020, 20, 16477, 27, 87355, 4548, 20, 4728, 78392, 17, 159969, 18, 26, 24491, 629, 15, 538, 22704, 5439, 15, 2788, 24491, 9885, 15, 43534, 605, 15, 814, 18403, 33200, 29, 15, 43534, 24458, 12410, 111, 24966, 83669, 9637, 144068, 26, 850, 22346, 27, 147, 24966, 83669, 83490, 26, 39113, 735, 27, 689, 656, 2800, 1339, 4600, 53, 122020, 115785, 34, 816, 1339, 46887, 18, 147, 53905, 1951, 42238, 41170, 17732, 834, 436, 15, 27523, 98733, 217, 147, 5542, 4981, 930, 17347, 16, 2], [20091, 629, 94, 82786, 58, 490, 20, 1528, 84, 53905, 344, 80592, 110128, 18822, 5267, 1306, 62, 152537, 308, 7997, 401, 124427, 549, 35442, 225, 109, 15055, 25748, 147, 7119, 43712, 34, 767, 135366, 18, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [592, 63784, 119466, 17, 147808, 88214, 18, 656, 81, 32, 3296, 10280, 16, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], '''attention_mask''': [[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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
    # fmt: on

    self.tokenizer_integration_test_util(
        expected_encoding=__UpperCAmelCase	,				model_name='''microsoft/xprophetnet-large-wiki100-cased'''	,				revision='''1acad1643ddd54a44df6a1b797ada8373685d90e'''	,				)






