



import gc
import importlib.metadata
import tempfile
import unittest

from packaging import version

from transformers import (
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForSeqaSeqLM,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    BitsAndBytesConfig,
    pipeline,
)
from transformers.testing_utils import (
    is_torch_available,
    require_accelerate,
    require_bitsandbytes,
    require_torch,
    require_torch_gpu,
    require_torch_multi_gpu,
    slow,
)






def 	lowerCAmelCase__		(    lowerCamelCase_		:		Any):





				'''simple docstring'''

				if model.config.model_type == "gpt2":
								return model.transformer.h[0].mlp.c_fc
				return model.transformer.h[0].mlp.dense_ah_to_h


if is_torch_available():
							import torch
							import torch.nn as nn



							class        lowerCamelCase__			(							nn.Module):




									'''simple docstring'''



									def __init__(self		,__lowerCamelCase		,__lowerCamelCase )     ->			List[Any]:

													"""simple docstring"""






													super().__init__()
													lowerCAmelCase__     :				Optional[Any]												=     module
													lowerCAmelCase__     :				List[Any]												=     nn.Sequential(
													    nn.Linear(module.in_features		,__lowerCamelCase		,bias=__lowerCamelCase )		,nn.Linear(__lowerCamelCase		,module.out_features		,bias=__lowerCamelCase )		,)
													lowerCAmelCase__     :				Union[str, Any]												=     (2.0 / (5 * min(module.in_features		,module.out_features ))) ** 0.5
													nn.init.normal_(self.adapter[0].weight		,std=__lowerCamelCase )
													nn.init.zeros_(self.adapter[1].weight )
													self.adapter.to(module.weight.device )



									def 		lowerCAmelCase__      (self		,__lowerCamelCase		,*__lowerCamelCase		,**__lowerCamelCase )     ->			Tuple:

													"""simple docstring"""






													return self.module(__lowerCamelCase		,*__lowerCamelCase		,**__lowerCamelCase ) + self.adapter(__lowerCamelCase )



@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class        lowerCamelCase__			(							unittest.TestCase):




		'''simple docstring'''



		snake_case_	="""bigscience/bloom-1b7"""

		# Constant values
		snake_case_	=2.1_09_65_95_52_69_25_74

		snake_case_	="""Hello my name is"""
		snake_case_	=set()
		EXPECTED_OUTPUTS.add("""Hello my name is John and I am a professional photographer. I""")
		EXPECTED_OUTPUTS.add("""Hello my name is John.\nI am a friend of your father.\n""")
		EXPECTED_OUTPUTS.add("""Hello my name is John Doe, I am a student at the University""")
		snake_case_	=10



		def 		lowerCAmelCase__      (self )     ->			Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__     :				int												=     AutoTokenizer.from_pretrained(self.model_name )



