




'''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      UpperCamelCase       :



  def __init__(			self		,     __lowerCAmelCase		,     __lowerCAmelCase=99		,     __lowerCAmelCase=13		,     __lowerCAmelCase=16		,     __lowerCAmelCase=7		,     __lowerCAmelCase=True		,     __lowerCAmelCase=True		,     __lowerCAmelCase=True		,     __lowerCAmelCase=False		,     __lowerCAmelCase=True		,     __lowerCAmelCase=2		,     __lowerCAmelCase=32		,     __lowerCAmelCase=4		,     __lowerCAmelCase=4		,     __lowerCAmelCase=30		,     __lowerCAmelCase=0		,     __lowerCAmelCase=1		,     __lowerCAmelCase=2		,     __lowerCAmelCase=None		,     ):







      '''simple docstring'''


      _a				:							str							       =      parent
      _a				:							List[str]							       =      batch_size
      _a				:							List[Any]							       =      decoder_seq_length
      # For common tests
      _a				:							List[Any]							       =      self.decoder_seq_length
      _a				:							Any							       =      is_training
      _a				:							str							       =      use_attention_mask
      _a				:							List[str]							       =      use_labels

      _a				:							Dict							       =      vocab_size
      _a				:							List[Any]							       =      d_model
      _a				:							List[str]							       =      d_model
      _a				:							List[str]							       =      decoder_layers
      _a				:							int							       =      decoder_layers
      _a				:							Optional[int]							       =      decoder_ffn_dim
      _a				:							List[Any]							       =      decoder_attention_heads
      _a				:							Tuple							       =      decoder_attention_heads
      _a				:							Dict							       =      eos_token_id
      _a				:							List[Any]							       =      bos_token_id
      _a				:							int							       =      pad_token_id
      _a				:							List[str]							       =      decoder_start_token_id
      _a				:							Dict							       =      use_cache
      _a				:							Optional[Any]							       =      max_position_embeddings

      _a				:							str							       =      None
      _a				:							Optional[Any]							       =      decoder_seq_length
      _a				:							List[str]							       =      2
      _a				:							Dict							       =      1



  def     a_							(			self ):







      '''simple docstring'''


      _a				:							Tuple							       =      ids_tensor([self.batch_size, self.decoder_seq_length]		,     self.vocab_size )

      _a				:							Any							       =      None
      if self.use_attention_mask:
          _a				:							Union[str, Any]							       =      ids_tensor([self.batch_size, self.decoder_seq_length]		,     vocab_size=2 )

      _a				:							int							       =      None
      if self.use_labels:
          _a				:							Tuple							       =      ids_tensor([self.batch_size, self.decoder_seq_length]		,     self.vocab_size )

      _a				:							int							       =      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     a_							(			self		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase		,     __lowerCAmelCase		,     ):







      '''simple docstring'''


      _a				:							Any							       =      True
      _a				:							int							       =      SpeechaTextaDecoder(config=__lowerCAmelCase ).to(__lowerCAmelCase ).eval()
      _a				:							Dict							       =      input_ids[:2]

      input_ids[input_ids == 0] += 1
      # first forward pass
      _a				:							Union[str, Any]							       =      model(__lowerCAmelCase		,     use_cache=__lowerCAmelCase )
      _a				:							List[Any]							       =      model(__lowerCAmelCase )
      _a				:							Union[str, Any]							       =      model(__lowerCAmelCase		,     use_cache=__lowerCAmelCase )

      self.parent.assertTrue(len(__lowerCAmelCase ) == len(__lowerCAmelCase ) )
      self.parent.assertTrue(len(__lowerCAmelCase ) == len(__lowerCAmelCase ) + 1 )

      _a				:							List[Any]							       =      outputs["""past_key_values"""]

      # create hypothetical next token and extent to next_input_ids
      _a				:							Any							       =      ids_tensor((2, 1)		,     config.vocab_size - 1 ) + 1

      # append to next input_ids and
      _a				:							Any							       =      torch.cat([input_ids, next_tokens]		,     dim=-1 )

      print(__lowerCAmelCase )

      _a				:							List[Any]							       =      model(__lowerCAmelCase )["""last_hidden_state"""]
      _a				:							List[str]							       =      model(__lowerCAmelCase		,     past_key_values=__lowerCAmelCase )["""last_hidden_state"""]

      # select random slice
      _a				:							List[Any]							       =      ids_tensor((1,)		,     output_from_past.shape[-1] ).item()
      _a				:							List[Any]							       =      output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
      _a				:							Dict							       =      output_from_past[:, 0, random_slice_idx].detach()

      # test that outputs are equal for slice
      assert torch.allclose(__lowerCAmelCase		,     __lowerCAmelCase		,     atol=1e-3 )



  def     a_							(			self ):







      '''simple docstring'''


      _a				:							Dict							       =      self.prepare_config_and_inputs()
      (
          (
          _a
      )       , (
          _a
      )       , (
          _a
      )       , (
          _a
      )       , 
      )				:							Any							       =      config_and_inputs

      _a				:							Dict							       =      {
          """input_ids""": input_ids,
          """attention_mask""": attention_mask,
      }
      return config, inputs_dict






@require_torch
class      UpperCamelCase       (	snake_case__      ,		snake_case__      ,		snake_case__      ,		unittest.TestCase       ):
  a     :int          =					(SpeechaTextaDecoder, SpeechaTextaForCausalLM) if is_torch_available() else ()
  a     :List[Any]          =					(SpeechaTextaForCausalLM,) if is_torch_available() else ()
  a     :int          =					{'text-generation': SpeechaTextaForCausalLM} if is_torch_available() else {}
  a     :Optional[Any]          =					True
  a     :Tuple          =					False



  def     a_							(			self		,     ):







      '''simple docstring'''


      _a				:							List[str]							       =      SpeechaTextaStandaloneDecoderModelTester(self		,     is_training=__lowerCAmelCase )
      _a				:							List[Any]							       =      ConfigTester(self		,     config_class=__lowerCAmelCase )



  def     a_							(			self ):







      '''simple docstring'''


      pass



  def     a_							(			self ):







      '''simple docstring'''


      pass



  def     a_							(			self ):







      '''simple docstring'''


      pass



  def     a_							(			self ):







      '''simple docstring'''


      self.config_tester.run_common_tests()



  def     a_							(			self ):







      '''simple docstring'''


      _a				:							Optional[int]							       =      self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_decoder_model_past(*__lowerCAmelCase )



  def     a_							(			self ):







      '''simple docstring'''


      return







def 	__snake_case      (     _UpperCAmelCase  ,					_UpperCAmelCase  ,					_UpperCAmelCase							):
    __a					=							[1 / first_term]
    __a					=							1 / first_term
    for _ in range(number_of_terms - 1							):
        first_term += common_difference
        arithmetic_progression.append(_UpperCAmelCase							)
    __a					=							[1 / step for step in arithmetic_progression]
    return sum(_UpperCAmelCase							)


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 print(sum_of_harmonic_progression(1 / 2, 2, 2))





