





'''simple docstring'''






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

from packaging import version


if TYPE_CHECKING:
	from ... import PreTrainedTokenizer, TensorType

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


__UpperCamelCase					    =	logging.get_logger(__name__)

__UpperCamelCase					    =	{
    "bigscience/bloom": "https://huggingface.co/bigscience/bloom/resolve/main/config.json",
    "bigscience/bloom-560m": "https://huggingface.co/bigscience/bloom-560m/blob/main/config.json",
    "bigscience/bloom-1b1": "https://huggingface.co/bigscience/bloom-1b1/blob/main/config.json",
    "bigscience/bloom-1b7": "https://huggingface.co/bigscience/bloom-1b7/blob/main/config.json",
    "bigscience/bloom-3b": "https://huggingface.co/bigscience/bloom-3b/blob/main/config.json",
    "bigscience/bloom-7b1": "https://huggingface.co/bigscience/bloom-7b1/blob/main/config.json",
}




class  _A (					__lowercase		):
		lowercase__:   Any				     =   '''bloom'''
		lowercase__:   List[str]				     =   ['''past_key_values''']
		lowercase__:   Any				     =   {
		    '''num_hidden_layers''': '''n_layer''',
		    '''num_attention_heads''': '''n_head''',
		}

		def __init__(   self					:   str  ,      __magic_name__					:   str=25_08_80  ,      __magic_name__					:   Optional[Any]=64  ,      __magic_name__					:   Dict=2  ,      __magic_name__					:   Optional[int]=8  ,      __magic_name__					:   Optional[int]=1E-5  ,      __magic_name__					:   Optional[int]=0.02  ,      __magic_name__					:   Union[str, Any]=True  ,      __magic_name__					:   int=1  ,      __magic_name__					:   int=2  ,      __magic_name__					:   List[str]=False  ,      __magic_name__					:   str=0.0  ,      __magic_name__					:   List[Any]=0.0  ,      __magic_name__					:   List[Any]=1  ,      __magic_name__					:   Any=False  ,      **__magic_name__					:   List[Any]  ,      )					->    List[str]:


					"""simple docstring"""

					__snake_case					:      List[Any]							      =     vocab_size
					# Backward compatibility with n_embed kwarg
					__snake_case					:      List[str]							      =     kwargs.pop("""n_embed"""  ,      __magic_name__			)
					__snake_case					:      Union[str, Any]							      =     hidden_size if n_embed is None else n_embed
					__snake_case					:      Union[str, Any]							      =     n_layer
					__snake_case					:      Dict							      =     n_head
					__snake_case					:      Dict							      =     layer_norm_epsilon
					__snake_case					:      int							      =     initializer_range
					__snake_case					:      Optional[int]							      =     use_cache
					__snake_case					:      List[str]							      =     pretraining_tp
					__snake_case					:      int							      =     apply_residual_connection_post_layernorm
					__snake_case					:      str							      =     hidden_dropout
					__snake_case					:      Tuple							      =     attention_dropout

					__snake_case					:      int							      =     bos_token_id
					__snake_case					:      Any							      =     eos_token_id
					__snake_case					:      Union[str, Any]							      =     slow_but_exact

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





class  _A (					__lowercase		):
		lowercase__:   Optional[int]				     =   version.parse('''1.12'''		)

		def __init__(   self					:   Optional[int]  ,      __magic_name__					:   PretrainedConfig  ,      __magic_name__					:   str = "default"  ,      __magic_name__					:   List[PatchingSpec] = None  ,      __magic_name__					:   bool = False  ,      )					->    Optional[int]:


					"""simple docstring"""

					super().__init__(__magic_name__  ,      task=__magic_name__  ,      patching_specs=__magic_name__  ,      use_past=__magic_name__			)
					if not getattr(self._config  ,      """pad_token_id"""  ,      __magic_name__			):
								# TODO: how to do that better?
								__snake_case					:      str							      =     0

		@property
		def 	lowercase__     (   self					:   Tuple			)					->    Mapping[str, Mapping[int, str]]:


					"""simple docstring"""

					__snake_case					:      Dict							      =     OrderedDict({"""input_ids""": {0: """batch""", 1: """sequence"""}}			)
					if self.use_past:
								# BLOOM stores values on dynamic axis 2. For more details see: https://github.com/huggingface/transformers/pull/18344
								self.fill_with_past_key_values_(__magic_name__  ,      direction="""inputs"""  ,      inverted_values_shape=__magic_name__			)
								__snake_case					:      List[Any]							      =     {0: """batch""", 1: """past_sequence + sequence"""}
					else:
								__snake_case					:      Any							      =     {0: """batch""", 1: """sequence"""}

					return common_inputs

		@property
		def 	lowercase__     (   self					:   Optional[Any]			)					->    int:


					"""simple docstring"""

					return self._config.n_layer

		@property
		def 	lowercase__     (   self					:   Optional[Any]			)					->    int:


					"""simple docstring"""

					return self._config.n_head

		@property
		def 	lowercase__     (   self					:   Optional[int]			)					->    float:


					"""simple docstring"""

					return 1E-3

		def 	lowercase__     (   self					:   List[Any]  ,      __magic_name__					:   "PreTrainedTokenizer"  ,      __magic_name__					:   int = -1  ,      __magic_name__					:   int = -1  ,      __magic_name__					:   bool = False  ,      __magic_name__					:   Optional["TensorType"] = None  ,      )					->    Mapping[str, Any]:


					"""simple docstring"""

					__snake_case					:      int							      =     super(__magic_name__  ,      self			).generate_dummy_inputs(
					    __magic_name__  ,      batch_size=__magic_name__  ,      seq_length=__magic_name__  ,      is_pair=__magic_name__  ,      framework=__magic_name__			)

					# We need to order the input in the way they appears in the forward()
					__snake_case					:      Optional[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

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

					__snake_case					:      Union[str, Any]							      =     common_inputs["""attention_mask"""]
					if self.use_past:
								__snake_case					:      Any							      =     ordered_inputs["""attention_mask"""].dtype
								__snake_case					:      int							      =     torch.cat(
								    [ordered_inputs["""attention_mask"""], torch.ones(__magic_name__  ,      __magic_name__  ,      dtype=__magic_name__			)]  ,      dim=1			)

					return ordered_inputs

		@property
		def 	lowercase__     (   self					:   List[Any]			)					->    int:


					"""simple docstring"""

					return 13







"""simple docstring"""







from ..utils import DummyObject, requires_backends

class       _a  ( metaclass=SCREAMING_SNAKE_CASE__):
			__magic_name__     					=     ["""keras_nlp"""]



			def __init__(			self							:				int   ,	*_lowercase							:				Optional[int]   ,	**_lowercase							:				Dict		)							->					List[Any]:
									requires_backends(self   ,	["keras_nlp"]		)