class        lowerCamelCase__			(							lowercase_):




		'''simple docstring'''



		def 		lowerCAmelCase__      (self )     ->			Dict:

						"""simple docstring"""






						super().setUp()

						# Models and tokenizer
						lowerCAmelCase__     :				List[Any]												=     AutoModelForCausalLM.from_pretrained(
						    self.model_name		,torch_dtype=torch.floataa		,device_map='''auto''' )
						lowerCAmelCase__     :				int												=     AutoModelForCausalLM.from_pretrained(self.model_name		,load_in_abit=__lowerCamelCase		,device_map='''auto''' )



		def 		lowerCAmelCase__      (self )     ->			str:

						"""simple docstring"""






						del self.model_fpaa
						del self.model_abit

						gc.collect()
						torch.cuda.empty_cache()



		def 		lowerCAmelCase__      (self )     ->			Optional[Any]:

						"""simple docstring"""






						lowerCAmelCase__     :				Dict												=     self.model_abit.config

						self.assertTrue(hasattr(__lowerCamelCase		,'''quantization_config''' ) )

						lowerCAmelCase__     :				Union[str, Any]												=     config.to_dict()
						lowerCAmelCase__     :				Optional[Any]												=     config.to_diff_dict()

						lowerCAmelCase__     :				Any												=     config.to_json_string()



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

						"""simple docstring"""






						from bitsandbytes.nn import Paramsabit

						lowerCAmelCase__     :				Any												=     self.model_fpaa.get_memory_footprint()
						lowerCAmelCase__     :				Tuple												=     self.model_abit.get_memory_footprint()

						self.assertAlmostEqual(mem_fpaa / mem_abit		,self.EXPECTED_RELATIVE_DIFFERENCE )
						lowerCAmelCase__     :				List[Any]												=     get_some_linear_layer(self.model_abit )
						self.assertTrue(linear.weight.__class__ == Paramsabit )



		def 		lowerCAmelCase__      (self )     ->			Optional[Any]:

						"""simple docstring"""






						from transformers import TaPreTrainedModel

						self.model_fpaa.get_memory_footprint()
						self.model_abit.get_memory_footprint()

						for name, module in self.model_abit.named_modules():
										if isinstance(__lowerCamelCase		,torch.nn.Linear ):
														if name not in ["lm_head"] + TaPreTrainedModel._keep_in_fpaa_modules:
																		# 4-bit parameters are packed in uint8 variables
																		self.assertTrue(module.weight.dtype == torch.uinta )



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

						"""simple docstring"""






						lowerCAmelCase__     :				int												=     self.tokenizer(self.input_text		,return_tensors='''pt''' )
						lowerCAmelCase__     :				Tuple												=     self.model_abit.generate(input_ids=encoded_input['''input_ids'''].to(0 )		,max_new_tokens=10 )

						self.assertIn(self.tokenizer.decode(output_sequences[0]		,skip_special_tokens=__lowerCamelCase )		,self.EXPECTED_OUTPUTS )



		def 		lowerCAmelCase__      (self )     ->			str:

						"""simple docstring"""






						lowerCAmelCase__     :				List[str]												=     BitsAndBytesConfig()
						lowerCAmelCase__     :				Tuple												=     True

						lowerCAmelCase__     :				int												=     AutoModelForCausalLM.from_pretrained(
						    self.model_name		,quantization_config=__lowerCamelCase		,device_map='''auto''' )

						lowerCAmelCase__     :				int												=     self.tokenizer(self.input_text		,return_tensors='''pt''' )
						lowerCAmelCase__     :				Optional[int]												=     model_abit_from_config.generate(
						    input_ids=encoded_input['''input_ids'''].to(0 )		,max_new_tokens=10 )

						self.assertIn(self.tokenizer.decode(output_sequences[0]		,skip_special_tokens=__lowerCamelCase )		,self.EXPECTED_OUTPUTS )



		def 		lowerCAmelCase__      (self )     ->			str:

						"""simple docstring"""






						with self.assertRaises(__lowerCamelCase ), tempfile.TemporaryDirectory() as tmpdirname:
										self.model_abit.save_pretrained(__lowerCamelCase )



		def 		lowerCAmelCase__      (self )     ->			Tuple:

						"""simple docstring"""






						lowerCAmelCase__     :				str												=     BitsAndBytesConfig()

						with self.assertRaises(__lowerCamelCase ):
										lowerCAmelCase__     :				Optional[int]												=     AutoModelForCausalLM.from_pretrained(
										    self.model_name		,quantization_config=__lowerCamelCase		,load_in_abit=__lowerCamelCase		,device_map='''auto'''		,bnb_abit_quant_type='''nf4'''		,)



		def 		lowerCAmelCase__      (self )     ->			Union[str, Any]:

						"""simple docstring"""






						with self.assertRaises(__lowerCamelCase ):
										# Tries with `str`
										self.model_abit.to('''cpu''' )

						with self.assertRaises(__lowerCamelCase ):
										# Tries with a `dtype``
										self.model_abit.to(torch.floataa )

						with self.assertRaises(__lowerCamelCase ):
										# Tries with a `device`
										self.model_abit.to(torch.device('''cuda:0''' ) )

						with self.assertRaises(__lowerCamelCase ):
										# Tries with a `device`
										self.model_abit.float()

						with self.assertRaises(__lowerCamelCase ):
										# Tries with a `device`
										self.model_abit.half()

						# Test if we did not break anything
						lowerCAmelCase__     :				Optional[Any]												=     self.tokenizer(self.input_text		,return_tensors='''pt''' )

						lowerCAmelCase__     :				Any												=     self.model_fpaa.to(torch.floataa )
						lowerCAmelCase__     :				Optional[Any]												=     self.model_fpaa.generate(input_ids=encoded_input['''input_ids'''].to(0 )		,max_new_tokens=10 )

						# Check this does not throw an error
						lowerCAmelCase__     :				List[Any]												=     self.model_fpaa.to('''cpu''' )

						# Check this does not throw an error
						lowerCAmelCase__     :				Any												=     self.model_fpaa.half()

						# Check this does not throw an error
						lowerCAmelCase__     :				Optional[Any]												=     self.model_fpaa.float()



		def 		lowerCAmelCase__      (self )     ->			Dict:

						"""simple docstring"""






						lowerCAmelCase__     :				Union[str, Any]												=     AutoModelForSeqaSeqLM.from_pretrained('''t5-small'''		,load_in_abit=__lowerCamelCase		,device_map='''auto''' )
						self.assertTrue(model.decoder.block[0].layer[2].DenseReluDense.wo.weight.dtype == torch.floataa )



