



import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
    from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor

class 					lowercase						:




       '''simple docstring'''







       def __init__(						self		,       _snake_case		,       _snake_case=13		,       _snake_case=32		,       _snake_case=2		,       _snake_case=3		,       _snake_case=16		,       _snake_case=[1, 2, 1]		,       _snake_case=[2, 2, 4]		,       _snake_case=2		,       _snake_case=2.0		,       _snake_case=True		,       _snake_case=0.0		,       _snake_case=0.0		,       _snake_case=0.1		,       _snake_case="gelu"		,       _snake_case=False		,       _snake_case=True		,       _snake_case=0.02		,       _snake_case=1e-5		,       _snake_case=True		,       _snake_case=None		,       _snake_case=True		,       _snake_case=10		,       _snake_case=8		,       _snake_case=["stage1", "stage2"]		,       _snake_case=[1, 2]		,       )					->		Optional[Any]:

           """simple docstring"""
           UpperCAmelCase     =    parent
           UpperCAmelCase     =    batch_size
           UpperCAmelCase     =    image_size
           UpperCAmelCase     =    patch_size
           UpperCAmelCase     =    num_channels
           UpperCAmelCase     =    embed_dim
           UpperCAmelCase     =    depths
           UpperCAmelCase     =    num_heads
           UpperCAmelCase     =    window_size
           UpperCAmelCase     =    mlp_ratio
           UpperCAmelCase     =    qkv_bias
           UpperCAmelCase     =    hidden_dropout_prob
           UpperCAmelCase     =    attention_probs_dropout_prob
           UpperCAmelCase     =    drop_path_rate
           UpperCAmelCase     =    hidden_act
           UpperCAmelCase     =    use_absolute_embeddings
           UpperCAmelCase     =    patch_norm
           UpperCAmelCase     =    layer_norm_eps
           UpperCAmelCase     =    initializer_range
           UpperCAmelCase     =    is_training
           UpperCAmelCase     =    scope
           UpperCAmelCase     =    use_labels
           UpperCAmelCase     =    type_sequence_label_size
           UpperCAmelCase     =    encoder_stride
           UpperCAmelCase     =    out_features
           UpperCAmelCase     =    out_indices






       def 				snake_case_ (						self   )					->		List[Any]:

           """simple docstring"""
           UpperCAmelCase     =    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]   )

           UpperCAmelCase     =    None
           if self.use_labels:
               UpperCAmelCase     =    ids_tensor([self.batch_size]		,       self.type_sequence_label_size   )

           UpperCAmelCase     =    self.get_config()

           return config, pixel_values, labels






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

           """simple docstring"""
           return SwinConfig(
               image_size=self.image_size		,       patch_size=self.patch_size		,       num_channels=self.num_channels		,       embed_dim=self.embed_dim		,       depths=self.depths		,       num_heads=self.num_heads		,       window_size=self.window_size		,       mlp_ratio=self.mlp_ratio		,       qkv_bias=self.qkv_bias		,       hidden_dropout_prob=self.hidden_dropout_prob		,       attention_probs_dropout_prob=self.attention_probs_dropout_prob		,       drop_path_rate=self.drop_path_rate		,       hidden_act=self.hidden_act		,       use_absolute_embeddings=self.use_absolute_embeddings		,       path_norm=self.patch_norm		,       layer_norm_eps=self.layer_norm_eps		,       initializer_range=self.initializer_range		,       encoder_stride=self.encoder_stride		,       out_features=self.out_features		,       out_indices=self.out_indices		,       )






       def 				snake_case_ (						self		,       _snake_case		,       _snake_case		,       _snake_case   )					->		Optional[Any]:

           """simple docstring"""
           UpperCAmelCase     =    SwinModel(config=_snake_case   )
           model.to(_snake_case   )
           model.eval()
           UpperCAmelCase     =    model(_snake_case   )

           UpperCAmelCase     =    ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
           UpperCAmelCase     =    int(config.embed_dim * 2 ** (len(config.depths   ) - 1)   )

           self.parent.assertEqual(result.last_hidden_state.shape		,       (self.batch_size, expected_seq_len, expected_dim)   )






       def 				snake_case_ (						self		,       _snake_case		,       _snake_case		,       _snake_case   )					->		List[str]:

           """simple docstring"""
           UpperCAmelCase     =    SwinBackbone(config=_snake_case   )
           model.to(_snake_case   )
           model.eval()
           UpperCAmelCase     =    model(_snake_case   )

           # verify hidden states
           self.parent.assertEqual(len(result.feature_maps   )		,       len(config.out_features   )   )
           self.parent.assertListEqual(list(result.feature_maps[0].shape   )		,       [self.batch_size, model.channels[0], 16, 16]   )

           # verify channels
           self.parent.assertEqual(len(model.channels   )		,       len(config.out_features   )   )

           # verify backbone works with out_features=None
           UpperCAmelCase     =    None
           UpperCAmelCase     =    SwinBackbone(config=_snake_case   )
           model.to(_snake_case   )
           model.eval()
           UpperCAmelCase     =    model(_snake_case   )

           # verify feature maps
           self.parent.assertEqual(len(result.feature_maps   )		,       1   )
           self.parent.assertListEqual(list(result.feature_maps[0].shape   )		,       [self.batch_size, model.channels[-1], 4, 4]   )

           # verify channels
           self.parent.assertEqual(len(model.channels   )		,       1   )






       def 				snake_case_ (						self		,       _snake_case		,       _snake_case		,       _snake_case   )					->		str:

           """simple docstring"""
           UpperCAmelCase     =    SwinForMaskedImageModeling(config=_snake_case   )
           model.to(_snake_case   )
           model.eval()
           UpperCAmelCase     =    model(_snake_case   )
           self.parent.assertEqual(
               result.logits.shape		,       (self.batch_size, self.num_channels, self.image_size, self.image_size)   )

           # test greyscale images
           UpperCAmelCase     =    1
           UpperCAmelCase     =    SwinForMaskedImageModeling(_snake_case   )
           model.to(_snake_case   )
           model.eval()

           UpperCAmelCase     =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
           UpperCAmelCase     =    model(_snake_case   )
           self.parent.assertEqual(result.logits.shape		,       (self.batch_size, 1, self.image_size, self.image_size)   )






       def 				snake_case_ (						self		,       _snake_case		,       _snake_case		,       _snake_case   )					->		List[Any]:

           """simple docstring"""
           UpperCAmelCase     =    self.type_sequence_label_size
           UpperCAmelCase     =    SwinForImageClassification(_snake_case   )
           model.to(_snake_case   )
           model.eval()
           UpperCAmelCase     =    model(_snake_case		,       labels=_snake_case   )
           self.parent.assertEqual(result.logits.shape		,       (self.batch_size, self.type_sequence_label_size)   )

           # test greyscale images
           UpperCAmelCase     =    1
           UpperCAmelCase     =    SwinForImageClassification(_snake_case   )
           model.to(_snake_case   )
           model.eval()

           UpperCAmelCase     =    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]   )
           UpperCAmelCase     =    model(_snake_case   )
           self.parent.assertEqual(result.logits.shape		,       (self.batch_size, self.type_sequence_label_size)   )






       def 				snake_case_ (						self   )					->		Optional[Any]:

           """simple docstring"""
           UpperCAmelCase     =    self.prepare_config_and_inputs()
           (
               UpperCAmelCase     
           )     =    config_and_inputs
           UpperCAmelCase     =    {'pixel_values': pixel_values}
           return config, inputs_dict

