code: 
  '''simple docstring'''
  
  import unittest
  
  from transformers import SpeechaTextaConfig
  from transformers.testing_utils import is_torch_available, require_torch, 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
  
  
  if is_torch_available():
       import torch
  
       from transformers.models.speech_to_text_a.modeling_speech_to_text_a import (
           SpeechaTextaDecoder,
           SpeechaTextaForCausalLM,
       )
  
  
  @require_torch
  class   a_  :
  
  
  
  
         def __init__(     self   ,   snake_case_   ,   snake_case_=9_9   ,   snake_case_=1_3   ,   snake_case_=1_6   ,   snake_case_=7   ,   snake_case_=True   ,   snake_case_=True   ,   snake_case_=True   ,   snake_case_=False   ,   snake_case_=True   ,   snake_case_=2   ,   snake_case_=3_2   ,   snake_case_=4   ,   snake_case_=4   ,   snake_case_=3_0   ,   snake_case_=0   ,   snake_case_=1   ,   snake_case_=2   ,   snake_case_=None   ,   ):
           _lowerCAmelCase       :  Any   				=					parent
           _lowerCAmelCase       :  List[Any]   				=					batch_size
           _lowerCAmelCase       :  List[str]   				=					decoder_seq_length
           # For common tests
           _lowerCAmelCase       :  Tuple   				=					self.decoder_seq_length
           _lowerCAmelCase       :  Tuple   				=					is_training
           _lowerCAmelCase       :  List[Any]   				=					use_attention_mask
           _lowerCAmelCase       :  Union[str, Any]   				=					use_labels
  
           _lowerCAmelCase       :  Any   				=					vocab_size
           _lowerCAmelCase       :  Dict   				=					d_model
           _lowerCAmelCase       :  List[Any]   				=					d_model
           _lowerCAmelCase       :  List[str]   				=					decoder_layers
           _lowerCAmelCase       :  Optional[Any]   				=					decoder_layers
           _lowerCAmelCase       :  List[str]   				=					decoder_ffn_dim
           _lowerCAmelCase       :  str   				=					decoder_attention_heads
           _lowerCAmelCase       :  List[Any]   				=					decoder_attention_heads
           _lowerCAmelCase       :  List[str]   				=					eos_token_id
           _lowerCAmelCase       :  int   				=					bos_token_id
           _lowerCAmelCase       :  Dict   				=					pad_token_id
           _lowerCAmelCase       :  Optional[int]   				=					decoder_start_token_id
           _lowerCAmelCase       :  List[Any]   				=					use_cache
           _lowerCAmelCase       :  Union[str, Any]   				=					max_position_embeddings
  
           _lowerCAmelCase       :  List[Any]   				=					None
           _lowerCAmelCase       :  str   				=					decoder_seq_length
           _lowerCAmelCase       :  Any   				=					2
           _lowerCAmelCase       :  Dict   				=					1
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  int   				=					ids_tensor([self.batch_size, self.decoder_seq_length]   ,   self.vocab_size  )
  
           _lowerCAmelCase       :  str   				=					None
           if self.use_attention_mask:
             _lowerCAmelCase       :  Dict   				=					ids_tensor([self.batch_size, self.decoder_seq_length]   ,   vocab_size=2  )
  
           _lowerCAmelCase       :  Dict   				=					None
           if self.use_labels:
             _lowerCAmelCase       :  List[Any]   				=					ids_tensor([self.batch_size, self.decoder_seq_length]   ,   self.vocab_size  )
  
           _lowerCAmelCase       :  List[Any]   				=					SpeechaTextaConfig(
               vocab_size=self.vocab_size   ,   d_model=self.d_model   ,   decoder_layers=self.decoder_layers   ,   decoder_ffn_dim=self.decoder_ffn_dim   ,   decoder_attention_heads=self.decoder_attention_heads   ,   eos_token_id=self.eos_token_id   ,   bos_token_id=self.bos_token_id   ,   use_cache=self.use_cache   ,   pad_token_id=self.pad_token_id   ,   decoder_start_token_id=self.decoder_start_token_id   ,   max_position_embeddings=self.max_position_embeddings   ,   )
  
           return (
               config,
               input_ids,
               attention_mask,
               lm_labels,
           )
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_   ,   snake_case_   ,   snake_case_   ,   snake_case_   ,   ):
           _lowerCAmelCase       :  str   				=					True
           _lowerCAmelCase       :  List[Any]   				=					SpeechaTextaDecoder(config=__UpperCamelCase  ).to(__UpperCamelCase  ).eval()
           _lowerCAmelCase       :  Tuple   				=					input_ids[:2]
  
           input_ids[input_ids == 0] += 1
           # first forward pass
           _lowerCAmelCase       :  List[str]   				=					model(__UpperCamelCase   ,   use_cache=__UpperCamelCase  )
           _lowerCAmelCase       :  List[Any]   				=					model(__UpperCamelCase  )
           _lowerCAmelCase       :  Union[str, Any]   				=					model(__UpperCamelCase   ,   use_cache=__UpperCamelCase  )
  
           self.parent.assertTrue(len(__UpperCamelCase  ) == len(__UpperCamelCase  )  )
           self.parent.assertTrue(len(__UpperCamelCase  ) == len(__UpperCamelCase  ) + 1  )
  
           _lowerCAmelCase       :  Optional[Any]   				=					outputs["""past_key_values"""]
  
           # create hypothetical next token and extent to next_input_ids
           _lowerCAmelCase       :  Any   				=					ids_tensor((2, 1)   ,   config.vocab_size - 1  ) + 1
  
           # append to next input_ids and
           _lowerCAmelCase       :  int   				=					torch.cat([input_ids, next_tokens]   ,   dim=-1  )
  
           print(__UpperCamelCase  )
  
           _lowerCAmelCase       :  int   				=					model(__UpperCamelCase  )["""last_hidden_state"""]
           _lowerCAmelCase       :  Any   				=					model(__UpperCamelCase   ,   past_key_values=__UpperCamelCase  )["""last_hidden_state"""]
  
           # select random slice
           _lowerCAmelCase       :  Any   				=					ids_tensor((1,)   ,   output_from_past.shape[-1]  ).item()
           _lowerCAmelCase       :  str   				=					output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
           _lowerCAmelCase       :  str   				=					output_from_past[:, 0, random_slice_idx].detach()
  
           # test that outputs are equal for slice
           assert torch.allclose(__UpperCamelCase   ,   __UpperCamelCase   ,   atol=1E-3  )
  
  
  
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  str   				=					self.prepare_config_and_inputs()
           (
               (
               _lowerCAmelCase					
           )				,					(
               _lowerCAmelCase					
           )				,					(
               _lowerCAmelCase					
           )				,					(
               _lowerCAmelCase					
           )				,										
           )       :  Optional[Any]   				=					config_and_inputs
  
           _lowerCAmelCase       :  str   				=					{
               """input_ids""": input_ids,
               """attention_mask""": attention_mask,
           }
           return config, inputs_dict
  
  
  
  @require_torch
  class   a_  (UpperCAmelCase_							,			UpperCAmelCase_							,			UpperCAmelCase_							,			unittest.TestCase    ):
         __lowerCAmelCase    :				Optional[Any]    =      (SpeechaTextaDecoder, SpeechaTextaForCausalLM) if is_torch_available() else ()
         __lowerCAmelCase    :				Tuple    =      (SpeechaTextaForCausalLM,) if is_torch_available() else ()
         __lowerCAmelCase    :				Union[str, Any]    =      {"""text-generation""": SpeechaTextaForCausalLM} if is_torch_available() else {}
         __lowerCAmelCase    :				List[Any]    =      True
         __lowerCAmelCase    :				List[Any]    =      False
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   ):
           _lowerCAmelCase       :  str   				=					SpeechaTextaStandaloneDecoderModelTester(self   ,   is_training=__UpperCamelCase  )
           _lowerCAmelCase       :  Optional[Any]   				=					ConfigTester(self   ,   config_class=__UpperCamelCase  )
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           pass
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           pass
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           pass
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           self.config_tester.run_common_tests()
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  str   				=					self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_decoder_model_past(*__UpperCamelCase  )
  
  
  
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           return
  
  
  