@require_bitsandbytes
@require_accelerate
@require_torch
@require_torch_gpu
@slow
class        lowerCamelCase__			(							unittest.TestCase):




		'''simple docstring'''



		@classmethod
		def 		lowerCAmelCase__      (cls )     ->			List[str]:

						"""simple docstring"""






						lowerCAmelCase__     :				str												=     '''t5-small'''
						lowerCAmelCase__     :				Dict												=     '''google/flan-t5-small'''  # flan-t5 uses dense-act instead of dense-relu-dense
						lowerCAmelCase__     :				Dict												=     AutoTokenizer.from_pretrained(cls.model_name )
						lowerCAmelCase__     :				List[Any]												=     '''Translate in German: Hello, my dog is cute'''



		def 		lowerCAmelCase__      (self )     ->			Any:

						"""simple docstring"""






						gc.collect()
						torch.cuda.empty_cache()



		def 		lowerCAmelCase__      (self )     ->			Any:

						"""simple docstring"""






						from transformers import TaForConditionalGeneration

						lowerCAmelCase__     :				Dict												=     TaForConditionalGeneration._keep_in_fpaa_modules
						lowerCAmelCase__     :				Optional[int]												=     None

						# test with `t5-small`
						lowerCAmelCase__     :				Optional[int]												=     TaForConditionalGeneration.from_pretrained(self.model_name		,load_in_abit=__lowerCamelCase		,device_map='''auto''' )
						lowerCAmelCase__     :				Optional[int]												=     self.tokenizer(self.input_text		,return_tensors='''pt''' ).to(0 )
						lowerCAmelCase__     :				Optional[Any]												=     model.generate(**__lowerCamelCase )

						# test with `flan-t5-small`
						lowerCAmelCase__     :				Tuple												=     TaForConditionalGeneration.from_pretrained(
						    self.dense_act_model_name		,load_in_abit=__lowerCamelCase		,device_map='''auto''' )
						lowerCAmelCase__     :				List[str]												=     self.tokenizer(self.input_text		,return_tensors='''pt''' ).to(0 )
						lowerCAmelCase__     :				Tuple												=     model.generate(**__lowerCamelCase )
						lowerCAmelCase__     :				Tuple												=     modules



		def 		lowerCAmelCase__      (self )     ->			int:

						"""simple docstring"""






						import bitsandbytes as bnb

						from transformers import TaForConditionalGeneration

						# test with `t5-small`
						lowerCAmelCase__     :				Optional[int]												=     TaForConditionalGeneration.from_pretrained(self.model_name		,load_in_abit=__lowerCamelCase		,device_map='''auto''' )

						# there was a bug with decoders - this test checks that it is fixed
						self.assertTrue(isinstance(model.decoder.block[0].layer[0].SelfAttention.q		,bnb.nn.Linearabit ) )

						lowerCAmelCase__     :				Dict												=     self.tokenizer(self.input_text		,return_tensors='''pt''' ).to(0 )
						lowerCAmelCase__     :				int												=     model.generate(**__lowerCamelCase )

						# test with `flan-t5-small`
						lowerCAmelCase__     :				Dict												=     TaForConditionalGeneration.from_pretrained(
						    self.dense_act_model_name		,load_in_abit=__lowerCamelCase		,device_map='''auto''' )
						lowerCAmelCase__     :				int												=     self.tokenizer(self.input_text		,return_tensors='''pt''' ).to(0 )
						lowerCAmelCase__     :				Dict												=     model.generate(**__lowerCamelCase )



