

"""simple docstring"""


import unittest

from transformers import GPTSwaTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


__A		  =     get_tests_dir("fixtures/test_sentencepiece_with_bytefallback.model")





@require_sentencepiece
@require_tokenizers
class        snake_case      (							UpperCAmelCase__,				unittest.TestCase    ):
				SCREAMING_SNAKE_CASE_  : List[str]   =    GPTSwaTokenizer
				SCREAMING_SNAKE_CASE_  : Any   =    False
				SCREAMING_SNAKE_CASE_  : Any   =    True
				SCREAMING_SNAKE_CASE_  : Union[str, Any]   =    False

				def 				lowercase_	(      self				:							int)->  Tuple:



						'''simple docstring'''


						super().setUp()

						# We have a SentencePiece fixture for testing
						__lowerCAmelCase:			str        =     GPTSwaTokenizer(UpperCAmelCase__	,    eos_token="<unk>"	,    bos_token="<unk>"	,    pad_token="<unk>")

						tokenizer.save_pretrained(self.tmpdirname)

				def 				lowercase_	(      self				:							Optional[int]	,    UpperCamelCase__				:							List[Any])->  Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase:			Union[str, Any]        =     "This is a test"
						__lowerCAmelCase:			List[Any]        =     "This is a test"
						return input_text, output_text

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



						'''simple docstring'''


						__lowerCAmelCase:			Dict        =     "<s>"
						__lowerCAmelCase:			Union[str, Any]        =     1

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

				def 				lowercase_	(      self				:							Optional[int])->  Dict:



						'''simple docstring'''


						__lowerCAmelCase:			Any        =     list(self.get_tokenizer().get_vocab().keys())

						self.assertEqual(vocab_keys[0]	,    "<unk>")
						self.assertEqual(vocab_keys[1]	,    "<s>")
						self.assertEqual(vocab_keys[-1]	,    "j")
						self.assertEqual(len(UpperCAmelCase__)	,    2_0_0_0)

				def 				lowercase_	(      self				:							int)->  Dict:



						'''simple docstring'''


						self.assertEqual(self.get_tokenizer().vocab_size	,    2_0_0_0)

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



						'''simple docstring'''


						__lowerCAmelCase:			List[Any]        =     GPTSwaTokenizer(UpperCAmelCase__)

						__lowerCAmelCase:			Tuple        =     tokenizer.tokenize("This is a test")
						self.assertListEqual(UpperCAmelCase__	,    ["▁This", "▁is", "▁a", "▁t", "est"])

						self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase__)	,    [4_6_5, 2_8_7, 2_6_5, 6_3_1, 8_4_2])

						__lowerCAmelCase:			Union[str, Any]        =     tokenizer.tokenize("I was born in 92000, and this is falsé.")
						# fmt: off
						self.assertListEqual(
						    UpperCAmelCase__	,    ["▁I", "▁was", "▁bor", "n", "▁in", "▁", "<0x39>", "2", "0", "0", "0", ",", "▁and", "▁this", "▁is", "▁f", "al", "s", "<0xC3>", "<0xA9>", "."]	,    )
						# fmt: on

						__lowerCAmelCase:			int        =     tokenizer.convert_tokens_to_ids(UpperCAmelCase__)
						self.assertListEqual(
						    UpperCAmelCase__	,    [2_6_2, 2_7_2, 1_5_2_5, 2_8_6, 2_7_1, 2_6_8, 6_0, 9_1_6, 6_3_3, 6_3_3, 6_3_3, 2_5_9, 2_6_6, 3_0_1, 2_8_7, 3_8_4, 3_6_7, 2_6_3, 1_9_8, 1_7_2, 2_6_0]	,    )

						__lowerCAmelCase:			Optional[int]        =     tokenizer.convert_ids_to_tokens(UpperCAmelCase__)
						# fmt: off
						self.assertListEqual(
						    UpperCAmelCase__	,    ["▁I", "▁was", "▁bor", "n", "▁in", "▁", "<0x39>", "2", "0", "0", "0", ",", "▁and", "▁this", "▁is", "▁f", "al", "s", "<0xC3>", "<0xA9>", "."])
						# fmt: on

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



						'''simple docstring'''


						__lowerCAmelCase:			Tuple        =     GPTSwaTokenizer(UpperCAmelCase__)
						__lowerCAmelCase:			Union[str, Any]        =     ["This is a test", "I was born in 92000, and this is falsé."]
						__lowerCAmelCase:			Optional[Any]        =     [
						    [4_6_5, 2_8_7, 2_6_5, 6_3_1, 8_4_2],
						    [2_6_2, 2_7_2, 1_5_2_5, 2_8_6, 2_7_1, 2_6_8, 6_0, 9_1_6, 6_3_3, 6_3_3, 6_3_3, 2_5_9, 2_6_6, 3_0_1, 2_8_7, 3_8_4, 3_6_7, 2_6_3, 1_9_8, 1_7_2, 2_6_0],
						]

						# Test that encode_fast returns the same as tokenize + convert_tokens_to_ids
						for text, expected_ids in zip(UpperCAmelCase__	,    UpperCAmelCase__):
								self.assertListEqual(tokenizer.encode_fast(UpperCAmelCase__)	,    UpperCAmelCase__)

						# Test that decode_fast returns the input text
						for text, token_ids in zip(UpperCAmelCase__	,    UpperCAmelCase__):
								self.assertEqual(tokenizer.decode_fast(UpperCAmelCase__)	,    UpperCAmelCase__)




				@slow
				def 				lowercase_	(      self				:							Any)->  int:



						'''simple docstring'''


						__lowerCAmelCase:			Dict        =     [
						    "<|python|>def fibonacci(n)\n    if n < 0:\n        print(\'Incorrect input\')",
						    "Hey there, how are you doing this fine day?",
						    "This is a text with a trailing spaces followed by a dot     .",
						    "Häj sväjs lillebrör! =)",
						    "Det är inget fel på Mr. Cool",
						]

						# fmt: off
						__lowerCAmelCase:			Optional[int]        =     {"input_ids": [[6_3_4_2_3, 5, 6_8_1_1, 1_4_9_5_4, 2_8_2, 8_1_6, 3_8_2_1, 6_3_4_6_6, 6_3_4_2_5, 6_3_4_6_2, 1_8, 6_3_9_7_8, 6_7_8, 3_0_1, 1_3_2_0, 6_3_4_2_3, 6_3_4_5_5, 6_3_4_5_8, 1_8, 6_3_9_8_2, 4_2_4_6, 3_9_4_0, 1_9_0_1, 4_7_7_8_9, 5_5_4_7, 1_8_9_9_4], [1_9_6_3_0, 1_1_0_0, 6_3_4_4_6, 1_3_4_2, 6_3_3, 5_4_4, 4_4_8_8, 5_9_3, 5_1_0_2, 2_4_1_6, 6_3_4_9_5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1_6_5_2, 4_2_8, 2_6_8, 1_9_3_6, 5_1_5, 2_6_8, 5_8_5_9_3, 2_2_4_1_3, 9_1_0_6, 5_4_6, 2_6_8, 3_3_2_1_3, 6_3_9_7_9, 6_9_8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_5_1_3_0, 6_3_4_5_0, 9_2_4, 6_3_4_4_9, 2_2_4_9, 4_0_6_2, 1_5_5_8, 3_1_8, 6_3_5_0_4, 2_1_4_9_8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [5_0_9, 3_7_7, 2_8_2_7, 2_5_5_9, 3_3_2, 6_5_7_5, 6_3_4_4_3, 2_6_8_0_1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "token_type_ids": [[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, 0, 0, 0]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}
						# fmt: on
						self.tokenizer_integration_test_util(
						    expected_encoding=UpperCAmelCase__	,    model_name="AI-Sweden/gpt-sw3-126m"	,    sequences=UpperCAmelCase__	,    )








import unittest

from transformers import BertGenerationConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
  import torch

  from transformers import BertGenerationDecoder, BertGenerationEncoder


class 							UpperCamelCase_       :

    '''simple docstring'''






    def __init__(     self :      Tuple   ,					UpperCAmelCase__ :      List[Any]   ,					UpperCAmelCase__ :      Dict=13   ,					UpperCAmelCase__ :      Dict=7   ,					UpperCAmelCase__ :      Dict=True   ,					UpperCAmelCase__ :      List[Any]=True   ,					UpperCAmelCase__ :      str=99   ,					UpperCAmelCase__ :      Union[str, Any]=32   ,					UpperCAmelCase__ :      Tuple=5   ,					UpperCAmelCase__ :      Union[str, Any]=4   ,					UpperCAmelCase__ :      List[Any]=37   ,					UpperCAmelCase__ :      Union[str, Any]="gelu"   ,					UpperCAmelCase__ :      Optional[int]=0.1   ,					UpperCAmelCase__ :      Optional[Any]=0.1   ,					UpperCAmelCase__ :      Tuple=50   ,					UpperCAmelCase__ :      Optional[int]=0.02   ,					UpperCAmelCase__ :      List[str]=True   ,					UpperCAmelCase__ :      List[str]=None   ,					)		->Union[str, Any]:





           '''simple docstring'''

           A__ 					=       parent
           A__ 					=       batch_size
           A__ 					=       seq_length
           A__ 					=       is_training
           A__ 					=       use_input_mask
           A__ 					=       vocab_size
           A__ 					=       hidden_size
           A__ 					=       num_hidden_layers
           A__ 					=       num_attention_heads
           A__ 					=       intermediate_size
           A__ 					=       hidden_act
           A__ 					=       hidden_dropout_prob
           A__ 					=       attention_probs_dropout_prob
           A__ 					=       max_position_embeddings
           A__ 					=       initializer_range
           A__ 					=       use_labels
           A__ 					=       scope


    def 			SCREAMING_SNAKE_CASE				(     self :      int)		->Any:





           '''simple docstring'''

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

           A__ 					=       None
           if self.use_input_mask:
                  A__ 					=       random_attention_mask([self.batch_size, self.seq_length])

           if self.use_labels:
                  A__ 					=       ids_tensor([self.batch_size, self.seq_length]   ,					self.vocab_size)

           A__ 					=       self.get_config()

           return config, input_ids, input_mask, token_labels


    def 			SCREAMING_SNAKE_CASE				(     self :      int)		->int:





           '''simple docstring'''

           return BertGenerationConfig(
               vocab_size=self.vocab_size   ,					hidden_size=self.hidden_size   ,					num_hidden_layers=self.num_hidden_layers   ,					num_attention_heads=self.num_attention_heads   ,					intermediate_size=self.intermediate_size   ,					hidden_act=self.hidden_act   ,					hidden_dropout_prob=self.hidden_dropout_prob   ,					attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,					max_position_embeddings=self.max_position_embeddings   ,					is_decoder=UpperCAmelCase__   ,					initializer_range=self.initializer_range   ,					)


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





           '''simple docstring'''

           (
               (
               A__
           )					,				(
               A__
           )					,				(
               A__
           )					,				(
               A__
           )					,				
           ) 					=       self.prepare_config_and_inputs()

           A__ 					=       True
           A__ 					=       floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
           A__ 					=       ids_tensor([self.batch_size, self.seq_length]   ,					vocab_size=2)

           return (
               config,
               input_ids,
               input_mask,
               token_labels,
               encoder_hidden_states,
               encoder_attention_mask,
           )


    def 			SCREAMING_SNAKE_CASE				(     self :      Any   ,					UpperCAmelCase__ :      Any   ,					UpperCAmelCase__ :      Optional[Any]   ,					UpperCAmelCase__ :      Optional[int]   ,					UpperCAmelCase__ :      List[str]   ,					**UpperCAmelCase__ :      List[Any]   ,					)		->Dict:





           '''simple docstring'''

           A__ 					=       BertGenerationEncoder(config=UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           A__ 					=       model(UpperCAmelCase__   ,					attention_mask=UpperCAmelCase__)
           A__ 					=       model(UpperCAmelCase__)
           self.parent.assertEqual(result.last_hidden_state.shape   ,					(self.batch_size, self.seq_length, self.hidden_size))


    def 			SCREAMING_SNAKE_CASE				(     self :      Dict   ,					UpperCAmelCase__ :      Union[str, Any]   ,					UpperCAmelCase__ :      Union[str, Any]   ,					UpperCAmelCase__ :      str   ,					UpperCAmelCase__ :      List[str]   ,					UpperCAmelCase__ :      Optional[int]   ,					UpperCAmelCase__ :      int   ,					**UpperCAmelCase__ :      Optional[Any]   ,					)		->Dict:





           '''simple docstring'''

           A__ 					=       True
           A__ 					=       BertGenerationEncoder(config=UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           A__ 					=       model(
               UpperCAmelCase__   ,					attention_mask=UpperCAmelCase__   ,					encoder_hidden_states=UpperCAmelCase__   ,					encoder_attention_mask=UpperCAmelCase__   ,					)
           A__ 					=       model(
               UpperCAmelCase__   ,					attention_mask=UpperCAmelCase__   ,					encoder_hidden_states=UpperCAmelCase__   ,					)
           self.parent.assertEqual(result.last_hidden_state.shape   ,					(self.batch_size, self.seq_length, self.hidden_size))


    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[int]   ,					UpperCAmelCase__ :      str   ,					UpperCAmelCase__ :      Tuple   ,					UpperCAmelCase__ :      Optional[int]   ,					UpperCAmelCase__ :      Any   ,					UpperCAmelCase__ :      Optional[int]   ,					UpperCAmelCase__ :      Dict   ,					**UpperCAmelCase__ :      Optional[int]   ,					)		->Any:





           '''simple docstring'''

           A__ 					=       True
           A__ 					=       True
           A__ 					=       BertGenerationDecoder(config=UpperCAmelCase__).to(UpperCAmelCase__).eval()

           # first forward pass
           A__ 					=       model(
               UpperCAmelCase__   ,					attention_mask=UpperCAmelCase__   ,					encoder_hidden_states=UpperCAmelCase__   ,					encoder_attention_mask=UpperCAmelCase__   ,					use_cache=UpperCAmelCase__   ,					)
           A__ 					=       outputs.past_key_values

           # create hypothetical multiple next token and extent to next_input_ids
           A__ 					=       ids_tensor((self.batch_size, 3)   ,					config.vocab_size)
           A__ 					=       ids_tensor((self.batch_size, 3)   ,					vocab_size=2)

           # append to next input_ids and
           A__ 					=       torch.cat([input_ids, next_tokens]   ,					dim=-1)
           A__ 					=       torch.cat([input_mask, next_mask]   ,					dim=-1)

           A__ 					=       model(
               UpperCAmelCase__   ,					attention_mask=UpperCAmelCase__   ,					encoder_hidden_states=UpperCAmelCase__   ,					encoder_attention_mask=UpperCAmelCase__   ,					output_hidden_states=UpperCAmelCase__   ,					)['''hidden_states'''][0]
           A__ 					=       model(
               UpperCAmelCase__   ,					attention_mask=UpperCAmelCase__   ,					encoder_hidden_states=UpperCAmelCase__   ,					encoder_attention_mask=UpperCAmelCase__   ,					past_key_values=UpperCAmelCase__   ,					output_hidden_states=UpperCAmelCase__   ,					)['''hidden_states'''][0]

           # select random slice
           A__ 					=       ids_tensor((1,)   ,					output_from_past.shape[-1]).item()
           A__ 					=       output_from_no_past[:, -3:, random_slice_idx].detach()
           A__ 					=       output_from_past[:, :, random_slice_idx].detach()

           self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1])

           # test that outputs are equal for slice
           self.parent.assertTrue(torch.allclose(UpperCAmelCase__   ,					UpperCAmelCase__   ,					atol=1e-3))


    def 			SCREAMING_SNAKE_CASE				(     self :      Tuple   ,					UpperCAmelCase__ :      int   ,					UpperCAmelCase__ :      Any   ,					UpperCAmelCase__ :      Optional[int]   ,					UpperCAmelCase__ :      List[str]   ,					*UpperCAmelCase__ :      List[str]   ,					)		->List[Any]:





           '''simple docstring'''

           A__ 					=       BertGenerationDecoder(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()
           A__ 					=       model(UpperCAmelCase__   ,					attention_mask=UpperCAmelCase__   ,					labels=UpperCAmelCase__)
           self.parent.assertEqual(result.logits.shape   ,					(self.batch_size, self.seq_length, self.vocab_size))





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





           '''simple docstring'''

           A__					,				A__					,				A__					,				A__ 					=       self.prepare_config_and_inputs()
           A__ 					=       {'''input_ids''': input_ids, '''attention_mask''': input_mask}
           return config, inputs_dict


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

    '''simple docstring'''






    UpperCAmelCase__				    = (BertGenerationEncoder, BertGenerationDecoder) if is_torch_available() else ()
    UpperCAmelCase__				    = (BertGenerationDecoder,) if is_torch_available() else ()
    UpperCAmelCase__				    = (
        {'''feature-extraction''': BertGenerationEncoder, '''text-generation''': BertGenerationDecoder}
        if is_torch_available()
        else {}
    )


    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[int])		->Dict:





           '''simple docstring'''

           A__ 					=       BertGenerationEncoderTester(self)
           A__ 					=       ConfigTester(self   ,					config_class=UpperCAmelCase__   ,					hidden_size=37)


    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[int])		->List[str]:





           '''simple docstring'''

           self.config_tester.run_common_tests()


    def 			SCREAMING_SNAKE_CASE				(     self :      List[Any])		->int:





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*UpperCAmelCase__)


    def 			SCREAMING_SNAKE_CASE				(     self :      Dict)		->Optional[Any]:





           '''simple docstring'''

           A__					,				A__					,				A__					,				A__ 					=       self.model_tester.prepare_config_and_inputs()
           A__ 					=       '''bert'''
           self.model_tester.create_and_check_model(UpperCAmelCase__   ,					UpperCAmelCase__   ,					UpperCAmelCase__   ,					UpperCAmelCase__)


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





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs_for_decoder()
           self.model_tester.create_and_check_model_as_decoder(*UpperCAmelCase__)


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





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs_for_decoder()
           self.model_tester.create_and_check_decoder_model_past_large_inputs(*UpperCAmelCase__)


    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[int])		->Any:





           '''simple docstring'''

           (
               (
               A__
           )					,				(
               A__
           )					,				(
               A__
           )					,				(
               A__
           )					,				(
               A__
           )					,				(
               A__
           )					,				
           ) 					=       self.model_tester.prepare_config_and_inputs_for_decoder()

           A__ 					=       None

           self.model_tester.create_and_check_model_as_decoder(
               UpperCAmelCase__   ,					UpperCAmelCase__   ,					UpperCAmelCase__   ,					UpperCAmelCase__   ,					UpperCAmelCase__   ,					UpperCAmelCase__   ,					)


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





           '''simple docstring'''

           A__ 					=       self.model_tester.prepare_config_and_inputs_for_decoder()
           self.model_tester.create_and_check_for_causal_lm(*UpperCAmelCase__)





    @slow
    def 			SCREAMING_SNAKE_CASE				(     self :      Dict)		->List[Any]:





           '''simple docstring'''

           A__ 					=       BertGenerationEncoder.from_pretrained('''google/bert_for_seq_generation_L-24_bbc_encoder''')
           self.assertIsNotNone(UpperCAmelCase__)


