





"""simple docstring"""




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  :



      '''simple docstring'''

      def __init__(					self ,				snake_case_ ,				snake_case_=3_6_0_0_0 ,				snake_case_=1_3 ,				snake_case_=7 ,				snake_case_=True ,				snake_case_=3_2 ,				snake_case_=4_2 ,				snake_case_=5 ,				snake_case_=2 ,				snake_case_=4 ,				snake_case_=2 ,				snake_case_=3_2 ,				snake_case_=8_0 ,				snake_case_=3_3 ,				snake_case_=0.0 ,				snake_case_=1E-6 ,				snake_case_=1_0_0 ,				snake_case_=0.0 ,				):

        """simple docstring"""

        A_  :	int    						=  vocab_size
        A_  :	str    						=  parent
        A_  :	int    						=  batch_size
        A_  :	Union[str, Any]    						=  num_contexts
        # For common tests
        A_  :	Tuple    						=  self.num_contexts
        A_  :	Optional[Any]    						=  is_training
        A_  :	Tuple    						=  hidden_size
        A_  :	Dict    						=  num_ext_layers
        A_  :	List[str]    						=  ext_size
        A_  :	List[str]    						=  num_hidden_layers
        A_  :	Optional[Any]    						=  num_attention_heads
        A_  :	List[str]    						=  num_experts
        A_  :	Any    						=  d_ff
        A_  :	Dict    						=  d_ext
        A_  :	Tuple    						=  d_spout
        A_  :	Optional[Any]    						=  dropout_rate
        A_  :	Tuple    						=  layer_norm_epsilon
        A_  :	List[Any]    						=  expert_capacity
        A_  :	int    						=  router_jitter_noise

      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

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

      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	Tuple    						=  ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size  )

        A_  :	str    						=  self.get_config()

        return (config, input_ids)

      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	int    						=  ids_tensor([self.batch_size, self.seq_length] ,				self.vocab_size  )

        A_  :	int    						=  self.get_config()

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

      def  lowerCamelCase_      (					self  ):

        """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  lowerCamelCase_      (					self ,				snake_case_ ,				snake_case_ ,				):

        """simple docstring"""

        A_  :	Union[str, Any]    						=  GPTSanJapaneseForConditionalGeneration(config=snake_case_  )
        model.to(snake_case_  )
        model.eval()
        A_  :	Optional[Any]    						=  model(
            input_ids=snake_case_ ,				)
        self.parent.assertIsNotNone(snake_case_  )


@require_torch
class 			_UpperCAmelCase  (       UpperCAmelCase__      ,       UpperCAmelCase__      ,       unittest.TestCase		):



      '''simple docstring'''
      lowercase_				:			Optional[Any]        =       (GPTSanJapaneseModel,) if is_torch_available() else ()
      lowercase_				:			Tuple        =       (
          {
              """conversational""": GPTSanJapaneseForConditionalGeneration,
              """feature-extraction""": GPTSanJapaneseForConditionalGeneration,
              """summarization""": GPTSanJapaneseForConditionalGeneration,
              """text2text-generation""": GPTSanJapaneseForConditionalGeneration,
              """translation""": GPTSanJapaneseForConditionalGeneration,
          }
          if is_torch_available()
          else {}
      )
      lowercase_				:			Optional[Any]        =       False
      lowercase_				:			Optional[int]        =       False
      lowercase_				:			str        =       False
      lowercase_				:			Any        =       False
      lowercase_				:			int        =       False
      lowercase_				:			int        =       False
      lowercase_				:			Optional[Any]        =       False
      lowercase_				:			List[Any]        =       False
      # The small GPTSAN_JAPANESE model needs higher percentages for CPU/MP tests
      lowercase_				:			List[str]        =       [0.8, 0.9]

      def  lowerCamelCase_      (					self ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_  ):

        """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  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	Union[str, Any]    						=  GPTSanJapaneseTester(self  )
        A_  :	int    						=  ConfigTester(self ,				config_class=snake_case_ ,				d_model=3_7  )

      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        GPTSanJapaneseConfig()

      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	List[Any]    						=  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*snake_case_  )

      @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  lowerCamelCase_      (					self  ):

        """simple docstring"""

        super().test_model_parallelism()

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

        """simple docstring"""

        pass