class        lowerCamelCase__			(							lowercase_):




		'''simple docstring'''



		def 		lowerCAmelCase__      (self )     ->			int:

						"""simple docstring"""






						super().setUp()
						# model_name
						lowerCAmelCase__     :				str												=     '''bigscience/bloom-560m'''
						lowerCAmelCase__     :				Optional[Any]												=     '''t5-small'''

						# Different types of model

						lowerCAmelCase__     :				Union[str, Any]												=     AutoModel.from_pretrained(self.model_name		,load_in_abit=__lowerCamelCase		,device_map='''auto''' )
						# Sequence classification model
						lowerCAmelCase__     :				Union[str, Any]												=     AutoModelForSequenceClassification.from_pretrained(
						    self.model_name		,load_in_abit=__lowerCamelCase		,device_map='''auto''' )
						# CausalLM model
						lowerCAmelCase__     :				Optional[Any]												=     AutoModelForCausalLM.from_pretrained(self.model_name		,load_in_abit=__lowerCamelCase		,device_map='''auto''' )
						# Seq2seq model
						lowerCAmelCase__     :				Optional[Any]												=     AutoModelForSeqaSeqLM.from_pretrained(
						    self.seq_to_seq_name		,load_in_abit=__lowerCamelCase		,device_map='''auto''' )



		def 		lowerCAmelCase__      (self )     ->			str:

						"""simple docstring"""






						del self.base_model
						del self.sequence_model
						del self.model_abit
						del self.seq_to_seq_model

						gc.collect()
						torch.cuda.empty_cache()



		def 		lowerCAmelCase__      (self )     ->			int:

						"""simple docstring"""






						from bitsandbytes.nn import Paramsabit

						self.assertTrue(self.base_model.h[-1].mlp.dense_ah_to_h.weight.__class__ == Paramsabit )

						# Other heads should be nn.Parameter
						self.assertTrue(self.model_abit.lm_head.weight.__class__ == torch.nn.Parameter )
						self.assertTrue(self.sequence_model.score.weight.__class__ == torch.nn.Parameter )
						self.assertTrue(self.seq_to_seq_model.lm_head.weight.__class__ == torch.nn.Parameter )



class        lowerCamelCase__			(							lowercase_):




		'''simple docstring'''



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

						"""simple docstring"""






						super().setUp()



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

						"""simple docstring"""






						del self.pipe

						gc.collect()
						torch.cuda.empty_cache()



		def 		lowerCAmelCase__      (self )     ->			str:

						"""simple docstring"""






						lowerCAmelCase__     :				Union[str, Any]												=     pipeline(
						    '''text-generation'''		,model=self.model_name		,model_kwargs={'''device_map''': '''auto''', '''load_in_4bit''': True, '''torch_dtype''': torch.floataa}		,max_new_tokens=self.MAX_NEW_TOKENS		,)

						# Real second forward pass
						lowerCAmelCase__     :				Any												=     self.pipe(self.input_text )
						self.assertIn(pipeline_output[0]['''generated_text''']		,self.EXPECTED_OUTPUTS )



