





def 							SCREAMING_SNAKE_CASE__       (  snake_case__  :Optional[Any]     )      ->						Dict:
  assert isinstance(UpperCamelCase__			,							UpperCamelCase__     ), F"""The input value of [n={number}] is not an integer"""

  if number == 1:
    return 2
  elif number < 1:
    _lowercase							= F"""The input value of [n={number}] has to be > 0"""
    raise ValueError(UpperCamelCase__     )
  else:
    _lowercase							= sylvester(number - 1     )
    _lowercase							= num - 1
    _lowercase							= num
    return lower * upper + 1


if __name__ == "__main__":
      print(F"""The 8th number in Sylvester\'s sequence: {sylvester(8)}""")






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 				A_				:







       """simple docstring"""





       def __init__(    self	:	List[Any]						,__A	:	str						,__A	:	Dict=13						,__A	:	Dict=7						,__A	:	List[Any]=True						,__A	:	Union[str, Any]=True						,__A	:	Any=99						,__A	:	Optional[Any]=32						,__A	:	Any=5						,__A	:	int=4						,__A	:	Dict=37						,__A	:	Dict="gelu"						,__A	:	Union[str, Any]=0.1						,__A	:	List[Any]=0.1						,__A	:	str=50						,__A	:	str=0.02						,__A	:	str=True						,__A	:	List[Any]=None						,)						->					Optional[Any]:
         _lowercase							= parent
         _lowercase							= batch_size
         _lowercase							= seq_length
         _lowercase							= is_training
         _lowercase							= use_input_mask
         _lowercase							= vocab_size
         _lowercase							= hidden_size
         _lowercase							= num_hidden_layers
         _lowercase							= num_attention_heads
         _lowercase							= intermediate_size
         _lowercase							= hidden_act
         _lowercase							= hidden_dropout_prob
         _lowercase							= attention_probs_dropout_prob
         _lowercase							= max_position_embeddings
         _lowercase							= initializer_range
         _lowercase							= use_labels
         _lowercase							= scope







       def    __UpperCAmelCase (    self	:	int  )						->					Optional[Any]:
         _lowercase							= ids_tensor([self.batch_size, self.seq_length]						,self.vocab_size  )

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

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

         _lowercase							= self.get_config()

         return config, input_ids, input_mask, token_labels







       def    __UpperCAmelCase (    self	:	Optional[int]  )						->					int:
         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=__A						,initializer_range=self.initializer_range						,)







       def    __UpperCAmelCase (    self	:	Union[str, Any]  )						->					int:
         (
             (
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		
         )							= self.prepare_config_and_inputs()

         _lowercase							= True
         _lowercase							= floats_tensor([self.batch_size, self.seq_length, self.hidden_size]  )
         _lowercase							= 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    __UpperCAmelCase (    self	:	Dict						,__A	:	List[Any]						,__A	:	Optional[int]						,__A	:	Optional[int]						,__A	:	int						,**__A	:	Union[str, Any]						,)						->					List[Any]:
         _lowercase							= BertGenerationEncoder(config=__A  )
         model.to(__A  )
         model.eval()
         _lowercase							= model(__A						,attention_mask=__A  )
         _lowercase							= model(__A  )
         self.parent.assertEqual(result.last_hidden_state.shape						,(self.batch_size, self.seq_length, self.hidden_size)  )







       def    __UpperCAmelCase (    self	:	List[str]						,__A	:	Optional[Any]						,__A	:	int						,__A	:	Dict						,__A	:	int						,__A	:	Tuple						,__A	:	str						,**__A	:	int						,)						->					Optional[Any]:
         _lowercase							= True
         _lowercase							= BertGenerationEncoder(config=__A  )
         model.to(__A  )
         model.eval()
         _lowercase							= model(
             __A						,attention_mask=__A						,encoder_hidden_states=__A						,encoder_attention_mask=__A						,)
         _lowercase							= model(
             __A						,attention_mask=__A						,encoder_hidden_states=__A						,)
         self.parent.assertEqual(result.last_hidden_state.shape						,(self.batch_size, self.seq_length, self.hidden_size)  )







       def    __UpperCAmelCase (    self	:	List[str]						,__A	:	List[str]						,__A	:	List[str]						,__A	:	Optional[Any]						,__A	:	List[Any]						,__A	:	Optional[int]						,__A	:	Optional[int]						,**__A	:	Dict						,)						->					List[Any]:
         _lowercase							= True
         _lowercase							= True
         _lowercase							= BertGenerationDecoder(config=__A  ).to(__A  ).eval()

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

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

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

         _lowercase							= model(
             __A						,attention_mask=__A						,encoder_hidden_states=__A						,encoder_attention_mask=__A						,output_hidden_states=__A						,)['hidden_states'][0]
         _lowercase							= model(
             __A						,attention_mask=__A						,encoder_hidden_states=__A						,encoder_attention_mask=__A						,past_key_values=__A						,output_hidden_states=__A						,)['hidden_states'][0]

         # select random slice
         _lowercase							= ids_tensor((1,)						,output_from_past.shape[-1]  ).item()
         _lowercase							= output_from_no_past[:, -3:, random_slice_idx].detach()
         _lowercase							= 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(__A						,__A						,atol=1e-3  )  )







       def    __UpperCAmelCase (    self	:	List[str]						,__A	:	List[str]						,__A	:	List[str]						,__A	:	List[Any]						,__A	:	List[str]						,*__A	:	List[Any]						,)						->					Tuple:
         _lowercase							= BertGenerationDecoder(__A  )
         model.to(__A  )
         model.eval()
         _lowercase							= model(__A						,attention_mask=__A						,labels=__A  )
         self.parent.assertEqual(result.logits.shape						,(self.batch_size, self.seq_length, self.vocab_size)  )







       def    __UpperCAmelCase (    self	:	List[Any]  )						->					Dict:
         _lowercase						,		_lowercase						,		_lowercase						,		_lowercase							= self.prepare_config_and_inputs()
         _lowercase							= {'input_ids': input_ids, 'attention_mask': input_mask}
         return config, inputs_dict