@require_torch
class 			_UpperCAmelCase  (       UpperCAmelCase__      ,       UpperCAmelCase__      ,       unittest.TestCase		):



      '''simple docstring'''
      lowercase_				:			str        =       (GPTSanJapaneseForConditionalGeneration,) if is_torch_available() else ()
      lowercase_				:			List[str]        =       False
      lowercase_				:			Dict        =       False
      lowercase_				:			Optional[int]        =       False
      lowercase_				:			Dict        =       False
      lowercase_				:			List[Any]        =       False
      lowercase_				:			List[str]        =       False
      # The small GPTSAN_JAPANESE model needs higher percentages for CPU/MP tests
      lowercase_				:			List[Any]        =       [0.8, 0.9]

      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	Optional[int]    						=  GPTSanJapaneseTester(self  )
        A_  :	List[str]    						=  ConfigTester(self ,				config_class=snake_case_ ,				d_model=3_7  )

      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        GPTSanJapaneseConfig()

      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	str    						=  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*snake_case_  )

      @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  lowerCamelCase_      (					self  ):

        """simple docstring"""

        super().test_model_parallelism()

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

        """simple docstring"""

        pass

      @slow
      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	int    						=  GPTSanJapaneseForConditionalGeneration.from_pretrained('Tanrei/GPTSAN-japanese'  )
        A_  :	Any    						=  GPTSanJapaneseTokenizer.from_pretrained('Tanrei/GPTSAN-japanese'  )
        A_  :	Any    						=  tokenizer.encode('武田信玄は' ,				return_tensors='pt'  )
        A_  :	Tuple    						=  model(snake_case_  )
        A_  :	Any    						=  outputs.logits.detach().cpu().numpy()
        # Output of original model created with mesh-tensoflow
        A_  :	Union[str, Any]    						=  [
            # fmt: off
            [-12.0_37_83_98_89_52_63_67, -12.4_33_06_15_99_73_14_45, -14.3_33_84_03_70_17_82_23, -12.4_50_34_59_93_04_19_92, -11.1_66_13_76_95_31_25,
            -11.9_30_13_76_34_27_73_44, -10.6_59_74_04_47_99_80_47, -12.9_09_57_45_08_66_69_92, -13.2_41_04_30_90_82_03_12, -13.3_98_57_95_97_47_31_45,
            -11.1_07_52_48_71_82_61_72, -12.3_68_59_41_69_61_67, -22.97_94_31_15_23_43_75, -10.4_81_06_76_57_47_07_03, -12.4_84_03_07_23_57_17_77,
            -12.8_07_36_06_49_10_88_87, -14.7_69_70_00_50_35_40_04, -12.2_33_57_96_35_62_01_17, -13.4_28_14_54_08_63_03_71, -22.6_24_17_79_32_73_92_58],
            [-7.5_11_14_98_83_27_02_64, -8.2_81_85_17_68_49_36_52, -7.9_43_12_71_55_30_39_55, -7.55_02_13_33_69_44_58, -6.49_86_99_66_50_69_58,
            -7.5_86_79_62_83_72_19_24, -6.9_78_08_59_94_72_04_59, -7.8_39_14_51_83_56_32_32, -8.21_96_41_68_54_85_84, -8.6_95_09_12_47_55_85_94,
            -6.7_06_91_06_10_19_89_75, -6.65_85_79_82_63_54_98_05, -19.5_65_69_86_23_65_72_27, -5.3_53_84_27_35_29_05_27, -8.3_50_68_60_73_30_32_23,
            -8.0_39_38_86_56_61_62_11, -10.8_56_56_92_90_16_11_33, -7.75_15_44_47_55_55_42, -8.8_19_02_21_78_64_99_02, -19.51_53_27_45_36_13_28],
            [-9.73_06_62_34_58_86_23, -10.2_23_92_27_29_49_21_88, -9.9_32_98_14_91_08_88_67, -11.8_57_83_67_23_32_76_37, -7.6_62_62_62_66_47_94_92,
            -11.13_52_91_09_95_48_34, -7.7_65_09_76_18_10_30_27, -11.4_72_92_32_78_80_85_94, -9.5_43_14_99_48_12_01_17, -11.9_05_63_39_26_39_16_02,
            -9.3_66_16_42_07_45_84_96, -11.5_73_42_81_53_99_17, -23.6_99_00_32_19_60_44_92, -9.4_29_59_02_25_21_97_27, -10.42_83_92_41_02_78_32,
            -10.5_85_24_03_64_07_47_07, -10.94_77_19_57_39_74_61, -11.0_95_41_60_69_03_07_62, -10.3_90_24_06_69_25_04_88, -23.7_69_37_29_40_06_34_77],
            [-9.7_28_26_57_62_32_91_02, -9.8_59_71_26_00_70_80_08, -10.09_72_92_90_00_85_45, -9.6_78_52_21_09_98_53_52, -6.8_79_51_99_39_42_26_07,
            -9.68_48_75_48_82_81_25, -4.28_03_42_57_88_87_93_95, -10.0_18_91_42_22_71_72_85, -9.3_08_44_59_30_48_09_57, -10.63_39_45_46_50_87_89,
            -8.0_83_64_67_74_29_19_92, -9.06_30_14_98_41_30_86, -21.9_04_26_63_57_42_18_75, -8.90_16_08_46_71_02_05, -8.8_41_87_60_29_96_82_62,
            -11.8_56_71_99_70_70_31_25, -12.0_79_39_81_55_21_24_02, -11.2_33_75_32_04_34_57_03, -10.1_77_33_86_00_15_86_91, -21.87_25_66_22_31_44_53],
            [-9.6_69_76_45_18_73_77_93, -9.6_14_19_86_84_69_23_83, -9.8_14_51_03_45_45_89_84, -9.9_96_50_19_22_60_74_22, -11.3_75_69_04_60_20_50_78,
            -10.1_13_40_52_27_66_11_33, -10.5_46_86_73_70_60_54_69, -10.04_36_90_68_14_57_52, -10.9_07_80_92_57_50_73_24, -10.5_04_21_61_94_15_28_32,
            -11.1_29_19_90_28_01_51_37, -10.1_51_12_40_00_54_93_16, -21.96_58_67_99_62_15_82, -9.0_86_34_94_87_30_46_88, -11.7_30_33_90_50_29_29_69,
            -10.4_60_66_76_10_16_84_57, -10.2_98_04_99_26_75_78_12, -10.7_84_14_82_16_24_75_59, -10.8_40_69_34_73_81_59_18, -22.03_15_28_47_29_00_39],
            # fmt: on
        ]
        A_  :	str    						=  np.array(snake_case_  ).flatten()
        A_  :	Optional[int]    						=  output_logits[0, :, :2_0].flatten()

        def check(snake_case_ ,				snake_case_ ,				snake_case_=5E-4  ):
          return abs(a - b  ) < epsilon * max(abs(snake_case_  ) ,				abs(snake_case_  )  )

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

      @slow
      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	Dict    						=  GPTSanJapaneseForConditionalGeneration.from_pretrained('Tanrei/GPTSAN-japanese'  )
        A_  :	List[str]    						=  GPTSanJapaneseTokenizer.from_pretrained('Tanrei/GPTSAN-japanese'  )
        model.to(snake_case_  )

        # set deterministically
        A_  :	int    						=  GenerationConfig.from_pretrained('Tanrei/GPTSAN-japanese'  )
        A_  :	Optional[int]    						=  1

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

        A_  :	Optional[Any]    						=  'left'
        A_  :	Tuple    						=  tokenizer(snake_case_ ,				return_tensors='pt' ,				padding=snake_case_  )
        A_  :	Optional[int]    						=  inputs['input_ids'].to(snake_case_  )

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

        A_  :	int    						=  model.generate(
            input_ids=snake_case_ ,				attention_mask=inputs['attention_mask'].to(snake_case_  ) ,				max_new_tokens=3 ,				generation_config=snake_case_ ,				)

        A_  :	Any    						=  tokenizer(sentences[0] ,				return_tensors='pt'  ).input_ids.to(snake_case_  )
        A_  :	Optional[Any]    						=  model.generate(
            input_ids=snake_case_ ,				max_new_tokens=3 ,				generation_config=snake_case_  )

        A_  :	List[Any]    						=  tokenizer(sentences[1] ,				return_tensors='pt'  ).input_ids.to(snake_case_  )
        A_  :	Tuple    						=  model.generate(input_ids=snake_case_ ,				max_new_tokens=3 ,				generation_config=snake_case_  )

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

        A_  :	Optional[int]    						=  tokenizer.batch_decode(snake_case_ ,				skip_special_tokens=snake_case_  )
        A_  :	Tuple    						=  tokenizer.decode(output_non_padded[0] ,				skip_special_tokens=snake_case_  )
        A_  :	Dict    						=  tokenizer.decode(output_padded[0] ,				skip_special_tokens=snake_case_  )

        A_  :	str    						=  [
            '甲斐なら武田と言うほど甲斐の武田',
            '織田信長は、このような',
        ]
        self.assertListEqual(snake_case_ ,				snake_case_  )
        self.assertListEqual(snake_case_ ,				[non_padded_sentence, padded_sentence]  )

      @tooslow
      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	List[str]    						=  GPTSanJapaneseForConditionalGeneration.from_pretrained('Tanrei/GPTSAN-japanese'  )
        A_  :	Any    						=  GPTSanJapaneseTokenizer.from_pretrained('Tanrei/GPTSAN-japanese'  )
        # Output of original model created with mesh-tensoflow
        A_  :	Optional[int]    						=  [
            ('武田信玄は', 3_5_6_7_5),
            ('武田信玄は、', 4_5),
            ('武田信玄は、この', 2_9),
            ('武田信玄は、このよう', 3_0_6_4_2),
            ('武田信玄は、このような', 3_5_6_8_0),
            ('武田信玄は、このような「', 8_6_4_0),
            ('武田信玄は、このような「武田', 3_1_6_1_7),
            ('武田信玄は、このような「武田家', 3_0_6_4_6),
            ('武田信玄は、このような「武田家の', 3_1_6_1_7),
            ('武田信玄は、このような「武田家の家', 3_1_3_8_1),
        ]
        for input, output in target:
          A_  :	Tuple    						=  tokenizer.encode(snake_case_ ,				return_tensors='pt'  )
          A_  :	Dict    						=  model(snake_case_  )
          A_  :	Any    						=  outputs.logits.detach().cpu().numpy()[0]
          A_  :	Tuple    						=  np.argmax(output_logits[-1]  )
          self.assertEqual(snake_case_ ,				snake_case_  )

      @slow
      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	str    						=  GPTSanJapaneseForConditionalGeneration.from_pretrained('Tanrei/GPTSAN-japanese'  )
        A_  :	List[Any]    						=  GPTSanJapaneseTokenizer.from_pretrained('Tanrei/GPTSAN-japanese'  )
        model.to(snake_case_  )

        # set deterministically
        A_  :	Tuple    						=  GenerationConfig.from_pretrained('Tanrei/GPTSAN-japanese'  )
        A_  :	Union[str, Any]    						=  1

        A_  :	List[str]    						=  '武田信玄は、'
        A_  :	Union[str, Any]    						=  tokenizer(snake_case_ ,				return_tensors='pt'  ).input_ids.to(snake_case_  )
        A_  :	List[Any]    						=  tokenizer([input_text, input_text] ,				return_tensors='pt'  ).input_ids.to(snake_case_  )

        # spout from uniform and one-hot
        A_  :	Any    						=  [
            # fmt: off
            [0.87_88_22_08, 0.38_42_63_96, 0.33_22_02_48, 0.43_89_04_06, 0.16_56_22_52,
            0.04_80_39_85, 0.21_15_72  , 0.23_18_84_73, 0.37_15_30_68, 0.7_83_63_77 ,
            0.02_16_01_72, 0.38_76_17_19, 0.75_29_07_72, 0.90_19_88_57, 0.34_36_57_77,
            0.64_16_81_69, 0.44_31_84_71, 0.14_57_57_46, 0.92_56_28_81, 0.40_81_21_48,
            0.29_01_91_22, 0.88_86_15_99, 0.65_52_48_46, 0.43_56_34_56, 0.38_17_71_87,
            0.70_83_29_65, 0.81_52_78_92, 0.68_83_28_12, 0.38_83_31_92, 0.4_56_15_22 ,
            0.14_82_88_17, 0.47_24_82_13, 0.54_35_73_35, 0.82_00_95_66, 0.1_33_88_84 ,
            0.02_75_54_17, 0.19_76_46_77, 0.2_42_20_84 , 0.04_75_76_74, 0.65_40_96_06,
            0.0_82_45_89 , 0.03_30_43_83, 0.94_38_76_89, 0.98_76_45_09, 0.82_43_39_01,
            0.27_64_67_41, 0.64_90_74_93, 0.76_00_94_06, 0.30_08_79_15, 0.17_90_46_89,
            0.41_60_17_14, 0.67_04_63_98, 0.10_42_28_22, 0.08_44_73_74, 0.07_35_43_44,
            0.61_42_35_65, 0.70_28_48_66, 0.7_53_23_33 , 0.1_97_20_38 , 0.29_57_56_59,
            0.90_58_38_86, 0.29_26_53_07, 0.50_00_01_75, 0.70_40_76_55, 0.88_93_63  ,
            0.81_90_44_18, 0.66_82_91_28, 0.64_46_88_15, 0.56_56_37_23, 0.85_60_18_75,
            0.94_92_46_72, 0.00_16_67_62, 0.25_22_06_43, 0.74_54_02_19, 0.67_99_32_47,
            0.1_54_96_75 , 0.39_38_53_52, 0.92_15_36_07, 0.63_74_59_31, 0.27_75_90_43,
            0.84_70_22_95, 0.65_90_42_71, 0.58_67_66_14, 0.8_66_69_36 , 0.39_60_74_38,
            0.79_95_49_83, 0.42_22_06_97, 0.39_65_03_81, 0.7_84_98_64 , 0.56_15_02_01,
            0.15_67_89_25, 0.14_74_60_32, 0.34_54_21_14, 0.47_02_67_83, 0.11_95_64_89,
            0.25_42_14_35, 0.33_78_89_01, 0.68_93_48_42, 0.36_42_46_85, 0.71_73_78_98,
            0.38_98_34_49, 0.94_39_37_79, 0.39_57_55_88, 0.36_61_65_53, 0.87_10_46_65,
            0.64_63_02_03, 0.22_51_69_05, 0.88_27_08_04, 0.15_03_13_38, 0.75_14_43_45,
            0.46_45_90_25, 0.85_39_64_54, 0.86_35_56_43, 0.65_13_98_51, 0.70_26_60_61,
            0.30_24_13_89, 0.81_05_64_97, 0.88_86_59_69, 0.38_77_38_07, 0.70_63_58_49,
            0.90_71_84_59, 0.43_24_57_89, 0.28_00_06_54, 0.45_93_55_62, 0.08_77_35_19,
            0.9_55_21_51 , 0.93_90_15_11, 0.22_48_92_88], # 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
        ]

        A_  :	Optional[Any]    						=  model.generate(
            input_ids=snake_case_ ,				spout=spouts[0] ,				max_new_tokens=2_0 ,				generation_config=snake_case_ ,				)

        A_  :	Tuple    						=  model.generate(
            input_ids=snake_case_ ,				spout=spouts[1] ,				max_new_tokens=2_0 ,				generation_config=snake_case_ ,				)

        A_  :	str    						=  model.generate(
            input_ids=snake_case_ ,				spout=snake_case_ ,				max_new_tokens=2_0 ,				generation_config=snake_case_ ,				)

        A_  :	Optional[Any]    						=  tokenizer.decode(outputa[0]  )
        A_  :	Tuple    						=  tokenizer.decode(outputa[0]  )
        A_  :	Any    						=  tokenizer.batch_decode(snake_case_  )

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

      @slow
      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	Tuple    						=  GPTSanJapaneseForConditionalGeneration.from_pretrained('Tanrei/GPTSAN-japanese'  )
        A_  :	List[str]    						=  GPTSanJapaneseTokenizer.from_pretrained('Tanrei/GPTSAN-japanese'  )
        model.to(snake_case_  )

        # set deterministically
        A_  :	Tuple    						=  GenerationConfig.from_pretrained('Tanrei/GPTSAN-japanese'  )
        A_  :	List[str]    						=  1

        A_  :	str    						=  '武田信玄'
        A_  :	List[Any]    						=  '織田信長'
        A_  :	Tuple    						=  'は、'
        A_  :	Optional[Any]    						=  'が、'
        A_  :	int    						=  tokenizer(snake_case_ ,				prefix_text=snake_case_ ,				return_tensors='pt'  )
        A_  :	Any    						=  tokenizer(snake_case_ ,				prefix_text=snake_case_ ,				return_tensors='pt'  )
        A_  :	Optional[Any]    						=  tokenizer([[prefix_text_a, input_text_a], [prefix_text_a, input_text_a]] ,				return_tensors='pt'  )

        A_  :	Optional[int]    						=  model.generate(
            input_ids=input_tok_a.input_ids.to(snake_case_  ) ,				token_type_ids=input_tok_a.token_type_ids.to(snake_case_  ) ,				max_new_tokens=2_0 ,				generation_config=snake_case_ ,				)

        A_  :	List[Any]    						=  model.generate(
            input_ids=input_tok_a.input_ids.to(snake_case_  ) ,				token_type_ids=input_tok_a.token_type_ids.to(snake_case_  ) ,				max_new_tokens=2_0 ,				generation_config=snake_case_ ,				)

        A_  :	Optional[Any]    						=  model.generate(
            input_ids=input_tok_a.input_ids.to(snake_case_  ) ,				token_type_ids=input_tok_a.token_type_ids.to(snake_case_  ) ,				attention_mask=input_tok_a.attention_mask.to(snake_case_  ) ,				max_new_tokens=2_0 ,				generation_config=snake_case_ ,				)

        A_  :	str    						=  tokenizer.decode(outputa[0]  )
        A_  :	List[str]    						=  tokenizer.decode(outputa[0]  )
        A_  :	str    						=  tokenizer.batch_decode(snake_case_  )

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