@require_torch
class 					lowercase						(	__UpperCamelCase				, __UpperCamelCase				, unittest.TestCase ):




       '''simple docstring'''







       __SCREAMING_SNAKE_CASE										=					(
           (
               SwinModel,
               SwinBackbone,
               SwinForImageClassification,
               SwinForMaskedImageModeling,
           )
           if is_torch_available()
           else ()
       )
       __SCREAMING_SNAKE_CASE										=					(
           {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
           if is_torch_available()
           else {}
       )
       __SCREAMING_SNAKE_CASE										=					True

       __SCREAMING_SNAKE_CASE										=					False
       __SCREAMING_SNAKE_CASE										=					False
       __SCREAMING_SNAKE_CASE										=					False






       def 				snake_case_ (						self   )					->		Optional[Any]:

           """simple docstring"""
           UpperCAmelCase     =    SwinModelTester(self   )
           UpperCAmelCase     =    ConfigTester(self		,       config_class=_snake_case		,       embed_dim=37   )






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

           """simple docstring"""
           self.create_and_test_config_common_properties()
           self.config_tester.create_and_test_config_to_json_string()
           self.config_tester.create_and_test_config_to_json_file()
           self.config_tester.create_and_test_config_from_and_save_pretrained()
           self.config_tester.create_and_test_config_with_num_labels()
           self.config_tester.check_config_can_be_init_without_params()
           self.config_tester.check_config_arguments_init()






       def 				snake_case_ (						self   )					->		List[str]:

           """simple docstring"""
           return






       def 				snake_case_ (						self   )					->		List[Any]:

           """simple docstring"""
           UpperCAmelCase     =    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*_snake_case   )






       @unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.'''   )
       def 				snake_case_ (						self   )					->		Tuple:

           """simple docstring"""
           pass






       def 				snake_case_ (						self   )					->		Optional[Any]:

           """simple docstring"""
           super().test_training_gradient_checkpointing()






       def 				snake_case_ (						self   )					->		List[str]:

           """simple docstring"""
           UpperCAmelCase     =    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_backbone(*_snake_case   )






       def 				snake_case_ (						self   )					->		Dict:

           """simple docstring"""
           UpperCAmelCase     =    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_masked_image_modeling(*_snake_case   )






       def 				snake_case_ (						self   )					->		Dict:

           """simple docstring"""
           UpperCAmelCase     =    self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_image_classification(*_snake_case   )






       @unittest.skip(reason='''Swin does not use inputs_embeds'''   )
       def 				snake_case_ (						self   )					->		Any:

           """simple docstring"""
           pass






       @unittest.skip(reason='''Swin Transformer does not use feedforward chunking'''   )
       def 				snake_case_ (						self   )					->		Any:

           """simple docstring"""
           pass






       def 				snake_case_ (						self   )					->		Any:

           """simple docstring"""
           UpperCAmelCase     =    self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               UpperCAmelCase     =    model_class(_snake_case   )
               self.assertIsInstance(model.get_input_embeddings()		,       (nn.Module)   )
               UpperCAmelCase     =    model.get_output_embeddings()
               self.assertTrue(x is None or isinstance(_snake_case		,       nn.Linear   )   )






       def 				snake_case_ (						self   )					->		Dict:

           """simple docstring"""
           UpperCAmelCase     =    self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               UpperCAmelCase     =    model_class(_snake_case   )
               UpperCAmelCase     =    inspect.signature(model.forward   )
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               UpperCAmelCase     =    [*signature.parameters.keys()]

               UpperCAmelCase     =    ['pixel_values']
               self.assertListEqual(arg_names[:1]		,       _snake_case   )






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

           """simple docstring"""
           UpperCAmelCase     =    self.model_tester.prepare_config_and_inputs_for_common()
           UpperCAmelCase     =    True

           for model_class in self.all_model_classes:
               UpperCAmelCase     =    True
               UpperCAmelCase     =    False
               UpperCAmelCase     =    True
               UpperCAmelCase     =    model_class(_snake_case   )
               model.to(_snake_case   )
               model.eval()
               with torch.no_grad():
                   UpperCAmelCase     =    model(**self._prepare_for_class(_snake_case		,       _snake_case   )   )
               UpperCAmelCase     =    outputs.attentions
               UpperCAmelCase     =    len(self.model_tester.depths   )
               self.assertEqual(len(_snake_case   )		,       _snake_case   )

               # check that output_attentions also work using config
               del inputs_dict["output_attentions"]
               UpperCAmelCase     =    True
               UpperCAmelCase     =    config.window_size**2
               UpperCAmelCase     =    model_class(_snake_case   )
               model.to(_snake_case   )
               model.eval()
               with torch.no_grad():
                   UpperCAmelCase     =    model(**self._prepare_for_class(_snake_case		,       _snake_case   )   )
               UpperCAmelCase     =    outputs.attentions
               self.assertEqual(len(_snake_case   )		,       _snake_case   )

               self.assertListEqual(
                   list(attentions[0].shape[-3:]   )		,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,       )
               UpperCAmelCase     =    len(_snake_case   )

               # Check attention is always last and order is fine
               UpperCAmelCase     =    True
               UpperCAmelCase     =    True
               UpperCAmelCase     =    model_class(_snake_case   )
               model.to(_snake_case   )
               model.eval()
               with torch.no_grad():
                   UpperCAmelCase     =    model(**self._prepare_for_class(_snake_case		,       _snake_case   )   )

               # also another +1 for reshaped_hidden_states
               UpperCAmelCase     =    1 if model_class.__name__ == 'SwinBackbone' else 2
               self.assertEqual(out_len + added_hidden_states		,       len(_snake_case   )   )

               UpperCAmelCase     =    outputs.attentions

               self.assertEqual(len(_snake_case   )		,       _snake_case   )

               self.assertListEqual(
                   list(self_attentions[0].shape[-3:]   )		,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared]		,       )






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

           """simple docstring"""
           UpperCAmelCase     =    model_class(_snake_case   )
           model.to(_snake_case   )
           model.eval()

           with torch.no_grad():
               UpperCAmelCase     =    model(**self._prepare_for_class(_snake_case		,       _snake_case   )   )

           UpperCAmelCase     =    outputs.hidden_states

           UpperCAmelCase     =    getattr(
               self.model_tester		,       '''expected_num_hidden_layers'''		,       len(self.model_tester.depths   ) + 1   )
           self.assertEqual(len(_snake_case   )		,       _snake_case   )

           # Swin has a different seq_length
           UpperCAmelCase     =    (
               config.patch_size
               if isinstance(config.patch_size		,       collections.abc.Iterable   )
               else (config.patch_size, config.patch_size)
           )

           UpperCAmelCase     =    (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

           self.assertListEqual(
               list(hidden_states[0].shape[-2:]   )		,       [num_patches, self.model_tester.embed_dim]		,       )

           if not model_class.__name__ == "SwinBackbone":
               UpperCAmelCase     =    outputs.reshaped_hidden_states
               self.assertEqual(len(_snake_case   )		,       _snake_case   )

               UpperCAmelCase     =    reshaped_hidden_states[0].shape
               UpperCAmelCase     =    (
                   reshaped_hidden_states[0].view(_snake_case		,       _snake_case		,       height * width   ).permute(0		,       2		,       1   )
               )
               self.assertListEqual(
                   list(reshaped_hidden_states.shape[-2:]   )		,       [num_patches, self.model_tester.embed_dim]		,       )






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

           """simple docstring"""
           UpperCAmelCase     =    self.model_tester.prepare_config_and_inputs_for_common()

           UpperCAmelCase     =    (
               self.model_tester.image_size
               if isinstance(self.model_tester.image_size		,       collections.abc.Iterable   )
               else (self.model_tester.image_size, self.model_tester.image_size)
           )

           for model_class in self.all_model_classes:
               UpperCAmelCase     =    True
               self.check_hidden_states_output(_snake_case		,       _snake_case		,       _snake_case		,       _snake_case   )

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               UpperCAmelCase     =    True

               self.check_hidden_states_output(_snake_case		,       _snake_case		,       _snake_case		,       _snake_case   )






       def 				snake_case_ (						self   )					->		int:

           """simple docstring"""
           UpperCAmelCase     =    self.model_tester.prepare_config_and_inputs_for_common()
           UpperCAmelCase     =    3

           UpperCAmelCase     =    (
               self.model_tester.image_size
               if isinstance(self.model_tester.image_size		,       collections.abc.Iterable   )
               else (self.model_tester.image_size, self.model_tester.image_size)
           )
           UpperCAmelCase     =    (
               config.patch_size
               if isinstance(config.patch_size		,       collections.abc.Iterable   )
               else (config.patch_size, config.patch_size)
           )

           UpperCAmelCase     =    image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
           UpperCAmelCase     =    image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

           for model_class in self.all_model_classes:
               UpperCAmelCase     =    True
               self.check_hidden_states_output(_snake_case		,       _snake_case		,       _snake_case		,       (padded_height, padded_width)   )

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               UpperCAmelCase     =    True
               self.check_hidden_states_output(_snake_case		,       _snake_case		,       _snake_case		,       (padded_height, padded_width)   )






       @slow
       def 				snake_case_ (						self   )					->		Dict:

           """simple docstring"""
           for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               UpperCAmelCase     =    SwinModel.from_pretrained(_snake_case   )
               self.assertIsNotNone(_snake_case   )






       def 				snake_case_ (						self   )					->		Any:

           """simple docstring"""
           UpperCAmelCase     =    self.model_tester.prepare_config_and_inputs_for_common()

           UpperCAmelCase     =    _config_zero_init(_snake_case   )
           for model_class in self.all_model_classes:
               UpperCAmelCase     =    model_class(config=_snake_case   )
               for name, param in model.named_parameters():
                   if "embeddings" not in name and param.requires_grad:
                       self.assertIn(
                           ((param.data.mean() * 1e9).round() / 1e9).item()		,       [0.0, 1.0]		,       msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""		,       )

@require_vision
@require_torch
class 					lowercase						(	unittest.TestCase ):




       '''simple docstring'''







       @cached_property
       def 				snake_case_ (						self   )					->		List[str]:

           """simple docstring"""
           return (
               AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''   )
               if is_vision_available()
               else None
           )






       @slow
       def 				snake_case_ (						self   )					->		Optional[Any]:

           """simple docstring"""
           UpperCAmelCase     =    SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''   ).to(_snake_case   )
           UpperCAmelCase     =    self.default_image_processor

           UpperCAmelCase     =    Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
           UpperCAmelCase     =    image_processor(images=_snake_case		,       return_tensors='''pt'''   ).to(_snake_case   )

           # forward pass
           with torch.no_grad():
               UpperCAmelCase     =    model(**_snake_case   )

           # verify the logits
           UpperCAmelCase     =    torch.Size((1, 1000)   )
           self.assertEqual(outputs.logits.shape		,       _snake_case   )
           UpperCAmelCase     =    torch.tensor([-0.0948, -0.6454, -0.0921]   ).to(_snake_case   )
           self.assertTrue(torch.allclose(outputs.logits[0, :3]		,       _snake_case		,       atol=1e-4   )   )

@require_torch
class 					lowercase						(	unittest.TestCase				, __UpperCamelCase ):




       '''simple docstring'''







       __SCREAMING_SNAKE_CASE										=					(SwinBackbone,) if is_torch_available() else ()
       __SCREAMING_SNAKE_CASE										=					SwinConfig






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

           """simple docstring"""
           UpperCAmelCase     =    SwinModelTester(self   )








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


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


@require_sentencepiece
@require_tokenizers
class        A_					(       __UpperCamelCase					,      unittest.TestCase    ):




      '''simple docstring'''


      __snake_case					       =   ErnieMTokenizer
      __snake_case					       =   False
      __snake_case					       =   True
      __snake_case					       =   False
      __snake_case					       =   False




      def      _snake_case	(				self:       Optional[int]				):
       super().setUp()

       # We have a SentencePiece fixture for testing
       __lowerCamelCase		:							List[str]							=						ErnieMTokenizer(a						,      unk_token='<unk>'						,      pad_token='<pad>'				)
       tokenizer.save_pretrained(self.tmpdirname				)




      def      _snake_case	(				self:       Dict						,      a:       List[Any]				):
       __lowerCamelCase		:							Optional[Any]							=						'this is a test'
       __lowerCamelCase		:							Optional[int]							=						'this is a test'
       return input_text, output_text




      def      _snake_case	(				self:       Tuple				):
       __lowerCamelCase		:							List[str]							=						'<pad>'
       __lowerCamelCase		:							Union[str, Any]							=						0

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




      def      _snake_case	(				self:       List[Any]				):
       __lowerCamelCase		:							List[str]							=						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(a				)						,      3_0000				)




      def      _snake_case	(				self:       Tuple				):
       self.assertEqual(self.get_tokenizer().vocab_size						,      3_0000				)




      def      _snake_case	(				self:       int				):
       if not self.test_rust_tokenizer:
        return

       __lowerCamelCase		:							Any							=						self.get_tokenizer()
       __lowerCamelCase		:							Optional[Any]							=						self.get_rust_tokenizer()

       __lowerCamelCase		:							Optional[int]							=						'I was born in 92000, and this is falsé.'

       __lowerCamelCase		:							Optional[Any]							=						tokenizer.tokenize(a				)
       __lowerCamelCase		:							Dict							=						rust_tokenizer.tokenize(a				)
       self.assertListEqual(a						,      a				)

       __lowerCamelCase		:							List[str]							=						tokenizer.encode(a						,      add_special_tokens=a				)
       __lowerCamelCase		:							List[Any]							=						rust_tokenizer.encode(a						,      add_special_tokens=a				)
       self.assertListEqual(a						,      a				)

       __lowerCamelCase		:							str							=						self.get_rust_tokenizer()
       __lowerCamelCase		:							str							=						tokenizer.encode(a				)
       __lowerCamelCase		:							List[str]							=						rust_tokenizer.encode(a				)
       self.assertListEqual(a						,      a				)




      def      _snake_case	(				self:       Optional[Any]				):
       __lowerCamelCase		:							Union[str, Any]							=						ErnieMTokenizer(a						,      do_lower_case=a						,      unk_token='<unk>'						,      pad_token='<pad>'				)

       __lowerCamelCase		:							List[str]							=						tokenizer.tokenize('This is a test'				)
       self.assertListEqual(a						,      ['▁this', '▁is', '▁a', '▁test']				)

       self.assertListEqual(tokenizer.convert_tokens_to_ids(a				)						,      [48, 25, 21, 1289]				)

       __lowerCamelCase		:							Optional[Any]							=						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(
           a						,      ['▁i', '▁was', '▁born', '▁in', '9', '2000', ',', '▁and', '▁this', '▁is', '▁fal', 's', 'é', '.']				)
       __lowerCamelCase		:							Any							=						tokenizer.convert_tokens_to_ids(a				)
       self.assertListEqual(a						,      [31, 23, 386, 19, 518, 3050, 15, 17, 48, 25, 8256, 18, 1, 9]				)

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




      def      _snake_case	(				self:       str				):
       __lowerCamelCase		:							Tuple							=						ErnieMTokenizer(a						,      unk_token='<unk>'						,      pad_token='<pad>'				)

       __lowerCamelCase		:							Tuple							=						tokenizer.encode('sequence builders'				)
       __lowerCamelCase		:							List[Any]							=						tokenizer.encode('multi-sequence build'				)

       __lowerCamelCase		:							Optional[Any]							=						tokenizer.build_inputs_with_special_tokens(a				)
       __lowerCamelCase		:							Tuple							=						tokenizer.build_inputs_with_special_tokens(a						,      a				)

       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      _snake_case	(				self:       List[Any]				):
       # fmt: off
       __lowerCamelCase		:							int							=						{'input_ids': [[0, 1_1062, 8_2772, 7, 15, 8_2772, 538, 5_1529, 237, 1_7198, 1290, 206, 9, 21_5175, 1314, 136, 1_7198, 1290, 206, 9, 5_6359, 42, 12_2009, 9, 1_6466, 16, 8_7344, 4537, 9, 4717, 7_8381, 6, 15_9958, 7, 15, 2_4480, 618, 4, 527, 2_2693, 9, 304, 4, 2777, 2_4480, 9874, 4, 4_3523, 594, 4, 803, 1_8392, 3_3189, 18, 4, 4_3523, 2_4447, 5, 5, 5, 16, 100, 2_4955, 8_3658, 9626, 14_4057, 15, 839, 2_2335, 16, 136, 2_4955, 8_3658, 8_3479, 15, 3_9102, 724, 16, 678, 645, 6460, 1328, 4589, 42, 12_2009, 11_5774, 23, 3559, 1328, 4_6876, 7, 136, 5_3894, 1940, 4_2227, 4_1159, 1_7721, 823, 425, 4, 2_7512, 9_8722, 206, 136, 5531, 4970, 919, 1_7336, 5, 2], [0, 2_0080, 618, 83, 8_2775, 47, 479, 9, 1517, 73, 5_3894, 333, 8_0581, 11_0117, 1_8811, 5256, 1295, 51, 15_2526, 297, 7986, 390, 12_4416, 538, 3_5431, 214, 98, 1_5044, 2_5737, 136, 7108, 4_3701, 23, 756, 13_5355, 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, 581, 6_3773, 11_9455, 6, 14_7797, 8_8203, 7, 645, 70, 21, 3285, 1_0269, 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=a						,      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.',
           ]						,      )

