

import unittest

from transformers import AutoTokenizer, FalconConfig, 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, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
       import torch

       from transformers import (
           FalconForCausalLM,
           FalconForQuestionAnswering,
           FalconForSequenceClassification,
           FalconForTokenClassification,
           FalconModel,
       )



class       __snake_case  :

  def __init__(					self						,		_A						,		_A=3						,		_A=7						,		_A=True						,		_A=True						,		_A=False						,		_A=True						,		_A=99						,		_A=32						,		_A=5						,		_A=4						,		_A=37						,		_A="gelu"						,		_A=0.1						,		_A=0.1						,		_A=512						,		_A=16						,		_A=2						,		_A=0.0_2						,		_A=3						,		_A=4						,		_A=None						,		):
      SCREAMING_SNAKE_CASE_									=						parent
      SCREAMING_SNAKE_CASE_									=						batch_size
      SCREAMING_SNAKE_CASE_									=						seq_length
      SCREAMING_SNAKE_CASE_									=						is_training
      SCREAMING_SNAKE_CASE_									=						use_input_mask
      SCREAMING_SNAKE_CASE_									=						use_token_type_ids
      SCREAMING_SNAKE_CASE_									=						use_labels
      SCREAMING_SNAKE_CASE_									=						vocab_size
      SCREAMING_SNAKE_CASE_									=						hidden_size
      SCREAMING_SNAKE_CASE_									=						num_hidden_layers
      SCREAMING_SNAKE_CASE_									=						num_attention_heads
      SCREAMING_SNAKE_CASE_									=						intermediate_size
      SCREAMING_SNAKE_CASE_									=						hidden_act
      SCREAMING_SNAKE_CASE_									=						hidden_dropout_prob
      SCREAMING_SNAKE_CASE_									=						attention_probs_dropout_prob
      SCREAMING_SNAKE_CASE_									=						max_position_embeddings
      SCREAMING_SNAKE_CASE_									=						type_vocab_size
      SCREAMING_SNAKE_CASE_									=						type_sequence_label_size
      SCREAMING_SNAKE_CASE_									=						initializer_range
      SCREAMING_SNAKE_CASE_									=						num_labels
      SCREAMING_SNAKE_CASE_									=						num_choices
      SCREAMING_SNAKE_CASE_									=						scope

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						ids_tensor([self.batch_size, self.seq_length]						,		self.vocab_size)

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

      SCREAMING_SNAKE_CASE_									=						None

      SCREAMING_SNAKE_CASE_									=						None
      SCREAMING_SNAKE_CASE_									=						None
      SCREAMING_SNAKE_CASE_									=						None
      if self.use_labels:
          SCREAMING_SNAKE_CASE_									=						ids_tensor([self.batch_size]						,		self.type_sequence_label_size)
          SCREAMING_SNAKE_CASE_									=						ids_tensor([self.batch_size, self.seq_length]						,		self.num_labels)
          SCREAMING_SNAKE_CASE_									=						ids_tensor([self.batch_size]						,		self.num_choices)

      SCREAMING_SNAKE_CASE_									=						self.get_config()

      return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

  def 						lowerCAmelCase__     (					self):
      return FalconConfig(
          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						,		type_vocab_size=self.type_vocab_size						,		is_decoder=_A						,		initializer_range=self.initializer_range						,		pad_token_id=1						,		new_decoder_architecture=_A						,		)

  def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A):
      SCREAMING_SNAKE_CASE_									=						FalconModel(config=_A)
      model.to(_A)
      model.eval()
      SCREAMING_SNAKE_CASE_									=						model(_A						,		attention_mask=_A)
      SCREAMING_SNAKE_CASE_									=						model(_A)
      self.parent.assertEqual(result.last_hidden_state.shape						,		(self.batch_size, self.seq_length, self.hidden_size))

  def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		):
      SCREAMING_SNAKE_CASE_									=						True
      SCREAMING_SNAKE_CASE_									=						FalconModel(_A)
      model.to(_A)
      model.eval()
      SCREAMING_SNAKE_CASE_									=						model(
          _A						,		attention_mask=_A						,		encoder_hidden_states=_A						,		encoder_attention_mask=_A						,		)
      SCREAMING_SNAKE_CASE_									=						model(
          _A						,		attention_mask=_A						,		encoder_hidden_states=_A						,		)
      SCREAMING_SNAKE_CASE_									=						model(_A						,		attention_mask=_A)
      self.parent.assertEqual(result.last_hidden_state.shape						,		(self.batch_size, self.seq_length, self.hidden_size))

  def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		):
      SCREAMING_SNAKE_CASE_									=						FalconForCausalLM(config=_A)
      model.to(_A)
      model.eval()
      SCREAMING_SNAKE_CASE_									=						model(_A						,		attention_mask=_A						,		labels=_A)
      self.parent.assertEqual(result.logits.shape						,		(self.batch_size, self.seq_length, self.vocab_size))

  def 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		_A						,		):
      SCREAMING_SNAKE_CASE_									=						True
      SCREAMING_SNAKE_CASE_									=						True
      SCREAMING_SNAKE_CASE_									=						FalconForCausalLM(config=_A)
      model.to(_A)
      model.eval()

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

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

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

      SCREAMING_SNAKE_CASE_									=						model(
          _A						,		attention_mask=_A						,		encoder_hidden_states=_A						,		encoder_attention_mask=_A						,		output_hidden_states=_A						,		)['hidden_states'][0]
      SCREAMING_SNAKE_CASE_									=						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
      SCREAMING_SNAKE_CASE_									=						ids_tensor((1,)						,		output_from_past.shape[-1]).item()
      SCREAMING_SNAKE_CASE_									=						output_from_no_past[:, -3:, random_slice_idx].detach()
      SCREAMING_SNAKE_CASE_									=						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 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.prepare_config_and_inputs()
      (
          (
          SCREAMING_SNAKE_CASE_
      )							,			(
          SCREAMING_SNAKE_CASE_
      )							,			(
          SCREAMING_SNAKE_CASE_
      )							,			(
          SCREAMING_SNAKE_CASE_
      )							,			(
          SCREAMING_SNAKE_CASE_
      )							,			(
          SCREAMING_SNAKE_CASE_
      )							,			(
          SCREAMING_SNAKE_CASE_
      )							,			
      )									=						config_and_inputs
      SCREAMING_SNAKE_CASE_									=						{'input_ids': input_ids, 'attention_mask': input_mask}
      return config, inputs_dict






