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

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


_snake_case      :							str     	=    logging.get_logger(__name__)

_snake_case      :							Optional[int]     	=    {
    "EleutherAI/gpt-j-6B": "https://huggingface.co/EleutherAI/gpt-j-6B/resolve/main/config.json",
    # See all GPT-J models at https://huggingface.co/models?filter=gpt_j
}





class   UpperCamelCase_      (      _a		):







						'''simple docstring'''



						UpperCamelCase      :  Tuple				   =					"""gptj"""
						UpperCamelCase      :  Union[str, Any]				   =					{
						    """max_position_embeddings""": """n_positions""",
						    """hidden_size""": """n_embd""",
						    """num_attention_heads""": """n_head""",
						    """num_hidden_layers""": """n_layer""",
						}





						def __init__(			self							:int		,    lowerCAmelCase__							:Optional[int]=50400		,    lowerCAmelCase__							:Optional[Any]=2048		,    lowerCAmelCase__							:Optional[Any]=4096		,    lowerCAmelCase__							:Any=28		,    lowerCAmelCase__							:Union[str, Any]=16		,    lowerCAmelCase__							:int=64		,    lowerCAmelCase__							:int=None		,    lowerCAmelCase__							:str="gelu_new"		,    lowerCAmelCase__							:str=0.0		,    lowerCAmelCase__							:Optional[Any]=0.0		,    lowerCAmelCase__							:Dict=0.0		,    lowerCAmelCase__							:Dict=1E-5		,    lowerCAmelCase__							:Optional[int]=0.02		,    lowerCAmelCase__							:List[str]=True		,    lowerCAmelCase__							:List[Any]=50256		,    lowerCAmelCase__							:Optional[int]=50256		,    lowerCAmelCase__							:List[Any]=False		,    **lowerCAmelCase__							:int		,    )  ->Dict:
										lowercase         =      vocab_size
										lowercase         =      n_positions
										lowercase         =      n_embd
										lowercase         =      n_layer
										lowercase         =      n_head
										lowercase         =      n_inner
										lowercase         =      rotary_dim
										lowercase         =      activation_function
										lowercase         =      resid_pdrop
										lowercase         =      embd_pdrop
										lowercase         =      attn_pdrop
										lowercase         =      layer_norm_epsilon
										lowercase         =      initializer_range
										lowercase         =      use_cache

										lowercase         =      bos_token_id
										lowercase         =      eos_token_id

										super().__init__(
										    bos_token_id=A_		,    eos_token_id=A_		,    tie_word_embeddings=A_		,    **A_     )





class   UpperCamelCase_      (      _a		):







						'''simple docstring'''



						def __init__(			self							:int		,    lowerCAmelCase__							:PretrainedConfig		,    lowerCAmelCase__							:str = "default"		,    lowerCAmelCase__							:List[PatchingSpec] = None		,    lowerCAmelCase__							:bool = False		,    )  ->str:
										super().__init__(A_		,    task=A_		,    patching_specs=A_		,    use_past=A_     )
										if not getattr(self._config		,    "pad_token_id"		,    A_     ):
														# TODO: how to do that better?
														lowercase         =      0





						@property
						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]     )  ->str:
										lowercase         =      OrderedDict({"input_ids": {0: "batch", 1: "sequence"}}     )
										if self.use_past:
														self.fill_with_past_key_values_(A_		,    direction="inputs"     )
														lowercase         =      {0: "batch", 1: "past_sequence + sequence"}
										else:
														lowercase         =      {0: "batch", 1: "sequence"}

										return common_inputs





						@property
						def        SCREAMING_SNAKE_CASE(			self							:List[str]     )  ->List[str]:
										return self._config.n_layer





						@property
						def        SCREAMING_SNAKE_CASE(			self							:Optional[int]     )  ->Optional[int]:
										return self._config.n_head





						def        SCREAMING_SNAKE_CASE(			self							:Optional[Any]		,    lowerCAmelCase__							:PreTrainedTokenizer		,    lowerCAmelCase__							:int = -1		,    lowerCAmelCase__							:int = -1		,    lowerCAmelCase__							:bool = False		,    lowerCAmelCase__							:Optional[TensorType] = None		,    )  ->int:
										lowercase         =      super(A_		,    self     ).generate_dummy_inputs(
										    A_		,    batch_size=A_		,    seq_length=A_		,    is_pair=A_		,    framework=A_     )

										# We need to order the input in the way they appears in the forward()
										lowercase         =      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

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

										lowercase         =      common_inputs["attention_mask"]
										if self.use_past:
														lowercase         =      ordered_inputs["attention_mask"].dtype
														lowercase         =      torch.cat(
														    [ordered_inputs["attention_mask"], torch.ones(A_		,    A_		,    dtype=A_     )]		,    dim=1     )

										return ordered_inputs





						@property
						def        SCREAMING_SNAKE_CASE(			self							:List[Any]     )  ->List[str]:
										return 13




