






"""simple docstring"""





import tempfile
import unittest

import numpy as np
import torch

from diffusers import ScoreSdeVeScheduler







class 						_a  (		unittest.TestCase       ):





   '''simple docstring'''






   UpperCamelCase__     	=							(ScoreSdeVeScheduler,)
   UpperCamelCase__     	=							()





   @property
   def __lowercase							(       self)			->   Tuple:




          '''simple docstring'''




          lowercase__:							Union[str, Any]         =     4
          lowercase__:							Union[str, Any]         =     3
          lowercase__:							Any         =     8
          lowercase__:							Union[str, Any]         =     8

          lowercase__:							Optional[Any]         =     torch.rand((batch_size, num_channels, height, width))

          return sample





   @property
   def __lowercase							(       self)			->   Optional[Any]:




          '''simple docstring'''




          lowercase__:							Dict         =     4
          lowercase__:							List[str]         =     3
          lowercase__:							List[str]         =     8
          lowercase__:							Union[str, Any]         =     8

          lowercase__:							str         =     batch_size * num_channels * height * width
          lowercase__:							Union[str, Any]         =     torch.arange(_SCREAMING_SNAKE_CASE)
          lowercase__:							Optional[Any]         =     sample.reshape(_SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE)
          lowercase__:							int         =     sample / num_elems
          lowercase__:							List[Any]         =     sample.permute(3					, 0					, 1					, 2)

          return sample





   def __lowercase							(       self)			->   Dict:




          '''simple docstring'''




          def model(UpperCAmelCase_					, UpperCAmelCase_					, *UpperCAmelCase_):
                 return sample * t / (t + 1)

          return model





   def __lowercase							(       self					, **UpperCAmelCase_)			->   Optional[Any]:




          '''simple docstring'''




          lowercase__:							Tuple         =     {
              "num_train_timesteps": 2_000,
              "snr": 0.15,
              "sigma_min": 0.01,
              "sigma_max": 1_348,
              "sampling_eps": 1E-5,
          }

          config.update(**_SCREAMING_SNAKE_CASE)
          return config





   def __lowercase							(       self					, UpperCAmelCase_=0					, **UpperCAmelCase_)			->   str:




          '''simple docstring'''




          lowercase__:							Union[str, Any]         =     dict(self.forward_default_kwargs)

          for scheduler_class in self.scheduler_classes:
                 lowercase__:							int         =     self.dummy_sample
                 lowercase__:							Optional[Any]         =     0.1 * sample

                 lowercase__:							List[str]         =     self.get_scheduler_config(**_SCREAMING_SNAKE_CASE)
                 lowercase__:							Tuple         =     scheduler_class(**_SCREAMING_SNAKE_CASE)

                 with tempfile.TemporaryDirectory() as tmpdirname:
                        scheduler.save_config(_SCREAMING_SNAKE_CASE)
                        lowercase__:							Union[str, Any]         =     scheduler_class.from_pretrained(_SCREAMING_SNAKE_CASE)

                 lowercase__:							Tuple         =     scheduler.step_pred(
                     _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, generator=torch.manual_seed(0)					, **_SCREAMING_SNAKE_CASE).prev_sample
                 lowercase__:							List[str]         =     new_scheduler.step_pred(
                     _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, generator=torch.manual_seed(0)					, **_SCREAMING_SNAKE_CASE).prev_sample

                 assert torch.sum(torch.abs(output - new_output)) < 1E-5, "Scheduler outputs are not identical"

                 lowercase__:							List[Any]         =     scheduler.step_correct(_SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, generator=torch.manual_seed(0)					, **_SCREAMING_SNAKE_CASE).prev_sample
                 lowercase__:							List[Any]         =     new_scheduler.step_correct(
                     _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, generator=torch.manual_seed(0)					, **_SCREAMING_SNAKE_CASE).prev_sample

                 assert torch.sum(torch.abs(output - new_output)) < 1E-5, "Scheduler correction are not identical"





   def __lowercase							(       self					, UpperCAmelCase_=0					, **UpperCAmelCase_)			->   Dict:




          '''simple docstring'''




          lowercase__:							Tuple         =     dict(self.forward_default_kwargs)
          kwargs.update(_SCREAMING_SNAKE_CASE)

          for scheduler_class in self.scheduler_classes:
                 lowercase__:							Union[str, Any]         =     self.dummy_sample
                 lowercase__:							Tuple         =     0.1 * sample

                 lowercase__:							Tuple         =     self.get_scheduler_config()
                 lowercase__:							int         =     scheduler_class(**_SCREAMING_SNAKE_CASE)

                 with tempfile.TemporaryDirectory() as tmpdirname:
                        scheduler.save_config(_SCREAMING_SNAKE_CASE)
                        lowercase__:							int         =     scheduler_class.from_pretrained(_SCREAMING_SNAKE_CASE)

                 lowercase__:							List[str]         =     scheduler.step_pred(
                     _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, generator=torch.manual_seed(0)					, **_SCREAMING_SNAKE_CASE).prev_sample
                 lowercase__:							List[str]         =     new_scheduler.step_pred(
                     _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, generator=torch.manual_seed(0)					, **_SCREAMING_SNAKE_CASE).prev_sample

                 assert torch.sum(torch.abs(output - new_output)) < 1E-5, "Scheduler outputs are not identical"

                 lowercase__:							Dict         =     scheduler.step_correct(_SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, generator=torch.manual_seed(0)					, **_SCREAMING_SNAKE_CASE).prev_sample
                 lowercase__:							Dict         =     new_scheduler.step_correct(
                     _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, generator=torch.manual_seed(0)					, **_SCREAMING_SNAKE_CASE).prev_sample

                 assert torch.sum(torch.abs(output - new_output)) < 1E-5, "Scheduler correction are not identical"





   def __lowercase							(       self)			->   Dict:




          '''simple docstring'''




          for timesteps in [10, 100, 1_000]:
                 self.check_over_configs(num_train_timesteps=_SCREAMING_SNAKE_CASE)





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




          '''simple docstring'''




          for sigma_min, sigma_max in zip([0.00_01, 0.0_01, 0.01]					, [1, 100, 1_000]):
                 self.check_over_configs(sigma_min=_SCREAMING_SNAKE_CASE					, sigma_max=_SCREAMING_SNAKE_CASE)





   def __lowercase							(       self)			->   str:




          '''simple docstring'''




          for t in [0.1, 0.5, 0.75]:
                 self.check_over_forward(time_step=_SCREAMING_SNAKE_CASE)





   def __lowercase							(       self)			->   Dict:




          '''simple docstring'''




          lowercase__:							Optional[int]         =     dict(self.forward_default_kwargs)

          lowercase__:							Optional[int]         =     self.scheduler_classes[0]
          lowercase__:							Dict         =     self.get_scheduler_config()
          lowercase__:							int         =     scheduler_class(**_SCREAMING_SNAKE_CASE)

          lowercase__:							Union[str, Any]         =     3

          lowercase__:							List[Any]         =     self.dummy_model()
          lowercase__:							Optional[int]         =     self.dummy_sample_deter

          scheduler.set_sigmas(_SCREAMING_SNAKE_CASE)
          scheduler.set_timesteps(_SCREAMING_SNAKE_CASE)
          lowercase__:							Dict         =     torch.manual_seed(0)

          for i, t in enumerate(scheduler.timesteps):
                 lowercase__:							Optional[Any]         =     scheduler.sigmas[i]

                 for _ in range(scheduler.config.correct_steps):
                        with torch.no_grad():
                               lowercase__:							Any         =     model(_SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE)
                        lowercase__:							Union[str, Any]         =     scheduler.step_correct(_SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, generator=_SCREAMING_SNAKE_CASE					, **_SCREAMING_SNAKE_CASE).prev_sample

                 with torch.no_grad():
                        lowercase__:							Union[str, Any]         =     model(_SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE)

                 lowercase__:							List[Any]         =     scheduler.step_pred(_SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, _SCREAMING_SNAKE_CASE					, generator=_SCREAMING_SNAKE_CASE					, **_SCREAMING_SNAKE_CASE)
                 lowercase__    ,      lowercase__:							str         =     output.prev_sample, output.prev_sample_mean

          lowercase__:							int         =     torch.sum(torch.abs(_SCREAMING_SNAKE_CASE))
          lowercase__:							Tuple         =     torch.mean(torch.abs(_SCREAMING_SNAKE_CASE))

          assert np.isclose(result_sum.item()					, 14_372_758_528.0)
          assert np.isclose(result_mean.item()					, 18_714_530.0)





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




          '''simple docstring'''




          lowercase__:							Dict         =     dict(self.forward_default_kwargs)

          lowercase__:							str         =     kwargs.pop("num_inference_steps"					, _SCREAMING_SNAKE_CASE)

          for scheduler_class in self.scheduler_classes:
                 lowercase__:							Dict         =     self.get_scheduler_config()
                 lowercase__:							int         =     scheduler_class(**_SCREAMING_SNAKE_CASE)

                 lowercase__:							int         =     self.dummy_sample
                 lowercase__:							Union[str, Any]         =     0.1 * sample

                 if num_inference_steps is not None and hasattr(_SCREAMING_SNAKE_CASE					, "set_timesteps"):
                        scheduler.set_timesteps(_SCREAMING_SNAKE_CASE)
                 elif num_inference_steps is not None and not hasattr(_SCREAMING_SNAKE_CASE					, "set_timesteps"):
                        lowercase__:							Optional[Any]         =     num_inference_steps

                 lowercase__:							Any         =     scheduler.step_pred(_SCREAMING_SNAKE_CASE					, 0					, _SCREAMING_SNAKE_CASE					, generator=torch.manual_seed(0)					, **_SCREAMING_SNAKE_CASE).prev_sample
                 lowercase__:							int         =     scheduler.step_pred(_SCREAMING_SNAKE_CASE					, 1					, _SCREAMING_SNAKE_CASE					, generator=torch.manual_seed(0)					, **_SCREAMING_SNAKE_CASE).prev_sample

                 self.assertEqual(output_a.shape					, sample.shape)
                 self.assertEqual(output_a.shape					, output_a.shape)













