

import unittest

import numpy as np

from transformers import (
    GPTSanJapaneseConfig,
    GPTSanJapaneseForConditionalGeneration,
    GPTSanJapaneseModel,
    GPTSanJapaneseTokenizer,
    is_torch_available,
)
from transformers.generation import GenerationConfig
from transformers.testing_utils import require_torch, slow, tooslow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin

class   __UpperCamelCase      :




	def __init__(						self		:  str						,		lowerCAmelCase		:  str						,		lowerCAmelCase		:  Optional[int]=36_000						,		lowerCAmelCase		:  str=13						,		lowerCAmelCase		:  List[str]=7						,		lowerCAmelCase		:  Tuple=True						,		lowerCAmelCase		:  List[str]=32						,		lowerCAmelCase		:  int=42						,		lowerCAmelCase		:  List[Any]=5						,		lowerCAmelCase		:  Union[str, Any]=2						,		lowerCAmelCase		:  List[str]=4						,		lowerCAmelCase		:  str=2						,		lowerCAmelCase		:  str=32						,		lowerCAmelCase		:  str=80						,		lowerCAmelCase		:  Tuple=33						,		lowerCAmelCase		:  Any=0.0						,		lowerCAmelCase		:  Optional[int]=1e-6						,		lowerCAmelCase		:  int=100						,		lowerCAmelCase		:  int=0.0						,		):


		'''simple docstring'''







		UpperCAmelCase_    			=     vocab_size
		UpperCAmelCase_    			=     parent
		UpperCAmelCase_    			=     batch_size
		UpperCAmelCase_    			=     num_contexts
		# For common tests
		UpperCAmelCase_    			=     self.num_contexts
		UpperCAmelCase_    			=     is_training
		UpperCAmelCase_    			=     hidden_size
		UpperCAmelCase_    			=     num_ext_layers
		UpperCAmelCase_    			=     ext_size
		UpperCAmelCase_    			=     num_hidden_layers
		UpperCAmelCase_    			=     num_attention_heads
		UpperCAmelCase_    			=     num_experts
		UpperCAmelCase_    			=     d_ff
		UpperCAmelCase_    			=     d_ext
		UpperCAmelCase_    			=     d_spout
		UpperCAmelCase_    			=     dropout_rate
		UpperCAmelCase_    			=     layer_norm_epsilon
		UpperCAmelCase_    			=     expert_capacity
		UpperCAmelCase_    			=     router_jitter_noise




	def  __A   (						self		:  Optional[Any]							):


		'''simple docstring'''







		return GPTSanJapaneseConfig.from_pretrained("Tanrei/GPTSAN-japanese"							)




	def  __A   (						self		:  Union[str, Any]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     ids_tensor([self.batch_size, self.seq_length]						,		self.vocab_size							)

		UpperCAmelCase_    			=     self.get_config()

		return (config, input_ids)




	def  __A   (						self		:  List[Any]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     ids_tensor([self.batch_size, self.seq_length]						,		self.vocab_size							)

		UpperCAmelCase_    			=     self.get_config()

		return (config, {"input_ids": input_ids})




	def  __A   (						self		:  str							):


		'''simple docstring'''







		return GPTSanJapaneseConfig(
		    vocab_size=self.vocab_size						,		num_contexts=self.seq_length						,		d_model=self.hidden_size						,		d_ff=self.d_ff						,		d_ext=self.d_ext						,		d_spout=self.d_spout						,		num_switch_layers=self.num_hidden_layers - self.num_ext_layers						,		num_ext_layers=self.num_ext_layers						,		num_heads=self.num_attention_heads						,		num_experts=self.num_experts						,		expert_capacity=self.expert_capacity						,		dropout_rate=self.dropout_rate						,		layer_norm_epsilon=self.layer_norm_epsilon						,		router_jitter_noise=self.router_jitter_noise						,		)




	def  __A   (						self		:  Union[str, Any]						,		lowerCAmelCase		:  List[Any]						,		lowerCAmelCase		:  List[Any]						,		):


		'''simple docstring'''







		UpperCAmelCase_    			=     GPTSanJapaneseForConditionalGeneration(config=lowerCAmelCase							)
		model.to(lowerCAmelCase							)
		model.eval()
		UpperCAmelCase_    			=     model(
		    input_ids=lowerCAmelCase						,		)
		self.parent.assertIsNotNone(lowerCAmelCase							)


@require_torch
class   __UpperCamelCase      (   lowerCamelCase_       ,       lowerCamelCase_       ,       unittest.TestCase  ):
	SCREAMING_SNAKE_CASE__      			=       (GPTSanJapaneseModel,) if is_torch_available() else ()
	SCREAMING_SNAKE_CASE__      			=       (
	    {
	        """conversational""": GPTSanJapaneseForConditionalGeneration,
	        """feature-extraction""": GPTSanJapaneseForConditionalGeneration,
	        """summarization""": GPTSanJapaneseForConditionalGeneration,
	        """text2text-generation""": GPTSanJapaneseForConditionalGeneration,
	        """translation""": GPTSanJapaneseForConditionalGeneration,
	    }
	    if is_torch_available()
	    else {}
	)
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	# The small GPTSAN_JAPANESE model needs higher percentages for CPU/MP tests
	SCREAMING_SNAKE_CASE__      			=       [0.8, 0.9]




	def  __A   (						self		:  Any						,		lowerCAmelCase		:  Union[str, Any]						,		lowerCAmelCase		:  Dict						,		lowerCAmelCase		:  List[str]						,		lowerCAmelCase		:  List[Any]						,		lowerCAmelCase		:  Union[str, Any]							):


		'''simple docstring'''







		if pipeline_test_casse_name == "SummarizationPipelineTests":
			# TODO: fix `_reorder_cache` is not implemented for this model
			return True
		elif pipeline_test_casse_name == "Text2TextGenerationPipelineTests":
			# TODO: check this.
			return True

		return False




	def  __A   (						self		:  str							):


		'''simple docstring'''







		UpperCAmelCase_    			=     GPTSanJapaneseTester(self							)
		UpperCAmelCase_    			=     ConfigTester(self						,		config_class=lowerCAmelCase						,		d_model=37							)




	def  __A   (						self		:  List[Any]							):


		'''simple docstring'''







		GPTSanJapaneseConfig()




	def  __A   (						self		:  Union[str, Any]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*lowerCAmelCase							)




	@unittest.skip(
	    reason="skip for now as the computed `max_memory` by `model_split_percents` in the test method will be changed inside `from_pretrained`"							)
	def  __A   (						self		:  Dict							):


		'''simple docstring'''







		super().test_model_parallelism()




	@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."							)
	def  __A   (						self		:  str							):


		'''simple docstring'''







		pass


@require_torch
class   __UpperCamelCase      (   lowerCamelCase_       ,       lowerCamelCase_       ,       unittest.TestCase  ):
	SCREAMING_SNAKE_CASE__      			=       (GPTSanJapaneseForConditionalGeneration,) if is_torch_available() else ()
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	SCREAMING_SNAKE_CASE__      			=       False
	# The small GPTSAN_JAPANESE model needs higher percentages for CPU/MP tests
	SCREAMING_SNAKE_CASE__      			=       [0.8, 0.9]




	def  __A   (						self		:  int							):


		'''simple docstring'''







		UpperCAmelCase_    			=     GPTSanJapaneseTester(self							)
		UpperCAmelCase_    			=     ConfigTester(self						,		config_class=lowerCAmelCase						,		d_model=37							)




	def  __A   (						self		:  List[Any]							):


		'''simple docstring'''







		GPTSanJapaneseConfig()




	def  __A   (						self		:  int							):


		'''simple docstring'''







		UpperCAmelCase_    			=     self.model_tester.prepare_config_and_inputs()
		self.model_tester.create_and_check_model(*lowerCAmelCase							)




	@unittest.skip(
	    reason="skip for now as the computed `max_memory` by `model_split_percents` in the test method will be changed inside `from_pretrained`"							)
	def  __A   (						self		:  str							):


		'''simple docstring'''







		super().test_model_parallelism()




	@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."							)
	def  __A   (						self		:  Dict							):


		'''simple docstring'''







		pass




	@slow
	def  __A   (						self		:  Optional[Any]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     GPTSanJapaneseForConditionalGeneration.from_pretrained("Tanrei/GPTSAN-japanese"							)
		UpperCAmelCase_    			=     GPTSanJapaneseTokenizer.from_pretrained("Tanrei/GPTSAN-japanese"							)
		UpperCAmelCase_    			=     tokenizer.encode("武田信玄は"						,		return_tensors="pt"							)
		UpperCAmelCase_    			=     model(lowerCAmelCase							)
		UpperCAmelCase_    			=     outputs.logits.detach().cpu().numpy()
		# Output of original model created with mesh-tensoflow
		UpperCAmelCase_    			=     [
		    # fmt: off
		    [-12.037_839_889_526_367, -12.433_061_599_731_445, -14.333_840_370_178_223, -12.450_345_993_041_992, -11.1_661_376_953_125,
		    -11.930_137_634_277_344, -10.659_740_447_998_047, -12.909_574_508_666_992, -13.241_043_090_820_312, -13.398_579_597_473_145,
		    -11.107_524_871_826_172, -12.3_685_941_696_167, -22.97_943_115_234_375, -10.481_067_657_470_703, -12.484_030_723_571_777,
		    -12.807_360_649_108_887, -14.769_700_050_354_004, -12.233_579_635_620_117, -13.428_145_408_630_371, -22.624_177_932_739_258],
		    [-7.511_149_883_270_264, -8.281_851_768_493_652, -7.943_127_155_303_955, -7.55_021_333_694_458, -6.49_869_966_506_958,
		    -7.586_796_283_721_924, -6.978_085_994_720_459, -7.839_145_183_563_232, -8.21_964_168_548_584, -8.695_091_247_558_594,
		    -6.706_910_610_198_975, -6.6_585_798_263_549_805, -19.565_698_623_657_227, -5.353_842_735_290_527, -8.350_686_073_303_223,
		    -8.039_388_656_616_211, -10.856_569_290_161_133, -7.75_154_447_555_542, -8.819_022_178_649_902, -19.51_532_745_361_328],
		    [-9.73_066_234_588_623, -10.223_922_729_492_188, -9.932_981_491_088_867, -11.857_836_723_327_637, -7.662_626_266_479_492,
		    -11.13_529_109_954_834, -7.765_097_618_103_027, -11.472_923_278_808_594, -9.543_149_948_120_117, -11.905_633_926_391_602,
		    -9.366_164_207_458_496, -11.5_734_281_539_917, -23.699_003_219_604_492, -9.429_590_225_219_727, -10.42_839_241_027_832,
		    -10.585_240_364_074_707, -10.94_771_957_397_461, -11.095_416_069_030_762, -10.390_240_669_250_488, -23.769_372_940_063_477],
		    [-9.728_265_762_329_102, -9.859_712_600_708_008, -10.09_729_290_008_545, -9.678_522_109_985_352, -6.879_519_939_422_607,
		    -9.68_487_548_828_125, -4.2_803_425_788_879_395, -10.018_914_222_717_285, -9.308_445_930_480_957, -10.63_394_546_508_789,
		    -8.083_646_774_291_992, -9.06_301_498_413_086, -21.904_266_357_421_875, -8.90_160_846_710_205, -8.841_876_029_968_262,
		    -11.856_719_970_703_125, -12.079_398_155_212_402, -11.233_753_204_345_703, -10.177_338_600_158_691, -21.87_256_622_314_453],
		    [-9.669_764_518_737_793, -9.614_198_684_692_383, -9.814_510_345_458_984, -9.996_501_922_607_422, -11.375_690_460_205_078,
		    -10.113_405_227_661_133, -10.546_867_370_605_469, -10.04_369_068_145_752, -10.907_809_257_507_324, -10.504_216_194_152_832,
		    -11.129_199_028_015_137, -10.151_124_000_549_316, -21.96_586_799_621_582, -9.086_349_487_304_688, -11.730_339_050_292_969,
		    -10.460_667_610_168_457, -10.298_049_926_757_812, -10.784_148_216_247_559, -10.840_693_473_815_918, -22.03_152_847_290_039],
		    # fmt: on
		]
		UpperCAmelCase_    			=     np.array(lowerCAmelCase							).flatten()
		UpperCAmelCase_    			=     output_logits[0, :, :20].flatten()

		def check(lowerCAmelCase		:  int						,		lowerCAmelCase		:  Union[str, Any]						,		lowerCAmelCase		:  Any=5e-4							):
			return abs(a - b							) < epsilon * max(abs(lowerCAmelCase							)						,		abs(lowerCAmelCase							)							)

		self.assertTrue(np.all([check(target[i]						,		predict[i]							) for i in range(len(lowerCAmelCase							)							)]							)							)




	@slow
	def  __A   (						self		:  List[Any]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     GPTSanJapaneseForConditionalGeneration.from_pretrained("Tanrei/GPTSAN-japanese"							)
		UpperCAmelCase_    			=     GPTSanJapaneseTokenizer.from_pretrained("Tanrei/GPTSAN-japanese"							)
		model.to(lowerCAmelCase							)

		# set deterministically
		UpperCAmelCase_    			=     GenerationConfig.from_pretrained("Tanrei/GPTSAN-japanese"							)
		UpperCAmelCase_    			=     1

		# use different length sentences to test batching
		UpperCAmelCase_    			=     [
		    "甲斐なら武田と言うほど",
		    "織田信長は、",
		]

		UpperCAmelCase_    			=     "left"
		UpperCAmelCase_    			=     tokenizer(lowerCAmelCase						,		return_tensors="pt"						,		padding=lowerCAmelCase							)
		UpperCAmelCase_    			=     inputs["input_ids"].to(lowerCAmelCase							)

		self.assertNotEqual(inputs["attention_mask"][0].numpy().tolist()						,		inputs["attention_mask"][1].numpy().tolist()							)

		UpperCAmelCase_    			=     model.generate(
		    input_ids=lowerCAmelCase						,		attention_mask=inputs["attention_mask"].to(lowerCAmelCase							)						,		max_new_tokens=3						,		generation_config=lowerCAmelCase						,		)

		UpperCAmelCase_    			=     tokenizer(sentences[0]						,		return_tensors="pt"							).input_ids.to(lowerCAmelCase							)
		UpperCAmelCase_    			=     model.generate(
		    input_ids=lowerCAmelCase						,		max_new_tokens=3						,		generation_config=lowerCAmelCase							)

		UpperCAmelCase_    			=     tokenizer(sentences[1]						,		return_tensors="pt"							).input_ids.to(lowerCAmelCase							)
		UpperCAmelCase_    			=     model.generate(input_ids=lowerCAmelCase						,		max_new_tokens=3						,		generation_config=lowerCAmelCase							)

		self.assertNotEqual(inputs_non_padded.shape						,		inputs_padded.shape							)

		UpperCAmelCase_    			=     tokenizer.batch_decode(lowerCAmelCase						,		skip_special_tokens=lowerCAmelCase							)
		UpperCAmelCase_    			=     tokenizer.decode(output_non_padded[0]						,		skip_special_tokens=lowerCAmelCase							)
		UpperCAmelCase_    			=     tokenizer.decode(output_padded[0]						,		skip_special_tokens=lowerCAmelCase							)

		UpperCAmelCase_    			=     [
		    "甲斐なら武田と言うほど甲斐の武田",
		    "織田信長は、このような",
		]
		self.assertListEqual(lowerCAmelCase						,		lowerCAmelCase							)
		self.assertListEqual(lowerCAmelCase						,		[non_padded_sentence, padded_sentence]							)




	@tooslow
	def  __A   (						self		:  Dict							):


		'''simple docstring'''







		UpperCAmelCase_    			=     GPTSanJapaneseForConditionalGeneration.from_pretrained("Tanrei/GPTSAN-japanese"							)
		UpperCAmelCase_    			=     GPTSanJapaneseTokenizer.from_pretrained("Tanrei/GPTSAN-japanese"							)
		# Output of original model created with mesh-tensoflow
		UpperCAmelCase_    			=     [
		    ("武田信玄は", 35_675),
		    ("武田信玄は、", 45),
		    ("武田信玄は、この", 29),
		    ("武田信玄は、このよう", 30_642),
		    ("武田信玄は、このような", 35_680),
		    ("武田信玄は、このような「", 8_640),
		    ("武田信玄は、このような「武田", 31_617),
		    ("武田信玄は、このような「武田家", 30_646),
		    ("武田信玄は、このような「武田家の", 31_617),
		    ("武田信玄は、このような「武田家の家", 31_381),
		]
		for input, output in target:
			UpperCAmelCase_    			=     tokenizer.encode(lowerCAmelCase						,		return_tensors="pt"							)
			UpperCAmelCase_    			=     model(lowerCAmelCase							)
			UpperCAmelCase_    			=     outputs.logits.detach().cpu().numpy()[0]
			UpperCAmelCase_    			=     np.argmax(output_logits[-1]							)
			self.assertEqual(lowerCAmelCase						,		lowerCAmelCase							)




	@slow
	def  __A   (						self		:  Union[str, Any]							):


		'''simple docstring'''







		UpperCAmelCase_    			=     GPTSanJapaneseForConditionalGeneration.from_pretrained("Tanrei/GPTSAN-japanese"							)
		UpperCAmelCase_    			=     GPTSanJapaneseTokenizer.from_pretrained("Tanrei/GPTSAN-japanese"							)
		model.to(lowerCAmelCase							)

		# set deterministically
		UpperCAmelCase_    			=     GenerationConfig.from_pretrained("Tanrei/GPTSAN-japanese"							)
		UpperCAmelCase_    			=     1

		UpperCAmelCase_    			=     "武田信玄は、"
		UpperCAmelCase_    			=     tokenizer(lowerCAmelCase						,		return_tensors="pt"							).input_ids.to(lowerCAmelCase							)
		UpperCAmelCase_    			=     tokenizer([input_text, input_text]						,		return_tensors="pt"							).input_ids.to(lowerCAmelCase							)

		# spout from uniform and one-hot
		UpperCAmelCase_    			=     [
		    # fmt: off
		    [0.87_882_208, 0.38_426_396, 0.33_220_248, 0.43_890_406, 0.16_562_252,
		    0.04_803_985, 0.211_572  , 0.23_188_473, 0.37_153_068, 0.7_836_377 ,
		    0.02_160_172, 0.38_761_719, 0.75_290_772, 0.90_198_857, 0.34_365_777,
		    0.64_168_169, 0.44_318_471, 0.14_575_746, 0.92_562_881, 0.40_812_148,
		    0.29_019_122, 0.88_861_599, 0.65_524_846, 0.43_563_456, 0.38_177_187,
		    0.70_832_965, 0.81_527_892, 0.68_832_812, 0.38_833_192, 0.4_561_522 ,
		    0.14_828_817, 0.47_248_213, 0.54_357_335, 0.82_009_566, 0.1_338_884 ,
		    0.02_755_417, 0.19_764_677, 0.2_422_084 , 0.04_757_674, 0.65_409_606,
		    0.0_824_589 , 0.03_304_383, 0.94_387_689, 0.98_764_509, 0.82_433_901,
		    0.27_646_741, 0.64_907_493, 0.76_009_406, 0.30_087_915, 0.17_904_689,
		    0.41_601_714, 0.67_046_398, 0.10_422_822, 0.08_447_374, 0.07_354_344,
		    0.61_423_565, 0.70_284_866, 0.7_532_333 , 0.1_972_038 , 0.29_575_659,
		    0.90_583_886, 0.29_265_307, 0.50_000_175, 0.70_407_655, 0.889_363  ,
		    0.81_904_418, 0.66_829_128, 0.64_468_815, 0.56_563_723, 0.85_601_875,
		    0.94_924_672, 0.00_166_762, 0.25_220_643, 0.74_540_219, 0.67_993_247,
		    0.1_549_675 , 0.39_385_352, 0.92_153_607, 0.63_745_931, 0.27_759_043,
		    0.84_702_295, 0.65_904_271, 0.58_676_614, 0.8_666_936 , 0.39_607_438,
		    0.79_954_983, 0.42_220_697, 0.39_650_381, 0.7_849_864 , 0.56_150_201,
		    0.15_678_925, 0.14_746_032, 0.34_542_114, 0.47_026_783, 0.11_956_489,
		    0.25_421_435, 0.33_788_901, 0.68_934_842, 0.36_424_685, 0.71_737_898,
		    0.38_983_449, 0.94_393_779, 0.39_575_588, 0.36_616_553, 0.87_104_665,
		    0.64_630_203, 0.22_516_905, 0.88_270_804, 0.15_031_338, 0.75_144_345,
		    0.46_459_025, 0.85_396_454, 0.86_355_643, 0.65_139_851, 0.70_266_061,
		    0.30_241_389, 0.81_056_497, 0.88_865_969, 0.38_773_807, 0.70_635_849,
		    0.90_718_459, 0.43_245_789, 0.28_000_654, 0.45_935_562, 0.08_773_519,
		    0.9_552_151 , 0.93_901_511, 0.22_489_288], # uniform
		    [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., 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.],
		    # fmt: on
		]

		UpperCAmelCase_    			=     model.generate(
		    input_ids=lowerCAmelCase						,		spout=spouts[0]						,		max_new_tokens=20						,		generation_config=lowerCAmelCase						,		)

		UpperCAmelCase_    			=     model.generate(
		    input_ids=lowerCAmelCase						,		spout=spouts[1]						,		max_new_tokens=20						,		generation_config=lowerCAmelCase						,		)

		UpperCAmelCase_    			=     model.generate(
		    input_ids=lowerCAmelCase						,		spout=lowerCAmelCase						,		max_new_tokens=20						,		generation_config=lowerCAmelCase						,		)

		UpperCAmelCase_    			=     tokenizer.decode(outputa[0]							)
		UpperCAmelCase_    			=     tokenizer.decode(outputa[0]							)
		UpperCAmelCase_    			=     tokenizer.batch_decode(lowerCAmelCase							)

		UpperCAmelCase_    			=     [
		    "武田信玄は、武田氏の滅亡後、武田氏の居城であった甲斐武田氏の居城である",
		    "武田信玄は、武田家の滅亡を防ぐため、武田家の家臣である武田信虎を討",
		]
		self.assertListEqual(lowerCAmelCase						,		lowerCAmelCase							)
		self.assertListEqual(lowerCAmelCase						,		[outa_sentence, outa_sentence]							)




	@slow
	def  __A   (						self		:  str							):


		'''simple docstring'''







		UpperCAmelCase_    			=     GPTSanJapaneseForConditionalGeneration.from_pretrained("Tanrei/GPTSAN-japanese"							)
		UpperCAmelCase_    			=     GPTSanJapaneseTokenizer.from_pretrained("Tanrei/GPTSAN-japanese"							)
		model.to(lowerCAmelCase							)

		# set deterministically
		UpperCAmelCase_    			=     GenerationConfig.from_pretrained("Tanrei/GPTSAN-japanese"							)
		UpperCAmelCase_    			=     1

		UpperCAmelCase_    			=     "武田信玄"
		UpperCAmelCase_    			=     "織田信長"
		UpperCAmelCase_    			=     "は、"
		UpperCAmelCase_    			=     "が、"
		UpperCAmelCase_    			=     tokenizer(lowerCAmelCase						,		prefix_text=lowerCAmelCase						,		return_tensors="pt"							)
		UpperCAmelCase_    			=     tokenizer(lowerCAmelCase						,		prefix_text=lowerCAmelCase						,		return_tensors="pt"							)
		UpperCAmelCase_    			=     tokenizer([[prefix_text_a, input_text_a], [prefix_text_a, input_text_a]]						,		return_tensors="pt"							)

		UpperCAmelCase_    			=     model.generate(
		    input_ids=input_tok_a.input_ids.to(lowerCAmelCase							)						,		token_type_ids=input_tok_a.token_type_ids.to(lowerCAmelCase							)						,		max_new_tokens=20						,		generation_config=lowerCAmelCase						,		)

		UpperCAmelCase_    			=     model.generate(
		    input_ids=input_tok_a.input_ids.to(lowerCAmelCase							)						,		token_type_ids=input_tok_a.token_type_ids.to(lowerCAmelCase							)						,		max_new_tokens=20						,		generation_config=lowerCAmelCase						,		)

		UpperCAmelCase_    			=     model.generate(
		    input_ids=input_tok_a.input_ids.to(lowerCAmelCase							)						,		token_type_ids=input_tok_a.token_type_ids.to(lowerCAmelCase							)						,		attention_mask=input_tok_a.attention_mask.to(lowerCAmelCase							)						,		max_new_tokens=20						,		generation_config=lowerCAmelCase						,		)

		UpperCAmelCase_    			=     tokenizer.decode(outputa[0]							)
		UpperCAmelCase_    			=     tokenizer.decode(outputa[0]							)
		UpperCAmelCase_    			=     tokenizer.batch_decode(lowerCAmelCase							)

		UpperCAmelCase_    			=     [
		    "武田信玄は、武田氏の祖である武田信虎を、その子・武田信友を擁して",
		    "織田信長が、織田信長の妻・お市の方を妻として迎えたという逸話が残",
		]
		self.assertListEqual(lowerCAmelCase						,		lowerCAmelCase							)
		self.assertListEqual(lowerCAmelCase						,		[outa_sentence, outa_sentence]							)






import importlib
import importlib.metadata
import os
import warnings
from distutils.util import strtobool
from functools import lru_cache

import torch
from packaging import version
from packaging.version import parse

from .environment import parse_flag_from_env
from .versions import compare_versions, is_torch_version


try:
				import torch_xla.core.xla_model as xm  # noqa: F401

				_a:      List[Any]								=     True
except ImportError:
				_a:      int								=     False


# Cache this result has it's a C FFI call which can be pretty time-consuming
_a:      str								=     torch.distributed.is_available()



def  __lowerCAmelCase (  A      ):
	# Check we're not importing a "pkg_name" directory somewhere but the actual library by trying to grab the version
	UpperCAmelCase_    			=     importlib.util.find_spec(A      ) is not None
	if package_exists:
		try:
			UpperCAmelCase_    			=     importlib.metadata.metadata(A      )
			return True
		except importlib.metadata.PackageNotFoundError:
			return False



def  __lowerCAmelCase (  ):
	return _torch_distributed_available



def  __lowerCAmelCase (  ):
	try:
		pass
	except ImportError:
		print(
		    "Intel(R) oneCCL Bindings for PyTorch* is required to run DDP on Intel(R) GPUs, but it is not"
		    " detected. If you see \"ValueError: Invalid backend: 'ccl'\" error, please install Intel(R) oneCCL"
		    " Bindings for PyTorch*."      )
	return (
	    importlib.util.find_spec("torch_ccl"      ) is not None
	    or importlib.util.find_spec("oneccl_bindings_for_pytorch"      ) is not None
	)



def  __lowerCAmelCase (  ):
	return importlib.metadata.version("oneccl_bind_pt"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("transformer_engine"      )



@lru_cache
def  __lowerCAmelCase (  A=True      ):
	# Due to bugs on the amp series GPUs, we disable torch-xla on them
	if torch.cuda.is_available():
		return False
	if _tpu_available and check_device:
		try:
			# Will raise a RuntimeError if no XLA configuration is found
			UpperCAmelCase_    			=     xm.xla_device()
			return True
		except RuntimeError:
			return False
	return _tpu_available



def  __lowerCAmelCase (  ):
	return _is_package_available("deepspeed"      )



def  __lowerCAmelCase (  A=False      ):
	if is_tpu_available():
		return not ignore_tpu
	if torch.cuda.is_available():
		return torch.cuda.is_bfaa_supported()
	if is_npu_available():
		return False
	return True



def  __lowerCAmelCase (  ):
	UpperCAmelCase_    			=     _is_package_available("bitsandbytes"      )
	if package_exists:
		UpperCAmelCase_    			=     version.parse(importlib.metadata.version("bitsandbytes"      )      )
		return compare_versions(A    ,       ">="    ,       "0.39.0"      )
	return False



def  __lowerCAmelCase (  ):
	UpperCAmelCase_    			=     _is_package_available("bitsandbytes"      )
	if package_exists:
		UpperCAmelCase_    			=     version.parse(importlib.metadata.version("bitsandbytes"      )      )
		return compare_versions(A    ,       ">="    ,       "0.37.2"      )
	return False



def  __lowerCAmelCase (  ):
	return _is_package_available("bitsandbytes"      )



def  __lowerCAmelCase (  ):
	if strtobool(os.environ.get("ACCELERATE_USE_MEGATRON_LM"    ,       "False"      )      ) == 1:
		UpperCAmelCase_    			=     importlib.util.find_spec("megatron"      ) is not None
		if package_exists:
			try:
				UpperCAmelCase_    			=     parse(importlib.metadata.version("megatron-lm"      )      )
				return compare_versions(A    ,       ">="    ,       "2.2.0"      )
			except Exception as e:
				warnings.warn(F"Parse Megatron version failed. Exception:{e}"      )
				return False



def  __lowerCAmelCase (  ):
	return _is_package_available("safetensors"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("transformers"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("datasets"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("aim"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("tensorboard"      ) or _is_package_available("tensorboardX"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("wandb"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("comet_ml"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("boto3"      )



def  __lowerCAmelCase (  ):
	if _is_package_available("rich"      ):
		if "ACCELERATE_DISABLE_RICH" in os.environ:
			warnings.warn(
			    "`ACCELERATE_DISABLE_RICH` is deprecated and will be removed in v0.22.0 and deactivated by default. Please use `ACCELERATE_ENABLE_RICH` if you wish to use `rich`."      )
			return not parse_flag_from_env("ACCELERATE_DISABLE_RICH"    ,       A      )
		return parse_flag_from_env("ACCELERATE_ENABLE_RICH"    ,       A      )
	return False



def  __lowerCAmelCase (  ):
	return _is_package_available("sagemaker"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("tqdm"      )



def  __lowerCAmelCase (  ):
	return _is_package_available("mlflow"      )



def  __lowerCAmelCase (  ):
	return is_torch_version(">="    ,       "1.12"      ) and torch.backends.mps.is_available() and torch.backends.mps.is_built()



def  __lowerCAmelCase (  ):
	def get_major_and_minor_from_version(A      ):
		return str(version.parse(A      ).major      ) + "." + str(version.parse(A      ).minor      )

	UpperCAmelCase_    			=     importlib.metadata.version("torch"      )
	if importlib.util.find_spec("intel_extension_for_pytorch"      ) is None:
		return False
	UpperCAmelCase_    			=     "N/A"
	try:
		UpperCAmelCase_    			=     importlib.metadata.version("intel_extension_for_pytorch"      )
	except importlib.metadata.PackageNotFoundError:
		return False
	UpperCAmelCase_    			=     get_major_and_minor_from_version(_torch_version      )
	UpperCAmelCase_    			=     get_major_and_minor_from_version(_ipex_version      )
	if torch_major_and_minor != ipex_major_and_minor:
		warnings.warn(
		    F"Intel Extension for PyTorch {ipex_major_and_minor} needs to work with PyTorch {ipex_major_and_minor}.*,"
		    F" but PyTorch {_torch_version} is found. Please switch to the matching version and run again."      )
		return False
	return True



@lru_cache
def  __lowerCAmelCase (  A=False      ):
	if importlib.util.find_spec("torch"      ) is None or importlib.util.find_spec("torch_npu"      ) is None:
		return False

	import torch
	import torch_npu  # noqa: F401

	if check_device:
		try:
			# Will raise a RuntimeError if no NPU is found
			UpperCAmelCase_    			=     torch.npu.device_count()
			return torch.npu.is_available()
		except RuntimeError:
			return False
	return hasattr(A    ,       "npu"      ) and torch.npu.is_available()




@lru_cache
def  __lowerCAmelCase (  A=False      ):
	if not parse_flag_from_env("ACCELERATE_USE_XPU"    ,       default=A      ):
		return False
	if is_ipex_available():
		import torch

		if is_torch_version("<="    ,       "1.12"      ):
			return False
	else:
		return False

	import intel_extension_for_pytorch  # noqa: F401

	if check_device:
		try:
			# Will raise a RuntimeError if no XPU  is found
			UpperCAmelCase_    			=     torch.xpu.device_count()
			return torch.xpu.is_available()
		except RuntimeError:
			return False
	return hasattr(A    ,       "xpu"      ) and torch.xpu.is_available()