@require_torch
class 				A_				(      UpperCAmelCase					,	UpperCAmelCase					,	UpperCAmelCase					,	unittest.TestCase	):







       """simple docstring"""





       SCREAMING_SNAKE_CASE_      : List[str]      =  (BertGenerationEncoder, BertGenerationDecoder) if is_torch_available() else ()
       SCREAMING_SNAKE_CASE_      : Union[str, Any]      =  (BertGenerationDecoder,) if is_torch_available() else ()
       SCREAMING_SNAKE_CASE_      : Dict      =  (
           {'''feature-extraction''': BertGenerationEncoder, '''text-generation''': BertGenerationDecoder}
           if is_torch_available()
           else {}
       )







       def    __UpperCAmelCase (    self	:	Any  )						->					Union[str, Any]:
         _lowercase							= BertGenerationEncoderTester(self  )
         _lowercase							= ConfigTester(self						,config_class=__A						,hidden_size=37  )







       def    __UpperCAmelCase (    self	:	int  )						->					int:
         self.config_tester.run_common_tests()







       def    __UpperCAmelCase (    self	:	Tuple  )						->					Any:
         _lowercase							= self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*__A  )







       def    __UpperCAmelCase (    self	:	Union[str, Any]  )						->					Dict:
         _lowercase						,		_lowercase						,		_lowercase						,		_lowercase							= self.model_tester.prepare_config_and_inputs()
         _lowercase							= 'bert'
         self.model_tester.create_and_check_model(__A						,__A						,__A						,__A  )







       def    __UpperCAmelCase (    self	:	Tuple  )						->					List[Any]:
         _lowercase							= self.model_tester.prepare_config_and_inputs_for_decoder()
         self.model_tester.create_and_check_model_as_decoder(*__A  )







       def    __UpperCAmelCase (    self	:	Tuple  )						->					Union[str, Any]:
         _lowercase							= self.model_tester.prepare_config_and_inputs_for_decoder()
         self.model_tester.create_and_check_decoder_model_past_large_inputs(*__A  )







       def    __UpperCAmelCase (    self	:	Any  )						->					Union[str, Any]:
         # This regression test was failing with PyTorch < 1.3
         (
             (
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		(
             _lowercase
         )						,		
         )							= self.model_tester.prepare_config_and_inputs_for_decoder()

         _lowercase							= None

         self.model_tester.create_and_check_model_as_decoder(
             __A						,__A						,__A						,__A						,__A						,__A						,)







       def    __UpperCAmelCase (    self	:	Optional[Any]  )						->					Union[str, Any]:
         _lowercase							= self.model_tester.prepare_config_and_inputs_for_decoder()
         self.model_tester.create_and_check_for_causal_lm(*__A  )







       @slow
       def    __UpperCAmelCase (    self	:	List[Any]  )						->					str:
         _lowercase							= BertGenerationEncoder.from_pretrained('google/bert_for_seq_generation_L-24_bbc_encoder'  )
         self.assertIsNotNone(__A  )





@require_torch
class 				A_				(      unittest.TestCase	):







       """simple docstring"""





       @slow
       def    __UpperCAmelCase (    self	:	Tuple  )						->					Union[str, Any]:
         _lowercase							= BertGenerationEncoder.from_pretrained('google/bert_for_seq_generation_L-24_bbc_encoder'  )
         _lowercase							= torch.tensor([[101, 7592, 1010, 2026, 3899, 2003, 1_0140, 102]]  )
         with torch.no_grad():
           _lowercase							= model(__A  )[0]
         _lowercase							= torch.Size([1, 8, 1024]  )
         self.assertEqual(output.shape						,__A  )
         _lowercase							= 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]						,__A						,atol=1e-4  )  )





@require_torch
class 				A_				(      unittest.TestCase	):







       """simple docstring"""





       @slow
       def    __UpperCAmelCase (    self	:	Optional[Any]  )						->					Union[str, Any]:
         _lowercase							= BertGenerationDecoder.from_pretrained('google/bert_for_seq_generation_L-24_bbc_encoder'  )
         _lowercase							= torch.tensor([[101, 7592, 1010, 2026, 3899, 2003, 1_0140, 102]]  )
         with torch.no_grad():
           _lowercase							= model(__A  )[0]
         _lowercase							= torch.Size([1, 8, 5_0358]  )
         self.assertEqual(output.shape						,__A  )
         _lowercase							= 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]						,__A						,atol=1e-4  )  )