import unittest

from transformers.testing_utils import is_torch_available, require_torch, tooslow

from ...generation.test_utils import 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 (
         CpmAntConfig,
         CpmAntForCausalLM,
         CpmAntModel,
         CpmAntTokenizer,
     )



@require_torch
class 				_UpperCamelCase       :

       def __init__(		self:			Optional[Any]       , _SCREAMING_SNAKE_CASE:			Any       , _SCREAMING_SNAKE_CASE:			List[Any]=2       , _SCREAMING_SNAKE_CASE:			List[str]=8       , _SCREAMING_SNAKE_CASE:			Optional[Any]=True       , _SCREAMING_SNAKE_CASE:			List[str]=False       , _SCREAMING_SNAKE_CASE:			int=False       , _SCREAMING_SNAKE_CASE:			Optional[Any]=False       , _SCREAMING_SNAKE_CASE:			List[str]=False       , _SCREAMING_SNAKE_CASE:			List[Any]=99       , _SCREAMING_SNAKE_CASE:			str=32       , _SCREAMING_SNAKE_CASE:			Tuple=3       , _SCREAMING_SNAKE_CASE:			Union[str, Any]=4       , _SCREAMING_SNAKE_CASE:			List[Any]=37       , _SCREAMING_SNAKE_CASE:			int=32       , _SCREAMING_SNAKE_CASE:			int=128       , _SCREAMING_SNAKE_CASE:			Dict=8       , _SCREAMING_SNAKE_CASE:			Optional[Any]=8       , _SCREAMING_SNAKE_CASE:			str=8       , _SCREAMING_SNAKE_CASE:			Dict=1.0       , _SCREAMING_SNAKE_CASE:			List[str]=True       , )							->			Optional[int]:




              """simple docstring"""


              UpperCamelCase_ 							=	parent
              UpperCamelCase_ 							=	batch_size
              UpperCamelCase_ 							=	seq_length
              UpperCamelCase_ 							=	is_training
              UpperCamelCase_ 							=	use_token_type_ids
              UpperCamelCase_ 							=	use_input_mask
              UpperCamelCase_ 							=	use_labels
              UpperCamelCase_ 							=	use_mc_token_ids
              UpperCamelCase_ 							=	vocab_size
              UpperCamelCase_ 							=	hidden_size
              UpperCamelCase_ 							=	num_hidden_layers
              UpperCamelCase_ 							=	num_attention_heads
              UpperCamelCase_ 							=	intermediate_size
              UpperCamelCase_ 							=	num_buckets
              UpperCamelCase_ 							=	max_distance
              UpperCamelCase_ 							=	prompt_length
              UpperCamelCase_ 							=	prompt_types
              UpperCamelCase_ 							=	segment_types
              UpperCamelCase_ 							=	init_std
              UpperCamelCase_ 							=	return_dict

       def lowercase			(		self:			Dict		)							->			str:




              """simple docstring"""


              UpperCamelCase_ 							=	{}
              UpperCamelCase_ 							=	ids_tensor([self.batch_size, self.seq_length]       , self.vocab_size		).type(torch.intaa		)
              UpperCamelCase_ 							=	False

              UpperCamelCase_ 							=	self.get_config()

              return (config, input_ids)

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




              """simple docstring"""


              return CpmAntConfig(
                  vocab_size=self.vocab_size       , hidden_size=self.hidden_size       , num_hidden_layers=self.num_hidden_layers       , num_attention_heads=self.num_attention_heads       , dim_ff=self.intermediate_size       , position_bias_num_buckets=self.num_buckets       , position_bias_max_distance=self.max_distance       , prompt_types=self.prompt_types       , prompt_length=self.prompt_length       , segment_types=self.segment_types       , use_cache=_SCREAMING_SNAKE_CASE       , init_std=self.init_std       , return_dict=self.return_dict       , )

       def lowercase			(		self:			Dict       , _SCREAMING_SNAKE_CASE:			Union[str, Any]       , _SCREAMING_SNAKE_CASE:			List[str]       , *_SCREAMING_SNAKE_CASE:			Tuple		)							->			str:




              """simple docstring"""


              UpperCamelCase_ 							=	CpmAntModel(config=_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              model.eval()

              UpperCamelCase_ 							=	model(**_SCREAMING_SNAKE_CASE		).last_hidden_state

              self.parent.assertEqual(hidden_states.shape       , (self.batch_size, self.seq_length, config.hidden_size)		)

       def lowercase			(		self:			Optional[Any]       , _SCREAMING_SNAKE_CASE:			Tuple       , _SCREAMING_SNAKE_CASE:			Optional[Any]       , *_SCREAMING_SNAKE_CASE:			Dict		)							->			Optional[int]:




              """simple docstring"""


              UpperCamelCase_ 							=	CpmAntForCausalLM(_SCREAMING_SNAKE_CASE		)
              model.to(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	input_ids["input_ids"].to(_SCREAMING_SNAKE_CASE		)
              model.eval()

              UpperCamelCase_ 							=	model(**_SCREAMING_SNAKE_CASE		)
              self.parent.assertEqual(
                  model_output.logits.shape       , (self.batch_size, self.seq_length, config.vocab_size + config.prompt_types * config.prompt_length)       , )



       def lowercase			(		self:			Any		)							->			Dict:




              """simple docstring"""


              UpperCamelCase_							,			UpperCamelCase_ 							=	self.prepare_config_and_inputs()
              return config, inputs_dict



@require_torch
class 				_UpperCamelCase       (						lowerCAmelCase_	,    lowerCAmelCase_	,    unittest.TestCase  ):
       _UpperCamelCase					:       Dict       = (CpmAntModel, CpmAntForCausalLM) if is_torch_available() else ()
       _UpperCamelCase					:       Union[str, Any]       = (
           {'''feature-extraction''': CpmAntModel, '''text-generation''': CpmAntForCausalLM} if is_torch_available() else {}
       )

       _UpperCamelCase					:       Optional[Any]       = False
       _UpperCamelCase					:       Dict       = False
       _UpperCamelCase					:       Any       = False
       _UpperCamelCase					:       Optional[Any]       = False
       _UpperCamelCase					:       Any       = False

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




              """simple docstring"""


              UpperCamelCase_ 							=	CpmAntModelTester(self		)
              UpperCamelCase_ 							=	ConfigTester(self       , config_class=_SCREAMING_SNAKE_CASE		)

       def lowercase			(		self:			str		)							->			Any:




              """simple docstring"""


              self.config_tester.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.check_config_can_be_init_without_params()
              self.config_tester.check_config_arguments_init()

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




              """simple docstring"""


              unittest.skip("CPMAnt doesn't support input_embeds."		)(self.test_inputs_embeds		)

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




              """simple docstring"""


              unittest.skip(
                  "CPMAnt doesn't support retain grad in hidden_states or attentions, because prompt management will peel off the output.hidden_states from graph.\
                 So is attentions. We strongly recommand you use loss to tune model."		)(self.test_retain_grad_hidden_states_attentions		)

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




              """simple docstring"""


              UpperCamelCase_							,			UpperCamelCase_ 							=	self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_cpmant_model(_SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE		)



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




              """simple docstring"""


              UpperCamelCase_							,			UpperCamelCase_ 							=	self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_lm_head_model(_SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE		)



@require_torch
class 				_UpperCamelCase       (						unittest.TestCase  ):

       @tooslow
       def lowercase			(		self:			List[Any]		)							->			List[Any]:




              """simple docstring"""


              UpperCamelCase_ 							=	"今天天气真好！"
              UpperCamelCase_ 							=	"openbmb/cpm-ant-10b"
              UpperCamelCase_ 							=	CpmAntModel.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	CpmAntTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	tokenizer(_SCREAMING_SNAKE_CASE       , return_tensors="pt"		)
              UpperCamelCase_ 							=	model(**_SCREAMING_SNAKE_CASE		).last_hidden_state

              UpperCamelCase_ 							=	torch.tensor(
                  [[[6.17_08, 5.92_44, 1.08_35], [6.52_07, 6.28_93, -11.33_24], [-1.01_07, -0.05_76, -5.95_77]]]       , )
              self.assertTrue(torch.allclose(hidden_states[:, :3, :3]       , _SCREAMING_SNAKE_CASE       , atol=1e-2		)		)



@require_torch
class 				_UpperCamelCase       (						unittest.TestCase  ):

       @tooslow
       def lowercase			(		self:			Optional[Any]		)							->			Union[str, Any]:




              """simple docstring"""


              UpperCamelCase_ 							=	"今天天气真好！"
              UpperCamelCase_ 							=	"openbmb/cpm-ant-10b"
              UpperCamelCase_ 							=	CpmAntForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	CpmAntTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	tokenizer(_SCREAMING_SNAKE_CASE       , return_tensors="pt"		)
              UpperCamelCase_ 							=	model(**_SCREAMING_SNAKE_CASE		).logits

              UpperCamelCase_ 							=	torch.tensor(
                  [[[-6.42_67, -6.40_83, -6.39_58], [-5.88_02, -5.94_47, -5.78_11], [-5.38_96, -5.48_20, -5.42_95]]]       , )
              self.assertTrue(torch.allclose(hidden_states[:, :3, :3]       , _SCREAMING_SNAKE_CASE       , atol=1e-2		)		)

       @tooslow
       def lowercase			(		self:			Dict		)							->			Optional[int]:




              """simple docstring"""


              UpperCamelCase_ 							=	"openbmb/cpm-ant-10b"
              UpperCamelCase_ 							=	CpmAntForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	CpmAntTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	"今天天气不错，"
              UpperCamelCase_ 							=	"今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的"
              UpperCamelCase_ 							=	tokenizer(_SCREAMING_SNAKE_CASE       , return_tensors="pt"		)
              UpperCamelCase_ 							=	model.generate(**_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	tokenizer.batch_decode(_SCREAMING_SNAKE_CASE		)
              self.assertEqual(_SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE		)



       @tooslow
       def lowercase			(		self:			List[str]		)							->			Optional[Any]:




              """simple docstring"""


              UpperCamelCase_ 							=	"openbmb/cpm-ant-10b"
              UpperCamelCase_ 							=	CpmAntForCausalLM.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	CpmAntTokenizer.from_pretrained(_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	["今天天气不错，", "新年快乐，万事如意！"]
              UpperCamelCase_ 							=	[
                  "今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的",
                  "新年快乐，万事如意！在这辞旧迎新的美好时刻，我谨代表《农村新技术》杂志社全体同仁，向一直以来关心、支持《农村新技术》杂志发展的各级领导、各界朋友和广大读者致以最诚挚的",
              ]
              UpperCamelCase_ 							=	tokenizer(_SCREAMING_SNAKE_CASE       , return_tensors="pt"       , padding=_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	model.generate(**_SCREAMING_SNAKE_CASE		)
              UpperCamelCase_ 							=	tokenizer.batch_decode(_SCREAMING_SNAKE_CASE		)
              self.assertEqual(_SCREAMING_SNAKE_CASE       , _SCREAMING_SNAKE_CASE		)

