import math

import tensorflow as tf
from packaging import version







def  __UpperCamelCase    (						A							):
     UpperCamelCase__										=      tf.convert_to_tensor(A							)
     UpperCamelCase__										=      0.5 * (1.0 + tf.math.erf(x / tf.cast(tf.sqrt(2.0							) ,							x.dtype							)							))

     return x * cdf







def  __UpperCamelCase    (						A							):
     UpperCamelCase__										=      tf.convert_to_tensor(A							)
     UpperCamelCase__										=      tf.cast(math.pi ,							x.dtype							)
     UpperCamelCase__										=      tf.cast(0.04_47_15 ,							x.dtype							)
     UpperCamelCase__										=      0.5 * (1.0 + tf.tanh(tf.sqrt(2.0 / pi							) * (x + coeff * tf.pow(A ,							3							))							))

     return x * cdf







def  __UpperCamelCase    (						A							):
     UpperCamelCase__										=      tf.convert_to_tensor(A							)

     return x * tf.tanh(tf.math.softplus(A							)							)







def  __UpperCamelCase    (						A							):
     UpperCamelCase__										=      tf.convert_to_tensor(A							)
     UpperCamelCase__										=      tf.cast(0.04_47_15 ,							x.dtype							)
     UpperCamelCase__										=      tf.cast(0.79_78_84_56_08 ,							x.dtype							)

     return 0.5 * x * (1.0 + tf.tanh(x * coeffa * (1.0 + coeffa * x * x)							))







def  __UpperCamelCase    (						A							):
     UpperCamelCase__										=      tf.convert_to_tensor(A							)
     UpperCamelCase__										=      tf.cast(1.7_02 ,							x.dtype							)
     return x * tf.math.sigmoid(coeff * x							)







def  __UpperCamelCase    (						A							):
     return tf.clip_by_value(_gelu(A							) ,							-10 ,							10							)







def  __UpperCamelCase    (						A ,							A=-1							):
     UpperCamelCase__						,       UpperCamelCase__										=      tf.split(A ,							2 ,							axis=A							)
     return a * tf.math.sigmoid(A							)


if version.parse(tf.version.VERSION) >= version.parse('''2.4'''):







     def  __UpperCamelCase    (						A							):
          return tf.keras.activations.gelu(A ,							approximate=A							)

     __magic_name__								=tf.keras.activations.gelu



     __magic_name__								=approximate_gelu_wrap
else:
     __magic_name__								=_gelu
     __magic_name__								=_gelu_new


__magic_name__								={
    '''gelu''': gelu,
    '''gelu_10''': gelu_aa,
    '''gelu_fast''': gelu_fast,
    '''gelu_new''': gelu_new,
    '''glu''': glu,
    '''mish''': mish,
    '''quick_gelu''': quick_gelu,
    '''relu''': tf.keras.activations.relu,
    '''sigmoid''': tf.keras.activations.sigmoid,
    '''silu''': tf.keras.activations.swish,
    '''swish''': tf.keras.activations.swish,
    '''tanh''': tf.keras.activations.tanh,
}







def  __UpperCamelCase    (						A							):
     if activation_string in ACTaFN:
          return ACTaFN[activation_string]
     else:
          raise KeyError(f"function {activation_string} not found in ACT2FN mapping {list(ACTaFN.keys()							)}"							)




import unittest

from transformers import TrOCRConfig
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.trocr.modeling_trocr import TrOCRDecoder, TrOCRForCausalLM



