"""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 						__UpperCAmelCase    :







			'''simple docstring'''





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







										'''simple docstring'''


										A__       :     Any								=			parent
										A__       :     Union[str, Any]								=			batch_size
										A__       :     Dict								=			decoder_seq_length
										# For common tests
										A__       :     List[Any]								=			self.decoder_seq_length
										A__       :     Tuple								=			is_training
										A__       :     Optional[Any]								=			use_attention_mask
										A__       :     Tuple								=			use_labels

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

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





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			ids_tensor([self.batch_size, self.decoder_seq_length]   ,      self.vocab_size							)

										A__       :     Dict								=			None
										if self.use_attention_mask:
																	A__       :     List[str]								=			ids_tensor([self.batch_size, self.decoder_seq_length]   ,      vocab_size=2							)

										A__       :     List[str]								=			None
										if self.use_labels:
																	A__       :     Tuple								=			ids_tensor([self.batch_size, self.decoder_seq_length]   ,      self.vocab_size							)

										A__       :     Tuple								=			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   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      snake_case_   ,      ):







										'''simple docstring'''


										A__       :     List[str]								=			True
										A__       :     Dict								=			TrOCRDecoder(config=snake_case_							).to(snake_case_							).eval()
										A__       :     int								=			input_ids[:2]

										input_ids[input_ids == 0] += 1
										# first forward pass
										A__       :     Dict								=			model(snake_case_   ,      use_cache=snake_case_							)
										A__       :     List[Any]								=			model(snake_case_							)
										A__       :     List[Any]								=			model(snake_case_   ,      use_cache=snake_case_							)

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

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

										# create hypothetical next token and extent to next_input_ids
										A__       :     Union[str, Any]								=			ids_tensor((2, 1)   ,      config.vocab_size - 1							) + 1

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

										A__       :     Optional[Any]								=			model(snake_case_							)["""last_hidden_state"""]
										A__       :     Tuple								=			model(snake_case_   ,      past_key_values=snake_case_							)["""last_hidden_state"""]

										# select random slice
										A__       :     str								=			ids_tensor((1,)   ,      output_from_past.shape[-1]							).item()
										A__       :     Optional[int]								=			output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
										A__       :     Optional[Any]								=			output_from_past[:, 0, random_slice_idx].detach()

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





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Optional[int]								=			self.prepare_config_and_inputs()
										A__				,							A__				,							A__				,							A__       :     Optional[int]								=			config_and_inputs

										A__       :     Any								=			{"""input_ids""": input_ids, """attention_mask""": attention_mask}
										return config, inputs_dict





@require_torch
class 						__UpperCAmelCase    (__A							,   __A							,   __A							,   unittest.TestCase     ):







			'''simple docstring'''
			_UpperCamelCase  :						Union[str, Any]					     =				(TrOCRDecoder, TrOCRForCausalLM) if is_torch_available() else ()
			_UpperCamelCase  :						List[str]					     =				(TrOCRForCausalLM,) if is_torch_available() else ()
			_UpperCamelCase  :						str					     =				{'text-generation': TrOCRForCausalLM} if is_torch_available() else {}
			_UpperCamelCase  :						Optional[int]					     =				True
			_UpperCamelCase  :						List[str]					     =				False





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     List[Any]								=			TrOCRStandaloneDecoderModelTester(self   ,      is_training=snake_case_							)
										A__       :     str								=			ConfigTester(self   ,      config_class=snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										pass





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										pass





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										pass





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										self.config_tester.run_common_tests()





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Union[str, Any]								=			self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_decoder_model_past(*snake_case_							)





			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return





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







										'''simple docstring'''


										pass






"""simple docstring"""



from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast
from ...utils import logging


_UpperCamelCase								=		logging.get_logger(__name__)

_UpperCamelCase								=		{
    "EleutherAI/gpt-neo-1.3B": "https://huggingface.co/EleutherAI/gpt-neo-1.3B/resolve/main/config.json",
    # See all GPTNeo models at https://huggingface.co/models?filter=gpt_neo
}
class 						__UpperCAmelCase    (__A     ):







			'''simple docstring'''
			_UpperCamelCase  :						Tuple					     =				'gpt_neo'
			_UpperCamelCase  :						Optional[Any]					     =				['past_key_values']
			_UpperCamelCase  :						int					     =				{'num_attention_heads': 'num_heads', 'num_hidden_layers': 'num_layers'}





			def __init__(			self   ,      snake_case_=50_257   ,      snake_case_=2_048   ,      snake_case_=2_048   ,      snake_case_=24   ,      snake_case_=[[["global", "local"], 12]]   ,      snake_case_=16   ,      snake_case_=None   ,      snake_case_=256   ,      snake_case_="gelu_new"   ,      snake_case_=0.0   ,      snake_case_=0.0   ,      snake_case_=0.0   ,      snake_case_=0.1   ,      snake_case_=1E-5   ,      snake_case_=0.02   ,      snake_case_=True   ,      snake_case_=50_256   ,      snake_case_=50_256   ,      **snake_case_   ,      ):







										'''simple docstring'''


										A__       :     int								=			vocab_size
										A__       :     Optional[Any]								=			max_position_embeddings
										A__       :     int								=			hidden_size
										A__       :     List[Any]								=			num_layers
										A__       :     Any								=			num_heads
										A__       :     List[str]								=			intermediate_size
										A__       :     Dict								=			window_size
										A__       :     Optional[int]								=			activation_function
										A__       :     Optional[int]								=			resid_dropout
										A__       :     List[str]								=			embed_dropout
										A__       :     str								=			attention_dropout
										A__       :     List[str]								=			classifier_dropout
										A__       :     str								=			layer_norm_epsilon
										A__       :     str								=			initializer_range
										A__       :     Any								=			use_cache

										A__       :     List[str]								=			bos_token_id
										A__       :     Any								=			eos_token_id

										A__       :     Optional[Any]								=			attention_types
										A__       :     List[Any]								=			self.expand_attention_types_params(snake_case_							)

										if len(self.attention_layers							) != self.num_layers:
																	raise ValueError(
																	    """Configuration for convolutional module is incorrect. """
																	    """It is required that `len(config.attention_layers)` == `config.num_layers` """
																	    F'''but is `len(config.attention_layers) = {len(self.attention_layers							)}`, '''
																	    F'''`config.num_layers = {self.num_layers}`. '''
																	    """`config.attention_layers` is prepared using `config.attention_types`. """
																	    """Please verify the value of `config.attention_types` argument."""							)

										super().__init__(bos_token_id=snake_case_   ,      eos_token_id=snake_case_   ,      **snake_case_							)





			@staticmethod
			def 		lowerCamelCase					(			snake_case_							):







										'''simple docstring'''


										A__       :     Optional[Any]								=			[]
										for item in attention_types:
																	for _ in range(item[1]							):
																								attentions.extend(item[0]							)
										return attentions





def  _A(		lowerCAmelCase			,  lowerCAmelCase			,  lowerCAmelCase			,  lowerCAmelCase							):
							import torch

							A__       :     Union[str, Any]								=			input.size()
							A__       :     str								=			len(lowerCAmelCase							)
							A__       :     Union[str, Any]								=			shape[dimension]

							A__       :     Dict								=			torch.arange(0			,  lowerCAmelCase			,  lowerCAmelCase							)
							A__       :     Dict								=			torch.div(sizedim - size			,  lowerCAmelCase			,  rounding_mode="""floor"""							) + 1
							A__       :     str								=			torch.arange(lowerCAmelCase							) + low_indices[:min_length][:, None]

							A__       :     str								=			[slice(lowerCAmelCase							)] * rank
							A__       :     Optional[Any]								=			indices
							A__       :     Tuple								=			input[s]

							A__       :     List[str]								=			list(range(0			,  rank + 1							)							)
							perm.append(perm.pop(dimension + 1							)							)

							return sliced.permute(lowerCAmelCase							)

def  _A(		lowerCAmelCase			,  lowerCAmelCase							):
							import torch

							A__       :     Optional[Any]								=			torch.arange(1			,  lowerCAmelCase							)
							A__       :     int								=			torch.remainder(lowerCAmelCase			,  lowerCAmelCase							)
							A__       :     str								=			remainders == 0
							A__       :     Tuple								=			candidates[divisor_indices]
							A__       :     Any								=			torch.max(lowerCAmelCase							)
							return largest_divisor, torch.div(lowerCAmelCase			,  lowerCAmelCase			,  rounding_mode="""floor"""							)



class 						__UpperCAmelCase    (__A     ):







			'''simple docstring'''





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										A__       :     Any								=			OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}}							)
										if self.use_past:
																	self.fill_with_past_key_values_(snake_case_   ,      direction="""inputs"""							)
																	A__       :     str								=			{0: """batch""", 1: """past_sequence + sequence"""}
										else:
																	A__       :     Optional[Any]								=			{0: """batch""", 1: """sequence"""}

										return common_inputs





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return self._config.num_heads





			def 		lowerCamelCase					(			self   ,      snake_case_   ,      snake_case_ = -1   ,      snake_case_ = -1   ,      snake_case_ = False   ,      snake_case_ = None   ,      ):







										'''simple docstring'''


										A__       :     Optional[int]								=			super(snake_case_   ,      self							).generate_dummy_inputs(
										    snake_case_   ,      batch_size=snake_case_   ,      seq_length=snake_case_   ,      is_pair=snake_case_   ,      framework=snake_case_							)

										# We need to order the input in the way they appears in the forward()
										A__       :     List[Any]								=			OrderedDict({"""input_ids""": common_inputs["""input_ids"""]}							)

										# Need to add the past_keys
										if self.use_past:
																	if not is_torch_available():
																								raise ValueError("""Cannot generate dummy past_keys inputs without PyTorch installed."""							)
																	else:
																								import torch

																								A__				,							A__       :     Dict								=			common_inputs["""input_ids"""].shape
																								# Not using the same length for past_key_values
																								A__       :     Any								=			seqlen + 2
																								A__       :     Any								=			(
																								    batch,
																								    self.num_attention_heads,
																								    past_key_values_length,
																								    self._config.hidden_size // self.num_attention_heads,
																								)
																								A__       :     List[Any]								=			[
																								    (torch.zeros(snake_case_							), torch.zeros(snake_case_							)) for _ in range(self.num_layers							)
																								]

										A__       :     Tuple								=			common_inputs["""attention_mask"""]
										if self.use_past:
																	A__       :     List[Any]								=			ordered_inputs["""attention_mask"""].dtype
																	A__       :     Optional[Any]								=			torch.cat(
																	    [ordered_inputs["""attention_mask"""], torch.ones(snake_case_   ,      snake_case_   ,      dtype=snake_case_							)]   ,      dim=1							)

										return ordered_inputs





			@property
			def 		lowerCamelCase					(			self							):







										'''simple docstring'''


										return 13