style_context: 
  '''simple docstring'''
  
  import random
  
  
  class   a_  :
  
  
  
  
         def __init__(     self   ,   snake_case_   ,   snake_case_  ):
           _lowerCAmelCase       :  List[str]   				=					x
           _lowerCAmelCase       :  List[str]   				=					y
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           return (self.x**2 + self.y**2) <= 1
  
  
  
  
  
  
  
         @classmethod
         def 							__UpperCamelCase       (     cls  ):
           return cls(x=random.random()   ,   y=random.random()  )
  
  
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       int		)    ->						float:
    if number_of_simulations < 1:
      raise ValueError("""At least one simulation is necessary to estimate PI."""		)
  
    _lowerCAmelCase       :  Tuple   				=					0
    for _ in range(_lowerCamelCase		):
      _lowerCAmelCase       :  Union[str, Any]   				=					Point.random_unit_square()
  
      if random_point.is_in_unit_circle():
        number_in_unit_circle += 1
  
    return 4 * number_in_unit_circle / number_of_simulations
  
  
  if __name__ == "__main__":
       # import doctest
  
       # doctest.testmod()
       from math import pi
  
       UpperCamelCase_     			=       """Please enter the desired number of Monte Carlo simulations: """
       UpperCamelCase_     			=       estimate_pi(int(input(prompt).strip()))
       print(F'An estimate of PI is {my_pi} with an error of {abs(my_pi - pi)}')
  
  
  