"""simple docstring"""

import copy
from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


if TYPE_CHECKING:
       from ... import PreTrainedTokenizerBase, TensorType

UpperCAmelCase__					=logging.get_logger(__name__)





class  lowerCamelCase__    (		_a     ):
      a			:  Optional[int]           =		"""vision-encoder-decoder"""
      a			:  Dict           =		True
      def __init__(		self						:						Dict   ,							**A_						:						List[Any]				):






       '''simple docstring'''


       super().__init__(**A_				)
       if "encoder" not in kwargs or "decoder" not in kwargs:
        raise ValueError(
            F'''A configuraton of type {self.model_type} cannot be instantiated because '''
            F'''not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}'''				)

       __lowercase						=						kwargs.pop("""encoder"""				)
       __lowercase						=						encoder_config.pop("""model_type"""				)
       __lowercase						=						kwargs.pop("""decoder"""				)
       __lowercase						=						decoder_config.pop("""model_type"""				)

       __lowercase						=						AutoConfig.for_model(A_   ,							**A_				)
       __lowercase						=						AutoConfig.for_model(A_   ,							**A_				)
       __lowercase						=						True
      @classmethod
      def SCREAMING_SNAKE_CASE_						(		cls						:						int   ,							A_						:						PretrainedConfig   ,							A_						:						PretrainedConfig   ,							**A_						:						Any				):






       '''simple docstring'''


       logger.info("""Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config"""				)
       __lowercase						=						True
       __lowercase						=						True

       return cls(encoder=encoder_config.to_dict()   ,							decoder=decoder_config.to_dict()   ,							**A_				)






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






       '''simple docstring'''


       __lowercase						=						copy.deepcopy(self.__dict__				)
       __lowercase						=						self.encoder.to_dict()
       __lowercase						=						self.decoder.to_dict()
       __lowercase						=						self.__class__.model_type
       return output






class  lowerCamelCase__    (		_a     ):
      a			:  Dict           =		version.parse("""1.11"""     )
      @property
      def SCREAMING_SNAKE_CASE_						(		self						:						Optional[int]				):






       '''simple docstring'''


       return OrderedDict(
           [
               ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
           ]				)
      @property
      def SCREAMING_SNAKE_CASE_						(		self						:						Tuple				):






       '''simple docstring'''


       return 1e-4






      @property
      def SCREAMING_SNAKE_CASE_						(		self						:						Any				):






       '''simple docstring'''


       return OrderedDict({"""last_hidden_state""": {0: """batch""", 1: """encoder_sequence"""}}				)






class  lowerCamelCase__    (		_a     ):
      @property
      def SCREAMING_SNAKE_CASE_						(		self						:						Dict				):






       '''simple docstring'''


       __lowercase						=						OrderedDict()
       __lowercase						=						{0: """batch""", 1: """past_decoder_sequence + sequence"""}
       __lowercase						=						{0: """batch""", 1: """past_decoder_sequence + sequence"""}
       __lowercase						=						{0: """batch""", 1: """encoder_sequence"""}

       return common_inputs






      def SCREAMING_SNAKE_CASE_						(		self						:						str   ,							A_						:						"PreTrainedTokenizerBase"   ,							A_						:						int = -1   ,							A_						:						int = -1   ,							A_						:						bool = False   ,							A_						:						Optional["TensorType"] = None   ,							):






       '''simple docstring'''


       import torch

       __lowercase						=						OrderedDict()

       __lowercase						=						super().generate_dummy_inputs(
           A_   ,							batch_size=A_   ,							seq_length=A_   ,							is_pair=A_   ,							framework=A_				)

       __lowercase				,		__lowercase						=						dummy_input["""input_ids"""].shape
       __lowercase						=						(batch, encoder_sequence, self._config.encoder_hidden_size)
       __lowercase						=						dummy_input.pop("""input_ids"""				)
       __lowercase						=						dummy_input.pop("""attention_mask"""				)
       __lowercase						=						torch.zeros(A_				)

       return common_inputs






class  lowerCamelCase__    (		_a     ):
      @property
      def SCREAMING_SNAKE_CASE_						(		self						:						str				):






       '''simple docstring'''


       pass
      def SCREAMING_SNAKE_CASE_						(		self						:						str   ,							A_						:						PretrainedConfig				):






       '''simple docstring'''


       return VisionEncoderDecoderEncoderOnnxConfig(A_				)






      def SCREAMING_SNAKE_CASE_						(		self						:						Tuple   ,							A_						:						PretrainedConfig   ,							A_						:						PretrainedConfig   ,							A_						:						str = "default"				):






       '''simple docstring'''


       __lowercase						=						encoder_config.hidden_size
       return VisionEncoderDecoderDecoderOnnxConfig(A_   ,							A_				)
