

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


__lowerCamelCase						    =      logging.get_logger(__name__)

__lowerCamelCase						    =      {
    '''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__ ( _snake_case     ):
    lowercase		   =						"bloom"
    lowercase		   =						["past_key_values"]
    lowercase		   =						{
        "num_hidden_layers": "n_layer",
        "num_attention_heads": "n_head",
    }



    def __init__(   self						,			UpperCamelCase__=250880						,			UpperCamelCase__=64						,			UpperCamelCase__=2						,			UpperCamelCase__=8						,			UpperCamelCase__=1e-5						,			UpperCamelCase__=0.02						,			UpperCamelCase__=True						,			UpperCamelCase__=1						,			UpperCamelCase__=2						,			UpperCamelCase__=False						,			UpperCamelCase__=0.0						,			UpperCamelCase__=0.0						,			UpperCamelCase__=1						,			UpperCamelCase__=False						,			**UpperCamelCase__						,			)  -> List[Any]:





           '''simple docstring'''
           A_		   = vocab_size
           # Backward compatibility with n_embed kwarg
           A_		   = kwargs.pop("""n_embed"""						,			UpperCamelCase__    )
           A_		   = hidden_size if n_embed is None else n_embed
           A_		   = n_layer
           A_		   = n_head
           A_		   = layer_norm_epsilon
           A_		   = initializer_range
           A_		   = use_cache
           A_		   = pretraining_tp
           A_		   = apply_residual_connection_post_layernorm
           A_		   = hidden_dropout
           A_		   = attention_dropout

           A_		   = bos_token_id
           A_		   = eos_token_id
           A_		   = slow_but_exact

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


class    A__ ( _snake_case     ):
    lowercase		   =						version.parse("1.12"     )



    def __init__(   self						,			UpperCamelCase__						,			UpperCamelCase__ = "default"						,			UpperCamelCase__ = None						,			UpperCamelCase__ = False						,			)  -> int:





           '''simple docstring'''
           super().__init__(UpperCamelCase__						,			task=UpperCamelCase__						,			patching_specs=UpperCamelCase__						,			use_past=UpperCamelCase__    )
           if not getattr(self._config						,			"""pad_token_id"""						,			UpperCamelCase__    ):
                  # TODO: how to do that better?
                  A_		   = 0



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





           '''simple docstring'''
           A_		   = 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_(UpperCamelCase__						,			direction="""inputs"""						,			inverted_values_shape=UpperCamelCase__    )
                  A_		   = {0: """batch""", 1: """past_sequence + sequence"""}
           else:
                  A_		   = {0: """batch""", 1: """sequence"""}

           return common_inputs



    @property
    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           return self._config.n_layer



    @property
    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           return self._config.n_head



    @property
    def    snake_case_     (   self    )  -> float:





           '''simple docstring'''
           return 1e-3



    def    snake_case_     (   self						,			UpperCamelCase__						,			UpperCamelCase__ = -1						,			UpperCamelCase__ = -1						,			UpperCamelCase__ = False						,			UpperCamelCase__ = None						,			)  -> Mapping[str, Any]:





           '''simple docstring'''
           A_		   = super(UpperCamelCase__						,			self    ).generate_dummy_inputs(
               UpperCamelCase__						,			batch_size=UpperCamelCase__						,			seq_length=UpperCamelCase__						,			is_pair=UpperCamelCase__						,			framework=UpperCamelCase__    )

           # We need to order the input in the way they appears in the forward()
           A_		   = 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_		   = common_inputs["""input_ids"""].shape
                         # Not using the same length for past_key_values
                         A_		   = seqlen + 2
                         A_		   = self._config.hidden_size // self.num_attention_heads
                         A_		   = (
                             batch * self.num_attention_heads,
                             head_dim,
                             past_key_values_length,
                         )
                         A_		   = (
                             batch * self.num_attention_heads,
                             past_key_values_length,
                             head_dim,
                         )
                         A_		   = [
                             (torch.zeros(UpperCamelCase__    ), torch.zeros(UpperCamelCase__    )) for _ in range(self.num_layers    )
                         ]

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

           return ordered_inputs







    @property
    def    snake_case_     (   self    )  -> int:





           '''simple docstring'''
           return 13



'''simple docstring'''







from functools import lru_cache
@lru_cache
def  UpperCAmelCase__      ( UpperCAmelCase__			)     ->     int:
       if num < 0:
              raise ValueError("""Number should not be negative."""			)

       return 1 if num in (0, 1) else num * factorial(num - 1			)


if __name__ == "__main__":
      import doctest

      doctest.testmod()