"""simple docstring"""




from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


lowerCamelCase_					:						Union[str, Any]      = logging.get_logger(__name__)

lowerCamelCase_					:						Optional[Any]      = {
    'gpt2': 'https://huggingface.co/gpt2/resolve/main/config.json',
    'gpt2-medium': 'https://huggingface.co/gpt2-medium/resolve/main/config.json',
    'gpt2-large': 'https://huggingface.co/gpt2-large/resolve/main/config.json',
    'gpt2-xl': 'https://huggingface.co/gpt2-xl/resolve/main/config.json',
    'distilgpt2': 'https://huggingface.co/distilgpt2/resolve/main/config.json',
}

class 			_UpperCAmelCase  (       UpperCAmelCase__		):



      '''simple docstring'''
      lowercase_				:			Optional[Any]        =       """gpt2"""
      lowercase_				:			Optional[int]        =       ["""past_key_values"""]
      lowercase_				:			Dict        =       {
          """hidden_size""": """n_embd""",
          """max_position_embeddings""": """n_positions""",
          """num_attention_heads""": """n_head""",
          """num_hidden_layers""": """n_layer""",
      }

      def __init__(					self ,				snake_case_=5_0_2_5_7 ,				snake_case_=1_0_2_4 ,				snake_case_=7_6_8 ,				snake_case_=1_2 ,				snake_case_=1_2 ,				snake_case_=None ,				snake_case_="gelu_new" ,				snake_case_=0.1 ,				snake_case_=0.1 ,				snake_case_=0.1 ,				snake_case_=1E-5 ,				snake_case_=0.02 ,				snake_case_="cls_index" ,				snake_case_=True ,				snake_case_=None ,				snake_case_=True ,				snake_case_=0.1 ,				snake_case_=True ,				snake_case_=True ,				snake_case_=5_0_2_5_6 ,				snake_case_=5_0_2_5_6 ,				snake_case_=False ,				snake_case_=False ,				**snake_case_ ,				):

        """simple docstring"""

        A_  :	Union[str, Any]    						=  vocab_size
        A_  :	List[Any]    						=  n_positions
        A_  :	List[Any]    						=  n_embd
        A_  :	Tuple    						=  n_layer
        A_  :	List[Any]    						=  n_head
        A_  :	List[str]    						=  n_inner
        A_  :	str    						=  activation_function
        A_  :	Optional[Any]    						=  resid_pdrop
        A_  :	int    						=  embd_pdrop
        A_  :	Tuple    						=  attn_pdrop
        A_  :	str    						=  layer_norm_epsilon
        A_  :	Any    						=  initializer_range
        A_  :	Union[str, Any]    						=  summary_type
        A_  :	Optional[Any]    						=  summary_use_proj
        A_  :	Dict    						=  summary_activation
        A_  :	Optional[int]    						=  summary_first_dropout
        A_  :	Optional[int]    						=  summary_proj_to_labels
        A_  :	Any    						=  scale_attn_weights
        A_  :	Optional[Any]    						=  use_cache
        A_  :	Dict    						=  scale_attn_by_inverse_layer_idx
        A_  :	Any    						=  reorder_and_upcast_attn

        A_  :	Optional[Any]    						=  bos_token_id
        A_  :	List[Any]    						=  eos_token_id

        super().__init__(bos_token_id=snake_case_ ,				eos_token_id=snake_case_ ,				**snake_case_  )