@require_torch
class       __snake_case  (    lowerCAmelCase__     , lowerCAmelCase__     , lowerCAmelCase__     , unittest.TestCase       ):
  __lowerCAmelCase     :	Optional[int]						 =  (
      (
          FalconModel,
          FalconForCausalLM,
          FalconForSequenceClassification,
          FalconForTokenClassification,
          FalconForQuestionAnswering,
      )
      if is_torch_available()
      else ()
  )
  __lowerCAmelCase     :	Any						 =  (FalconForCausalLM,) if is_torch_available() else ()
  __lowerCAmelCase     :	Optional[int]						 =  (
      {
          'feature-extraction': FalconModel,
          'text-classification': FalconForSequenceClassification,
          'text-generation': FalconForCausalLM,
          'question-answering': FalconForQuestionAnswering,
          'token-classification': FalconForTokenClassification,
          'zero-shot': FalconForSequenceClassification,
      }
      if is_torch_available()
      else {}
  )
  __lowerCAmelCase     :	Tuple						 =  False
  __lowerCAmelCase     :	Optional[Any]						 =  False

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						FalconModelTester(self)
      SCREAMING_SNAKE_CASE_									=						ConfigTester(self						,		config_class=_A						,		hidden_size=37)

  def 						lowerCAmelCase__     (					self):
      self.config_tester.run_common_tests()

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_A)

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_							,			*SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs()
      for alibi in [True, False]:
          SCREAMING_SNAKE_CASE_									=						alibi
          self.model_tester.create_and_check_model(_A						,		*_A)

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()
      SCREAMING_SNAKE_CASE_									=						3
      SCREAMING_SNAKE_CASE_									=						input_dict['input_ids']
      SCREAMING_SNAKE_CASE_									=						input_ids.ne(1).to(_A)
      SCREAMING_SNAKE_CASE_									=						ids_tensor([self.model_tester.batch_size]						,		self.model_tester.type_sequence_label_size)
      SCREAMING_SNAKE_CASE_									=						FalconForSequenceClassification(_A)
      model.to(_A)
      model.eval()
      SCREAMING_SNAKE_CASE_									=						model(_A						,		attention_mask=_A						,		labels=_A)
      self.assertEqual(result.logits.shape						,		(self.model_tester.batch_size, self.model_tester.num_labels))

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()
      SCREAMING_SNAKE_CASE_									=						3
      SCREAMING_SNAKE_CASE_									=						'single_label_classification'
      SCREAMING_SNAKE_CASE_									=						input_dict['input_ids']
      SCREAMING_SNAKE_CASE_									=						input_ids.ne(1).to(_A)
      SCREAMING_SNAKE_CASE_									=						ids_tensor([self.model_tester.batch_size]						,		self.model_tester.type_sequence_label_size)
      SCREAMING_SNAKE_CASE_									=						FalconForSequenceClassification(_A)
      model.to(_A)
      model.eval()
      SCREAMING_SNAKE_CASE_									=						model(_A						,		attention_mask=_A						,		labels=_A)
      self.assertEqual(result.logits.shape						,		(self.model_tester.batch_size, self.model_tester.num_labels))

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()
      SCREAMING_SNAKE_CASE_									=						input_dict['input_ids']
      SCREAMING_SNAKE_CASE_									=						FalconForCausalLM(_A)
      model.to(_A)
      model.eval()
      SCREAMING_SNAKE_CASE_									=						model(_A						,		use_cache=_A)
      SCREAMING_SNAKE_CASE_									=						input_ids.shape[0]
      SCREAMING_SNAKE_CASE_									=						model._convert_to_rw_cache(result.past_key_values)
      SCREAMING_SNAKE_CASE_									=						model._convert_cache_to_standard_format(_A						,		_A)
      for layer in range(len(_A)):
          for tensor_idx in range(2):
              self.assertTrue(rw_cache[layer][tensor_idx].ndim == 3)
              self.assertTrue(result.past_key_values[layer][tensor_idx].ndim == 4)
              self.assertTrue(
                  torch.all(result.past_key_values[layer][tensor_idx] == standard_cache[layer][tensor_idx]))

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()
      SCREAMING_SNAKE_CASE_									=						3
      SCREAMING_SNAKE_CASE_									=						'multi_label_classification'
      SCREAMING_SNAKE_CASE_									=						input_dict['input_ids']
      SCREAMING_SNAKE_CASE_									=						input_ids.ne(1).to(_A)
      SCREAMING_SNAKE_CASE_									=						ids_tensor(
          [self.model_tester.batch_size, config.num_labels]						,		self.model_tester.type_sequence_label_size).to(torch.float)
      SCREAMING_SNAKE_CASE_									=						FalconForSequenceClassification(_A)
      model.to(_A)
      model.eval()
      SCREAMING_SNAKE_CASE_									=						model(_A						,		attention_mask=_A						,		labels=_A)
      self.assertEqual(result.logits.shape						,		(self.model_tester.batch_size, self.model_tester.num_labels))


  def 						lowerCAmelCase__     (					self):
      # Falcon can have different numbers of KV-heads than the number of query heads, so we need
      # to override this test to use the right head counts.
      for model_class in self.all_generative_model_classes:
          SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs_for_common()

          # If it doesn't support cache, pass the test
          if not hasattr(_A						,		'use_cache'):
              return

          SCREAMING_SNAKE_CASE_									=						model_class(_A).to(_A)
          if "use_cache" not in inputs:
              SCREAMING_SNAKE_CASE_									=						True
          SCREAMING_SNAKE_CASE_									=						model(**_A)

          # If "past_key_values" is not returned, pass the test (e.g. RWKV uses a different cache name and format)
          if "past_key_values" not in outputs:
              return

          SCREAMING_SNAKE_CASE_									=						(
              getattr(_A						,		'decoder_layers'						,		_A)
              or getattr(_A						,		'num_decoder_layers'						,		_A)
              or config.num_hidden_layers
          )
          SCREAMING_SNAKE_CASE_									=						getattr(_A						,		'num_kv_heads'						,		config.num_attention_heads)
          SCREAMING_SNAKE_CASE_									=						getattr(_A						,		'd_model'						,		config.hidden_size)
          SCREAMING_SNAKE_CASE_									=						embed_dim // num_attention_heads

          SCREAMING_SNAKE_CASE_									=						outputs['past_key_values']
          self.assertEqual(len(_A)						,		_A)

          SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						inputs['input_ids'].shape
          for i in range(_A):
              if config.new_decoder_architecture:
                  SCREAMING_SNAKE_CASE_									=						config.num_attention_heads
              elif config.multi_query:
                  SCREAMING_SNAKE_CASE_									=						1
              self.assertEqual(len(past_kv[0])						,		2)  # K V for the decoder = 2
              self.assertEqual(
                  past_kv[i][0].shape						,		(batch_size, num_attention_heads, seq_length, per_head_embed_dim))
              self.assertEqual(
                  past_kv[i][1].shape						,		(batch_size, num_attention_heads, seq_length, per_head_embed_dim))






