
import gc
import os
import tempfile
import unittest

import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, DDIMScheduler, StableDiffusionPipeline, UNetaDConditionModel
from diffusers.loaders import AttnProcsLayers, LoraLoaderMixin
from diffusers.models.attention_processor import (
    Attention,
    AttnProcessor,
    AttnProcessor2_0,
    LoRAAttnProcessor,
    LoRAAttnProcessor2_0,
    LoRAXFormersAttnProcessor,
    XFormersAttnProcessor,
)
from diffusers.utils import TEXT_ENCODER_ATTN_MODULE, floats_tensor, torch_device





def        lowerCAmelCase       (				snake_case__   :      int )->			Any:
    A_								=					{}
    for name in unet.attn_processors.keys():
        A_								=					None if name.endswith("attn1.processor" ) else unet.config.cross_attention_dim
        if name.startswith("mid_block" ):
            A_								=					unet.config.block_out_channels[-1]
        elif name.startswith("up_blocks" ):
            A_								=					int(name[len("up_blocks." )] )
            A_								=					list(reversed(unet.config.block_out_channels ) )[block_id]
        elif name.startswith("down_blocks" ):
            A_								=					int(name[len("down_blocks." )] )
            A_								=					unet.config.block_out_channels[block_id]
        A_								=					(
            LoRAAttnProcessor2_0 if hasattr(__lowerCAmelCase				,					"scaled_dot_product_attention" ) else LoRAAttnProcessor
        )
        A_								=					lora_attn_processor_class(
            hidden_size=__lowerCAmelCase				,					cross_attention_dim=__lowerCAmelCase )
    A_								=					AttnProcsLayers(__lowerCAmelCase )
    return lora_attn_procs, unet_lora_layers





def        lowerCAmelCase       (				snake_case__   :      Tuple )->			Any:
    A_								=					{}
    A_								=					(
        LoRAAttnProcessor2_0 if hasattr(__lowerCAmelCase				,					"scaled_dot_product_attention" ) else LoRAAttnProcessor
    )
    for name, module in text_encoder.named_modules():
        if name.endswith(__lowerCAmelCase ):
            A_								=					lora_attn_processor_class(
                hidden_size=module.out_proj.out_features				,					cross_attention_dim=__lowerCAmelCase )
    return text_lora_attn_procs





def        lowerCAmelCase       (				snake_case__   :      str )->			List[Any]:
    A_								=					create_text_encoder_lora_attn_procs(__lowerCAmelCase )
    A_								=					AttnProcsLayers(__lowerCAmelCase )
    return text_encoder_lora_layers





def        lowerCAmelCase       (				snake_case__   :      Optional[Any]				,					snake_case__   :      Optional[int]=False )->			Dict:



    for _, attn_proc in text_lora_attn_procs.items():
        # set up.weights
        for layer_name, layer_module in attn_proc.named_modules():
            if layer_name.endswith("_lora" ):
                A_								=					(
                    torch.randn_like(layer_module.up.weight )
                    if randn_weight
                    else torch.zeros_like(layer_module.up.weight )
                )
                A_								=					torch.nn.Parameter(__lowerCAmelCase )