@require_torch_multi_gpu
class        lowerCamelCase__			(							lowercase_):




		'''simple docstring'''



		def 		lowerCAmelCase__      (self )     ->			str:

						"""simple docstring"""






						super().setUp()



		def 		lowerCAmelCase__      (self )     ->			Union[str, Any]:

						"""simple docstring"""






						lowerCAmelCase__     :				Optional[Any]												=     AutoModelForCausalLM.from_pretrained(
						    self.model_name		,load_in_abit=__lowerCamelCase		,device_map='''balanced''' )

						# Check correct device map
						self.assertEqual(set(model_parallel.hf_device_map.values() )		,{0, 1} )

						# Check that inference pass works on the model
						lowerCAmelCase__     :				Union[str, Any]												=     self.tokenizer(self.input_text		,return_tensors='''pt''' )

						# Second real batch
						lowerCAmelCase__     :				Union[str, Any]												=     model_parallel.generate(input_ids=encoded_input['''input_ids'''].to(0 )		,max_new_tokens=10 )
						self.assertIn(self.tokenizer.decode(output_parallel[0]		,skip_special_tokens=__lowerCamelCase )		,self.EXPECTED_OUTPUTS )



class        lowerCamelCase__			(							lowercase_):




		'''simple docstring'''



		def 		lowerCAmelCase__      (self )     ->			str:

						"""simple docstring"""






						lowerCAmelCase__     :				Dict												=     '''facebook/opt-350m'''
						super().setUp()



		def 		lowerCAmelCase__      (self )     ->			Tuple:

						"""simple docstring"""






						if version.parse(importlib.metadata.version('''bitsandbytes''' ) ) < version.parse('''0.37.0''' ):
										return

						# Step 1: freeze all parameters
						lowerCAmelCase__     :				str												=     AutoModelForCausalLM.from_pretrained(self.model_name		,load_in_abit=__lowerCamelCase )

						self.assertEqual(set(model.hf_device_map.values() )		,{torch.cuda.current_device()} )

						for param in model.parameters():
										lowerCAmelCase__     :				Union[str, Any]												=     False  # freeze the model - train adapters later
										if param.ndim == 1:
														# cast the small parameters (e.g. layernorm) to fp32 for stability
														lowerCAmelCase__     :				int												=     param.data.to(torch.floataa )

        # Step 2: add adapters
						for _, module in model.named_modules():
										if "OPTAttention" in repr(type(__lowerCamelCase ) ):
														lowerCAmelCase__     :				str												=     LoRALayer(module.q_proj		,rank=16 )
														lowerCAmelCase__     :				Dict												=     LoRALayer(module.k_proj		,rank=16 )
														lowerCAmelCase__     :				Optional[Any]												=     LoRALayer(module.v_proj		,rank=16 )

        # Step 3: dummy batch
						lowerCAmelCase__     :				Dict												=     self.tokenizer('''Test batch '''		,return_tensors='''pt''' ).to(0 )

						# Step 4: Check if the gradient is not None
						with torch.cuda.amp.autocast():
										lowerCAmelCase__     :				Optional[Any]												=     model.forward(**__lowerCamelCase )
										out.logits.norm().backward()

						for module in model.modules():
										if isinstance(__lowerCamelCase		,__lowerCamelCase ):
														self.assertTrue(module.adapter[1].weight.grad is not None )
														self.assertTrue(module.adapter[1].weight.grad.norm().item() > 0 )
										elif isinstance(__lowerCamelCase		,nn.Embedding ):
														self.assertTrue(module.weight.grad is None )



class        lowerCamelCase__			(							lowercase_):




		'''simple docstring'''



		snake_case_	="""gpt2-xl"""
		snake_case_	=3.31_91_85_48_54_15_21_87