@require_torch
class     _A   :






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





       '''simple docstring'''





       UpperCamelCase__										=      parent
       UpperCamelCase__										=      batch_size
       UpperCamelCase__										=      decoder_seq_length
       # For common tests
       UpperCamelCase__										=      self.decoder_seq_length
       UpperCamelCase__										=      is_training
       UpperCamelCase__										=      use_attention_mask
       UpperCamelCase__										=      use_labels

       UpperCamelCase__										=      vocab_size
       UpperCamelCase__										=      d_model
       UpperCamelCase__										=      d_model
       UpperCamelCase__										=      decoder_layers
       UpperCamelCase__										=      decoder_layers
       UpperCamelCase__										=      decoder_ffn_dim
       UpperCamelCase__										=      decoder_attention_heads
       UpperCamelCase__										=      decoder_attention_heads
       UpperCamelCase__										=      eos_token_id
       UpperCamelCase__										=      bos_token_id
       UpperCamelCase__										=      pad_token_id
       UpperCamelCase__										=      decoder_start_token_id
       UpperCamelCase__										=      use_cache
       UpperCamelCase__										=      max_position_embeddings

       UpperCamelCase__										=      None
       UpperCamelCase__										=      decoder_seq_length
       UpperCamelCase__										=      2
       UpperCamelCase__										=      1






  def 		_a					(self	)		->      str:





       '''simple docstring'''





       UpperCamelCase__										=      ids_tensor([self.batch_size, self.decoder_seq_length]   ,				self.vocab_size	)

       UpperCamelCase__										=      None
       if self.use_attention_mask:
            UpperCamelCase__										=      ids_tensor([self.batch_size, self.decoder_seq_length]   ,				vocab_size=2	)

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

       UpperCamelCase__										=      TrOCRConfig(
           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   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_   ,				SCREAMING_SNAKE_CASE_   ,				)		->      Any:





       '''simple docstring'''





       UpperCamelCase__										=      True
       UpperCamelCase__										=      TrOCRDecoder(config=SCREAMING_SNAKE_CASE_	).to(SCREAMING_SNAKE_CASE_	).eval()
       UpperCamelCase__										=      input_ids[:2]

       input_ids[input_ids == 0] += 1
       # first forward pass
       UpperCamelCase__										=      model(SCREAMING_SNAKE_CASE_   ,				use_cache=SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      model(SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      model(SCREAMING_SNAKE_CASE_   ,				use_cache=SCREAMING_SNAKE_CASE_	)

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

       UpperCamelCase__										=      outputs['''past_key_values''']

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

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

       UpperCamelCase__										=      model(SCREAMING_SNAKE_CASE_	)['''last_hidden_state''']
       UpperCamelCase__										=      model(SCREAMING_SNAKE_CASE_   ,				past_key_values=SCREAMING_SNAKE_CASE_	)['''last_hidden_state''']

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

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






  def 		_a					(self	)		->      Dict:





       '''simple docstring'''





       UpperCamelCase__										=      self.prepare_config_and_inputs()
       UpperCamelCase__						,       UpperCamelCase__						,       UpperCamelCase__						,       UpperCamelCase__										=      config_and_inputs

       UpperCamelCase__										=      {'''input_ids''': input_ids, '''attention_mask''': attention_mask}
       return config, inputs_dict



@require_torch
class     _A   (    __UpperCamelCase	, __UpperCamelCase	, __UpperCamelCase	, unittest.TestCase							):
  SCREAMING_SNAKE_CASE_	:	Tuple						=(TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
  SCREAMING_SNAKE_CASE_	:	Any						=(TrOCRForCausalLM,) if is_torch_available() else ()
  SCREAMING_SNAKE_CASE_	:	Optional[int]						={"text-generation": TrOCRForCausalLM} if is_torch_available() else {}
  SCREAMING_SNAKE_CASE_	:	Optional[int]						=True
  SCREAMING_SNAKE_CASE_	:	Dict						=False






  def 		_a					(self	)		->      int:





       '''simple docstring'''





       UpperCamelCase__										=      TrOCRStandaloneDecoderModelTester(self   ,				is_training=SCREAMING_SNAKE_CASE_	)
       UpperCamelCase__										=      ConfigTester(self   ,				config_class=SCREAMING_SNAKE_CASE_	)






  def 		_a					(self	)		->      Dict:





       '''simple docstring'''





       pass






  def 		_a					(self	)		->      List[str]:





       '''simple docstring'''





       pass






  def 		_a					(self	)		->      int:





       '''simple docstring'''





       pass






  def 		_a					(self	)		->      Tuple:





       '''simple docstring'''





       self.config_tester.run_common_tests()






  def 		_a					(self	)		->      Any:





       '''simple docstring'''





       UpperCamelCase__										=      self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_decoder_model_past(*SCREAMING_SNAKE_CASE_	)






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





       '''simple docstring'''





       return






  @unittest.skip('''The model doesn\'t support left padding'''	)  # and it's not used enough to be worth fixing :)
  def 		_a					(self	)		->      Optional[int]:





       '''simple docstring'''





       pass