class 							lowerCamelCase       (		unittest.TestCase					):



  """simple docstring"""





  def 					lowercase_						(					self					):
      torch.manual_seed(0					)
      A_								=					UNetaDConditionModel(
          block_out_channels=(32, 64)						,    layers_per_block=2						,    sample_size=32						,    in_channels=4						,    out_channels=4						,    down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")						,    up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")						,    cross_attention_dim=32						,    )
      A_								=					DDIMScheduler(
          beta_start=0.0_0085						,    beta_end=0.012						,    beta_schedule="scaled_linear"						,    clip_sample=__UpperCamelCase						,    set_alpha_to_one=__UpperCamelCase						,    steps_offset=1						,    )
      torch.manual_seed(0					)
      A_								=					AutoencoderKL(
          block_out_channels=[32, 64]						,    in_channels=3						,    out_channels=3						,    down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]						,    up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]						,    latent_channels=4						,    )
      A_								=					CLIPTextConfig(
          bos_token_id=0						,    eos_token_id=2						,    hidden_size=32						,    intermediate_size=37						,    layer_norm_eps=1E-05						,    num_attention_heads=4						,    num_hidden_layers=5						,    pad_token_id=1						,    vocab_size=1000						,    )
      A_								=					CLIPTextModel(__UpperCamelCase					)
      A_								=					CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"					)

      A_	,	A_								=					create_unet_lora_layers(__UpperCamelCase					)
      A_								=					create_text_encoder_lora_layers(__UpperCamelCase					)

      A_								=					{
          "unet": unet,
          "scheduler": scheduler,
          "vae": vae,
          "text_encoder": text_encoder,
          "tokenizer": tokenizer,
          "safety_checker": None,
          "feature_extractor": None,
      }
      A_								=					{
          "unet_lora_layers": unet_lora_layers,
          "text_encoder_lora_layers": text_encoder_lora_layers,
          "unet_lora_attn_procs": unet_lora_attn_procs,
      }
      return pipeline_components, lora_components

  def 					lowercase_						(					self					):
      A_								=					1
      A_								=					10
      A_								=					4
      A_								=					(32, 32)

      A_								=					torch.manual_seed(0					)
      A_								=					floats_tensor((batch_size, num_channels) + sizes					)
      A_								=					torch.randint(1						,    __UpperCamelCase						,    size=(batch_size, sequence_length)						,    generator=__UpperCamelCase					)

      A_								=					{
          "prompt": "A painting of a squirrel eating a burger",
          "generator": generator,
          "num_inference_steps": 2,
          "guidance_scale": 6.0,
          "output_type": "numpy",
      }

      return noise, input_ids, pipeline_inputs

      # copied from: https://colab.research.google.com/gist/sayakpaul/df2ef6e1ae6d8c10a49d859883b10860/scratchpad.ipynb

  def 					lowercase_						(					self					):
      A_								=					77

      A_								=					torch.randint(2						,    56						,    size=(1, max_seq_length)						,    generator=torch.manual_seed(0					)					)

      A_								=					{}
      A_								=					inputs
      return prepared_inputs

  def 					lowercase_						(					self						,    __UpperCamelCase					):
      A_	,	A_								=					self.get_dummy_components()
      LoraLoaderMixin.save_lora_weights(
          save_directory=__UpperCamelCase						,    unet_lora_layers=lora_components["unet_lora_layers"]						,    text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]						,    )
      self.assertTrue(os.path.isfile(os.path.join(__UpperCamelCase						,    "pytorch_lora_weights.bin"					)					)					)

  def 					lowercase_						(					self					):
      A_	,	A_								=					self.get_dummy_components()
      A_								=					StableDiffusionPipeline(**__UpperCamelCase					)
      A_								=					sd_pipe.to(__UpperCamelCase					)
      sd_pipe.set_progress_bar_config(disable=__UpperCamelCase					)

      A_	,	A_	,	A_								=					self.get_dummy_inputs()

      A_								=					sd_pipe(**__UpperCamelCase					).images
      A_								=					original_images[0, -3:, -3:, -1]

      with tempfile.TemporaryDirectory() as tmpdirname:
          LoraLoaderMixin.save_lora_weights(
              save_directory=__UpperCamelCase						,    unet_lora_layers=lora_components["unet_lora_layers"]						,    text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]						,    )
          self.assertTrue(os.path.isfile(os.path.join(__UpperCamelCase						,    "pytorch_lora_weights.bin"					)					)					)
          sd_pipe.load_lora_weights(__UpperCamelCase					)

      A_								=					sd_pipe(**__UpperCamelCase					).images
      A_								=					lora_images[0, -3:, -3:, -1]

      # Outputs shouldn't match.
      self.assertFalse(torch.allclose(torch.from_numpy(__UpperCamelCase					)						,    torch.from_numpy(__UpperCamelCase					)					)					)

  def 					lowercase_						(					self					):
      A_	,	A_								=					self.get_dummy_components()
      A_								=					StableDiffusionPipeline(**__UpperCamelCase					)
      A_								=					sd_pipe.to(__UpperCamelCase					)
      sd_pipe.set_progress_bar_config(disable=__UpperCamelCase					)

      A_	,	A_	,	A_								=					self.get_dummy_inputs()

      A_								=					sd_pipe(**__UpperCamelCase					).images
      A_								=					original_images[0, -3:, -3:, -1]

      with tempfile.TemporaryDirectory() as tmpdirname:
          LoraLoaderMixin.save_lora_weights(
              save_directory=__UpperCamelCase						,    unet_lora_layers=lora_components["unet_lora_layers"]						,    text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]						,    safe_serialization=__UpperCamelCase						,    )
          self.assertTrue(os.path.isfile(os.path.join(__UpperCamelCase						,    "pytorch_lora_weights.safetensors"					)					)					)
          sd_pipe.load_lora_weights(__UpperCamelCase					)

      A_								=					sd_pipe(**__UpperCamelCase					).images
      A_								=					lora_images[0, -3:, -3:, -1]

      # Outputs shouldn't match.
      self.assertFalse(torch.allclose(torch.from_numpy(__UpperCamelCase					)						,    torch.from_numpy(__UpperCamelCase					)					)					)

  def 					lowercase_						(					self					):
      A_	,	A_								=					self.get_dummy_components()
      A_								=					lora_components["unet_lora_attn_procs"]
      A_								=					StableDiffusionPipeline(**__UpperCamelCase					)
      A_								=					sd_pipe.to(__UpperCamelCase					)
      sd_pipe.set_progress_bar_config(disable=__UpperCamelCase					)

      A_	,	A_	,	A_								=					self.get_dummy_inputs()

      A_								=					sd_pipe(**__UpperCamelCase					).images
      A_								=					original_images[0, -3:, -3:, -1]

      with tempfile.TemporaryDirectory() as tmpdirname:
          A_								=					sd_pipe.unet
          unet.set_attn_processor(__UpperCamelCase					)
          unet.save_attn_procs(__UpperCamelCase					)
          self.assertTrue(os.path.isfile(os.path.join(__UpperCamelCase						,    "pytorch_lora_weights.bin"					)					)					)
          sd_pipe.load_lora_weights(__UpperCamelCase					)

      A_								=					sd_pipe(**__UpperCamelCase					).images
      A_								=					lora_images[0, -3:, -3:, -1]

      # Outputs shouldn't match.
      self.assertFalse(torch.allclose(torch.from_numpy(__UpperCamelCase					)						,    torch.from_numpy(__UpperCamelCase					)					)					)

  def 					lowercase_						(					self					):
      A_	,	A_								=					self.get_dummy_components()
      A_								=					StableDiffusionPipeline(**__UpperCamelCase					)

      A_								=					self.get_dummy_tokens()

      # inference without lora
      A_								=					pipe.text_encoder(**__UpperCamelCase					)[0]
      assert outputs_without_lora.shape == (1, 77, 32)

      # create lora_attn_procs with zeroed out up.weights
      A_								=					create_text_encoder_lora_attn_procs(pipe.text_encoder					)
      set_lora_up_weights(__UpperCamelCase						,    randn_weight=__UpperCamelCase					)

      # monkey patch
      pipe._modify_text_encoder(__UpperCamelCase					)

      # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
      del text_attn_procs
      gc.collect()

      # inference with lora
      A_								=					pipe.text_encoder(**__UpperCamelCase					)[0]
      assert outputs_with_lora.shape == (1, 77, 32)

      assert torch.allclose(
          __UpperCamelCase						,    __UpperCamelCase					), "lora_up_weight are all zero, so the lora outputs should be the same to without lora outputs"

      # create lora_attn_procs with randn up.weights
      A_								=					create_text_encoder_lora_attn_procs(pipe.text_encoder					)
      set_lora_up_weights(__UpperCamelCase						,    randn_weight=__UpperCamelCase					)

      # monkey patch
      pipe._modify_text_encoder(__UpperCamelCase					)

      # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
      del text_attn_procs
      gc.collect()

      # inference with lora
      A_								=					pipe.text_encoder(**__UpperCamelCase					)[0]
      assert outputs_with_lora.shape == (1, 77, 32)

      assert not torch.allclose(
          __UpperCamelCase						,    __UpperCamelCase					), "lora_up_weight are not zero, so the lora outputs should be different to without lora outputs"

  def 					lowercase_						(					self					):
      A_	,	A_								=					self.get_dummy_components()
      A_								=					StableDiffusionPipeline(**__UpperCamelCase					)

      A_								=					self.get_dummy_tokens()

      # inference without lora
      A_								=					pipe.text_encoder(**__UpperCamelCase					)[0]
      assert outputs_without_lora.shape == (1, 77, 32)

      # create lora_attn_procs with randn up.weights
      A_								=					create_text_encoder_lora_attn_procs(pipe.text_encoder					)
      set_lora_up_weights(__UpperCamelCase						,    randn_weight=__UpperCamelCase					)

      # monkey patch
      pipe._modify_text_encoder(__UpperCamelCase					)

      # verify that it's okay to release the text_attn_procs which holds the LoRAAttnProcessor.
      del text_attn_procs
      gc.collect()

      # inference with lora
      A_								=					pipe.text_encoder(**__UpperCamelCase					)[0]
      assert outputs_with_lora.shape == (1, 77, 32)

      assert not torch.allclose(
          __UpperCamelCase						,    __UpperCamelCase					), "lora outputs should be different to without lora outputs"

      # remove monkey patch
      pipe._remove_text_encoder_monkey_patch()

      # inference with removed lora
      A_								=					pipe.text_encoder(**__UpperCamelCase					)[0]
      assert outputs_without_lora_removed.shape == (1, 77, 32)

      assert torch.allclose(
          __UpperCamelCase						,    __UpperCamelCase					), "remove lora monkey patch should restore the original outputs"

  def 					lowercase_						(					self					):
      A_	,	A_								=					self.get_dummy_components()
      A_								=					StableDiffusionPipeline(**__UpperCamelCase					)
      A_								=					sd_pipe.to(__UpperCamelCase					)
      sd_pipe.set_progress_bar_config(disable=__UpperCamelCase					)

      A_	,	A_	,	A_								=					self.get_dummy_inputs()

      with tempfile.TemporaryDirectory() as tmpdirname:
          LoraLoaderMixin.save_lora_weights(
              save_directory=__UpperCamelCase						,    unet_lora_layers=lora_components["unet_lora_layers"]						,    text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]						,    )
          self.assertTrue(os.path.isfile(os.path.join(__UpperCamelCase						,    "pytorch_lora_weights.bin"					)					)					)
          sd_pipe.load_lora_weights(__UpperCamelCase					)

      A_								=					sd_pipe(**__UpperCamelCase					).images
      A_								=					lora_images[0, -3:, -3:, -1]

      A_								=					sd_pipe(**__UpperCamelCase						,    cross_attention_kwargs={"scale": 0.5}					).images
      A_								=					lora_images_with_scale[0, -3:, -3:, -1]

      # Outputs shouldn't match.
      self.assertFalse(
          torch.allclose(torch.from_numpy(__UpperCamelCase					)						,    torch.from_numpy(__UpperCamelCase					)					)					)

  def 					lowercase_						(					self					):







      with tempfile.TemporaryDirectory() as tmpdirname:
          self.create_lora_weight_file(__UpperCamelCase					)

          A_	,	A_								=					self.get_dummy_components()
          A_								=					StableDiffusionPipeline(**__UpperCamelCase					)
          A_								=					sd_pipe.to(__UpperCamelCase					)
          sd_pipe.set_progress_bar_config(disable=__UpperCamelCase					)

          # check if vanilla attention processors are used
          for _, module in sd_pipe.unet.named_modules():
              if isinstance(__UpperCamelCase						,    __UpperCamelCase					):
                  self.assertIsInstance(module.processor						,    (AttnProcessor, AttnProcessor2_0)					)

            # load LoRA weight file
          sd_pipe.load_lora_weights(__UpperCamelCase					)

          # check if lora attention processors are used
          for _, module in sd_pipe.unet.named_modules():
              if isinstance(__UpperCamelCase						,    __UpperCamelCase					):
                  A_								=					(
                      LoRAAttnProcessor2_0 if hasattr(__UpperCamelCase						,    "scaled_dot_product_attention"					) else LoRAAttnProcessor
                  )
                  self.assertIsInstance(module.processor						,    __UpperCamelCase					)

  @unittest.skipIf(torch_device != "cuda"						,    "This test is supposed to run on GPU"					)
  def 					lowercase_						(					self					):







      with tempfile.TemporaryDirectory() as tmpdirname:
          self.create_lora_weight_file(__UpperCamelCase					)

          A_	,	A_								=					self.get_dummy_components()
          A_								=					StableDiffusionPipeline(**__UpperCamelCase					)
          A_								=					sd_pipe.to(__UpperCamelCase					)
          sd_pipe.set_progress_bar_config(disable=__UpperCamelCase					)

          # enable XFormers
          sd_pipe.enable_xformers_memory_efficient_attention()

          # check if xFormers attention processors are used
          for _, module in sd_pipe.unet.named_modules():
              if isinstance(__UpperCamelCase						,    __UpperCamelCase					):
                  self.assertIsInstance(module.processor						,    __UpperCamelCase					)

            # load LoRA weight file
          sd_pipe.load_lora_weights(__UpperCamelCase					)

          # check if lora attention processors are used
          for _, module in sd_pipe.unet.named_modules():
              if isinstance(__UpperCamelCase						,    __UpperCamelCase					):
                  self.assertIsInstance(module.processor						,    __UpperCamelCase					)

  @unittest.skipIf(torch_device != "cuda"						,    "This test is supposed to run on GPU"					)
  def 					lowercase_						(					self					):
      A_	,	A_								=					self.get_dummy_components()
      A_								=					StableDiffusionPipeline(**__UpperCamelCase					)
      A_								=					sd_pipe.to(__UpperCamelCase					)
      sd_pipe.set_progress_bar_config(disable=__UpperCamelCase					)

      A_	,	A_	,	A_								=					self.get_dummy_inputs()

      # enable XFormers
      sd_pipe.enable_xformers_memory_efficient_attention()

      A_								=					sd_pipe(**__UpperCamelCase					).images
      A_								=					original_images[0, -3:, -3:, -1]

      with tempfile.TemporaryDirectory() as tmpdirname:
          LoraLoaderMixin.save_lora_weights(
              save_directory=__UpperCamelCase						,    unet_lora_layers=lora_components["unet_lora_layers"]						,    text_encoder_lora_layers=lora_components["text_encoder_lora_layers"]						,    )
          self.assertTrue(os.path.isfile(os.path.join(__UpperCamelCase						,    "pytorch_lora_weights.bin"					)					)					)
          sd_pipe.load_lora_weights(__UpperCamelCase					)

      A_								=					sd_pipe(**__UpperCamelCase					).images
      A_								=					lora_images[0, -3:, -3:, -1]

      # Outputs shouldn't match.
      self.assertFalse(torch.allclose(torch.from_numpy(__UpperCamelCase					)						,    torch.from_numpy(__UpperCamelCase					)					)					)