@require_torch
class       __snake_case  (    unittest.TestCase       ):

  @slow
  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						AutoTokenizer.from_pretrained('Rocketknight1/falcon-rw-1b')
      SCREAMING_SNAKE_CASE_									=						FalconForCausalLM.from_pretrained('Rocketknight1/falcon-rw-1b')
      model.eval()
      model.to(_A)
      SCREAMING_SNAKE_CASE_									=						tokenizer('My favorite food is'						,		return_tensors='pt').to(_A)

      SCREAMING_SNAKE_CASE_									=						(
          'My favorite food is pizza. I love it so much that I have a pizza party every year for my birthday.'
      )

      SCREAMING_SNAKE_CASE_									=						model.generate(**_A						,		do_sample=_A						,		max_new_tokens=19)
      SCREAMING_SNAKE_CASE_									=						tokenizer.batch_decode(_A)[0]

      self.assertEqual(_A						,		_A)

  @slow
  def 						lowerCAmelCase__     (					self):
      # The big models are way too big for the CI, so we use tiny random models that resemble their
      # architectures but with much smaller and fewer layers
      for repo in ["Rocketknight1/tiny-random-falcon-7b", "Rocketknight1/tiny-random-falcon-40b"]:
          SCREAMING_SNAKE_CASE_									=						AutoTokenizer.from_pretrained(_A)
          SCREAMING_SNAKE_CASE_									=						FalconForCausalLM.from_pretrained(_A)
          model.eval()
          model.to(_A)
          SCREAMING_SNAKE_CASE_									=						tokenizer('My favorite food is'						,		return_tensors='pt').to(_A)

          # We just test that these run without errors - the models are randomly initialized
          # and so the actual text outputs will be garbage
          model.generate(**_A						,		do_sample=_A						,		max_new_tokens=4)
          model.generate(**_A						,		do_sample=_A						,		max_new_tokens=4)
          model.generate(**_A						,		num_beams=2						,		max_new_tokens=4)


  @slow
  def 						lowerCAmelCase__     (					self):
      # The big models are way too big for the CI, so we use tiny random models that resemble their
      # architectures but with much smaller and fewer layers
      with torch.no_grad():
          for repo in [
              "Rocketknight1/falcon-rw-1b",
              "Rocketknight1/tiny-random-falcon-7b",
              "Rocketknight1/tiny-random-falcon-40b",
          ]:
              SCREAMING_SNAKE_CASE_									=						AutoTokenizer.from_pretrained(_A)
              SCREAMING_SNAKE_CASE_									=						FalconForCausalLM.from_pretrained(_A)
              model.eval()
              model.to(device=_A)
              SCREAMING_SNAKE_CASE_									=						tokenizer('My favorite food is'						,		return_tensors='pt').to(_A)

              # Test results are the same with and without cache
              SCREAMING_SNAKE_CASE_									=						model.generate(**_A						,		do_sample=_A						,		max_new_tokens=20						,		use_cache=_A)
              SCREAMING_SNAKE_CASE_									=						model.generate(**_A						,		do_sample=_A						,		max_new_tokens=20						,		use_cache=_A)
              self.assertTrue((outputs_cache - outputs_no_cache).sum().item() == 0)





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

  def __init__(					self						,		_A						,		_A=99						,		_A=13						,		_A=16						,		_A=7						,		_A=True						,		_A=True						,		_A=True						,		_A=False						,		_A=True						,		_A=2						,		_A=32						,		_A=4						,		_A=4						,		_A=30						,		_A=0						,		_A=1						,		_A=2						,		_A=None						,		):
      SCREAMING_SNAKE_CASE_									=						parent
      SCREAMING_SNAKE_CASE_									=						batch_size
      SCREAMING_SNAKE_CASE_									=						decoder_seq_length
      # For common tests
      SCREAMING_SNAKE_CASE_									=						self.decoder_seq_length
      SCREAMING_SNAKE_CASE_									=						is_training
      SCREAMING_SNAKE_CASE_									=						use_attention_mask
      SCREAMING_SNAKE_CASE_									=						use_labels

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

      SCREAMING_SNAKE_CASE_									=						None
      SCREAMING_SNAKE_CASE_									=						decoder_seq_length
      SCREAMING_SNAKE_CASE_									=						2
      SCREAMING_SNAKE_CASE_									=						1

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						ids_tensor([self.batch_size, self.decoder_seq_length]						,		self.vocab_size)

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

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

      SCREAMING_SNAKE_CASE_									=						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 						lowerCAmelCase__     (					self						,		_A						,		_A						,		_A						,		_A						,		):
      SCREAMING_SNAKE_CASE_									=						True
      SCREAMING_SNAKE_CASE_									=						TrOCRDecoder(config=_A).to(_A).eval()
      SCREAMING_SNAKE_CASE_									=						input_ids[:2]

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

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

      SCREAMING_SNAKE_CASE_									=						outputs['past_key_values']

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

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

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

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

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


  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.prepare_config_and_inputs()
      SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_							,			SCREAMING_SNAKE_CASE_									=						config_and_inputs

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