'''simple docstring'''

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





      '''simple docstring'''






      def __init__(self    :    str   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    Optional[int]=99   ,						UpperCamelCase    :    Optional[int]=13   ,						UpperCamelCase    :    Tuple=16   ,						UpperCamelCase    :    Union[str, Any]=7   ,						UpperCamelCase    :    List[Any]=True   ,						UpperCamelCase    :    List[str]=True   ,						UpperCamelCase    :    str=True   ,						UpperCamelCase    :    Tuple=False   ,						UpperCamelCase    :    str=True   ,						UpperCamelCase    :    Tuple=2   ,						UpperCamelCase    :    Optional[int]=32   ,						UpperCamelCase    :    Any=4   ,						UpperCamelCase    :    Optional[int]=4   ,						UpperCamelCase    :    Tuple=30   ,						UpperCamelCase    :    str=0   ,						UpperCamelCase    :    Tuple=1   ,						UpperCamelCase    :    List[Any]=2   ,						UpperCamelCase    :    str=None   ,						):

             '''simple docstring'''







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

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

             lowercase__      			= None
             lowercase__      			= decoder_seq_length
             lowercase__      			= 2
             lowercase__      			= 1



      def       UpperCamelCase__		(self    :    str ):

             '''simple docstring'''







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

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

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

             lowercase__      			= 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       UpperCamelCase__		(self    :    Tuple   ,						UpperCamelCase    :    List[Any]   ,						UpperCamelCase    :    Optional[Any]   ,						UpperCamelCase    :    Tuple   ,						UpperCamelCase    :    List[str]   ,						):

             '''simple docstring'''







             lowercase__      			= True
             lowercase__      			= TrOCRDecoder(config=UpperCamelCase ).to(UpperCamelCase ).eval()
             lowercase__      			= input_ids[:2]

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

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

             lowercase__      			= outputs['''past_key_values''']

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

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

             lowercase__      			= model(UpperCamelCase )['''last_hidden_state''']
             lowercase__      			= model(UpperCamelCase   ,						past_key_values=UpperCamelCase )['''last_hidden_state''']

             # select random slice
             lowercase__      			= ids_tensor((1,)   ,						output_from_past.shape[-1] ).item()
             lowercase__      			= output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
             lowercase__      			= 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    :    Optional[Any] ):

             '''simple docstring'''







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

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






@require_torch
class   __lowerCAmelCase						(lowercase_  ,     lowercase_  ,     lowercase_  ,     unittest.TestCase     ):





      '''simple docstring'''






      lowerCAmelCase__					:     List[str]  					=							(TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
      lowerCAmelCase__					:     List[Any]  					=							(TrOCRForCausalLM,) if is_torch_available() else ()
      lowerCAmelCase__					:     Optional[Any]  					=							{"""text-generation""": TrOCRForCausalLM} if is_torch_available() else {}
      lowerCAmelCase__					:     Optional[Any]  					=							True
      lowerCAmelCase__					:     List[str]  					=							False



      def       UpperCamelCase__		(self    :    Any ):

             '''simple docstring'''







             lowercase__      			= TrOCRStandaloneDecoderModelTester(self   ,						is_training=UpperCamelCase )
             lowercase__      			= ConfigTester(self   ,						config_class=UpperCamelCase )



      def       UpperCamelCase__		(self    :    List[str] ):

             '''simple docstring'''







             pass



      def       UpperCamelCase__		(self    :    Optional[int] ):

             '''simple docstring'''







             pass



      def       UpperCamelCase__		(self    :    Any ):

             '''simple docstring'''







             pass



      def       UpperCamelCase__		(self    :    Any ):

             '''simple docstring'''







             self.config_tester.run_common_tests()



      def       UpperCamelCase__		(self    :    Union[str, Any] ):

             '''simple docstring'''







             lowercase__      			= self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_decoder_model_past(*UpperCamelCase )



      def       UpperCamelCase__		(self    :    Optional[int] ):

             '''simple docstring'''







             return






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

             '''simple docstring'''







             pass