import json
import os
import unittest

from transformers.models.gpt_neox_japanese.tokenization_gpt_neox_japanese import (
    VOCAB_FILES_NAMES,
    GPTNeoXJapaneseTokenizer,
)
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin





@require_tokenizers
class __lowerCamelCase					( snake_case__	,			unittest.TestCase):





	"""simple docstring"""






	UpperCamelCase__								= GPTNeoXJapaneseTokenizer
	UpperCamelCase__								= False
	UpperCamelCase__								= {"do_clean_text": False, "add_prefix_space": False}

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							super().setUp()

							_UpperCAmelCase							   =     [
							    'こん',
							    'こんに',
							    'にちは',
							    'ばんは',
							    '世界,㔺界',
							    '、',
							    '。',
							    '<BR>',
							    '<SP>',
							    '<TAB>',
							    '<URL>',
							    '<EMAIL>',
							    '<TEL>',
							    '<DATE>',
							    '<PRICE>',
							    '<BLOCK>',
							    '<KIGOU>',
							    '<U2000U2BFF>',
							    '<|emoji1|>',
							    '<unk>',
							    '<|startoftext|>',
							    '<|endoftext|>',
							]
							_UpperCAmelCase							   =     {'emoji': {'\ud83d\ude00': '<|emoji1|>'}, 'emoji_inv': {'<|emoji1|>': '\ud83d\ude00'}}  # 😀
							_UpperCAmelCase							   =     {'unk_token': '<unk>'}

							_UpperCAmelCase							   =     os.path.join(self.tmpdirname			,       VOCAB_FILES_NAMES['vocab_file']       )
							_UpperCAmelCase							   =     os.path.join(self.tmpdirname			,       VOCAB_FILES_NAMES['emoji_file']       )
							with open(self.vocab_file			,       'w'			,       encoding='utf-8'       ) as vocab_writer:
													vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]       )       )
							with open(self.emoji_file			,       'w'       ) as emoji_writer:
													emoji_writer.write(json.dumps(UpperCAmelCase       )       )

	def 			UpperCamelCase       (				self			,       **UpperCAmelCase       ):
							"""simple docstring"""







							kwargs.update(self.special_tokens_map       )
							return GPTNeoXJapaneseTokenizer.from_pretrained(self.tmpdirname			,       **UpperCAmelCase       )

	def 			UpperCamelCase       (				self			,       UpperCAmelCase       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     'こんにちは、世界。 \nこんばんは、㔺界。😀'
							_UpperCAmelCase							   =     'こんにちは、世界。 \nこんばんは、世界。😀'
							return input_text, output_text

	def 			UpperCamelCase       (				self			,       UpperCAmelCase       ):
							"""simple docstring"""







							_UpperCAmelCase   ,					_UpperCAmelCase							   =     self.get_input_output_texts(UpperCAmelCase       )
							_UpperCAmelCase							   =     tokenizer.encode(UpperCAmelCase			,       add_special_tokens=UpperCAmelCase       )
							_UpperCAmelCase							   =     tokenizer.decode(UpperCAmelCase			,       clean_up_tokenization_spaces=UpperCAmelCase       )
							return text, ids

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							pass  # TODO add if relevant

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							pass  # TODO add if relevant

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							pass  # TODO add if relevant

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     self.get_tokenizer()

							# Testing tokenization
							_UpperCAmelCase							   =     'こんにちは、世界。　こんばんは、㔺界。'
							_UpperCAmelCase							   =     ['こん', 'にちは', '、', '世界', '。', '<SP>', 'こん', 'ばんは', '、', '㔺界', '。']
							_UpperCAmelCase							   =     tokenizer.tokenize(UpperCAmelCase       )
							self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )

							# Testing conversion to ids without special tokens
							_UpperCAmelCase							   =     [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6]
							_UpperCAmelCase							   =     tokenizer.convert_tokens_to_ids(UpperCAmelCase       )
							self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )

							# Testing conversion to ids with special tokens
							_UpperCAmelCase							   =     tokens + [tokenizer.unk_token]
							_UpperCAmelCase							   =     [0, 2, 5, 4, 6, 8, 0, 3, 5, 4, 6, 19]
							_UpperCAmelCase							   =     tokenizer.convert_tokens_to_ids(UpperCAmelCase       )
							self.assertListEqual(UpperCAmelCase			,       UpperCAmelCase       )

	@slow
	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							_UpperCAmelCase							   =     self.tokenizer_class.from_pretrained('abeja/gpt-neox-japanese-2.7b'       )

							_UpperCAmelCase							   =     tokenizer.encode('ありがとう。'			,       add_special_tokens=UpperCAmelCase       )
							_UpperCAmelCase							   =     tokenizer.encode('どういたしまして。'			,       add_special_tokens=UpperCAmelCase       )

							_UpperCAmelCase							   =     tokenizer.build_inputs_with_special_tokens(UpperCAmelCase       )
							_UpperCAmelCase							   =     tokenizer.build_inputs_with_special_tokens(UpperCAmelCase			,       UpperCAmelCase       )

							assert encoded_sentence == ids_a
							assert encoded_pair == ids_a + ids_a

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							pass

	def 			UpperCamelCase       (				self       ):
							"""simple docstring"""







							pass