class 			_UpperCAmelCase  (       UpperCAmelCase__		):



      '''simple docstring'''

      def __init__(					self ,				snake_case_ ,				snake_case_ = "default" ,				snake_case_ = None ,				snake_case_ = False ,				):

        """simple docstring"""

        super().__init__(snake_case_ ,				task=snake_case_ ,				patching_specs=snake_case_ ,				use_past=snake_case_  )
        if not getattr(self._config ,				'pad_token_id' ,				snake_case_  ):
          # TODO: how to do that better?
          A_  :	Tuple    						=  0

      @property
      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        A_  :	Dict    						=  OrderedDict({'input_ids': {0: 'batch', 1: 'sequence'}}  )
        if self.use_past:
          self.fill_with_past_key_values_(snake_case_ ,				direction='inputs'  )
          A_  :	List[str]    						=  {0: 'batch', 1: 'past_sequence + sequence'}
        else:
          A_  :	Tuple    						=  {0: 'batch', 1: 'sequence'}

        return common_inputs

      @property
      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        return self._config.n_layer

      @property
      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        return self._config.n_head

      def  lowerCamelCase_      (					self ,				snake_case_ ,				snake_case_ = -1 ,				snake_case_ = -1 ,				snake_case_ = False ,				snake_case_ = None ,				):

        """simple docstring"""

        A_  :	int    						=  super(snake_case_ ,				self  ).generate_dummy_inputs(
            snake_case_ ,				batch_size=snake_case_ ,				seq_length=snake_case_ ,				is_pair=snake_case_ ,				framework=snake_case_  )

        # We need to order the input in the way they appears in the forward()
        A_  :	Optional[Any]    						=  OrderedDict({'input_ids': common_inputs['input_ids']}  )

        # Need to add the past_keys
        if self.use_past:
          if not is_torch_available():
            raise ValueError('Cannot generate dummy past_keys inputs without PyTorch installed.'  )
          else:
            import torch

            A_						,	A_  :	List[str]    						=  common_inputs['input_ids'].shape
            # Not using the same length for past_key_values
            A_  :	Optional[Any]    						=  seqlen + 2
            A_  :	Any    						=  (
                batch,
                self.num_attention_heads,
                past_key_values_length,
                self._config.hidden_size // self.num_attention_heads,
            )
            A_  :	Any    						=  [
                (torch.zeros(snake_case_  ), torch.zeros(snake_case_  )) for _ in range(self.num_layers  )
            ]

        A_  :	List[Any]    						=  common_inputs['attention_mask']
        if self.use_past:
          A_  :	List[Any]    						=  ordered_inputs['attention_mask'].dtype
          A_  :	Any    						=  torch.cat(
              [ordered_inputs['attention_mask'], torch.ones(snake_case_ ,				snake_case_ ,				dtype=snake_case_  )] ,				dim=1  )

        return ordered_inputs

      @property
      def  lowerCamelCase_      (					self  ):

        """simple docstring"""

        return 1_3