@require_torch
class       __snake_case  (    lowerCAmelCase__     , lowerCAmelCase__     , lowerCAmelCase__     , unittest.TestCase       ):
  __lowerCAmelCase     :	Tuple						 =  (TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
  __lowerCAmelCase     :	Union[str, Any]						 =  (TrOCRForCausalLM,) if is_torch_available() else ()
  __lowerCAmelCase     :	str						 =  {'text-generation': TrOCRForCausalLM} if is_torch_available() else {}
  __lowerCAmelCase     :	Any						 =  True
  __lowerCAmelCase     :	str						 =  False

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						TrOCRStandaloneDecoderModelTester(self						,		is_training=_A)
      SCREAMING_SNAKE_CASE_									=						ConfigTester(self						,		config_class=_A)

  def 						lowerCAmelCase__     (					self):
      pass

  def 						lowerCAmelCase__     (					self):
      pass

  def 						lowerCAmelCase__     (					self):
      pass

  def 						lowerCAmelCase__     (					self):
      self.config_tester.run_common_tests()

  def 						lowerCAmelCase__     (					self):
      SCREAMING_SNAKE_CASE_									=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_decoder_model_past(*_A)

  def 						lowerCAmelCase__     (					self):
      return


  @unittest.skip('The model doesn\'t support left padding')  # and it's not used enough to be worth fixing :)
  def 						lowerCAmelCase__     (					self):
      pass