@require_torch
class 							UpperCamelCase_       (					unittest.TestCase	):

    '''simple docstring'''






    @slow
    def 			SCREAMING_SNAKE_CASE				(     self :      Any)		->Union[str, Any]:





           '''simple docstring'''

           A__ 					=       BertGenerationEncoder.from_pretrained('''google/bert_for_seq_generation_L-24_bbc_encoder''')
           A__ 					=       torch.tensor([[101, 7_592, 1_010, 2_026, 3_899, 2_003, 10_140, 102]])
           with torch.no_grad():
                  A__ 					=       model(UpperCAmelCase__)[0]
           A__ 					=       torch.Size([1, 8, 1_024])
           self.assertEqual(output.shape   ,					UpperCAmelCase__)
           A__ 					=       torch.tensor(
               [[[0.1775, 0.0083, -0.0321], [1.6002, 0.1287, 0.3912], [2.1473, 0.5791, 0.6066]]])
           self.assertTrue(torch.allclose(output[:, :3, :3]   ,					UpperCAmelCase__   ,					atol=1e-4))


@require_torch
class 							UpperCamelCase_       (					unittest.TestCase	):

    '''simple docstring'''






    @slow
    def 			SCREAMING_SNAKE_CASE				(     self :      Optional[Any])		->Union[str, Any]:





           '''simple docstring'''

           A__ 					=       BertGenerationDecoder.from_pretrained('''google/bert_for_seq_generation_L-24_bbc_encoder''')
           A__ 					=       torch.tensor([[101, 7_592, 1_010, 2_026, 3_899, 2_003, 10_140, 102]])
           with torch.no_grad():
                  A__ 					=       model(UpperCAmelCase__)[0]
           A__ 					=       torch.Size([1, 8, 50_358])
           self.assertEqual(output.shape   ,					UpperCAmelCase__)
           A__ 					=       torch.tensor(
               [[[-0.5788, -2.5994, -3.7054], [0.0438, 4.7997, 1.8795], [1.5862, 6.6409, 4.4638]]])
           self.assertTrue(torch.allclose(output[:, :3, :3]   ,					UpperCAmelCase__   ,					atol=1e-4))


