





'''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


__SCREAMING_SNAKE_CASE     :Dict       =				logging.get_logger(__name__)

__SCREAMING_SNAKE_CASE     :Optional[int]       =				{
    '''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_	(  lowerCAmelCase_			):
 _lowerCamelCase  : str           =							"""bloom"""
 _lowerCamelCase  : Tuple           =							["""past_key_values"""]
 _lowerCamelCase  : int           =							{
     """num_hidden_layers""": """n_layer""",
     """num_attention_heads""": """n_head""",
 }




 def __init__(					self       :    str	,			snake_case_       :    Dict=2_5_0_8_8_0	,			snake_case_       :    int=6_4	,			snake_case_       :    Union[str, Any]=2	,			snake_case_       :    Optional[int]=8	,			snake_case_       :    Optional[Any]=1e-5	,			snake_case_       :    str=0.0_2	,			snake_case_       :    Tuple=True	,			snake_case_       :    Tuple=1	,			snake_case_       :    List[str]=2	,			snake_case_       :    List[str]=False	,			snake_case_       :    List[Any]=0.0	,			snake_case_       :    Tuple=0.0	,			snake_case_       :    Dict=1	,			snake_case_       :    Tuple=False	,			**snake_case_       :    Any	,			):
      _UpperCAmelCase     							=   vocab_size
      # Backward compatibility with n_embed kwarg
      _UpperCAmelCase     							=   kwargs.pop("n_embed"	,			snake_case_    )
      _UpperCAmelCase     							=   hidden_size if n_embed is None else n_embed
      _UpperCAmelCase     							=   n_layer
      _UpperCAmelCase     							=   n_head
      _UpperCAmelCase     							=   layer_norm_epsilon
      _UpperCAmelCase     							=   initializer_range
      _UpperCAmelCase     							=   use_cache
      _UpperCAmelCase     							=   pretraining_tp
      _UpperCAmelCase     							=   apply_residual_connection_post_layernorm
      _UpperCAmelCase     							=   hidden_dropout
      _UpperCAmelCase     							=   attention_dropout

      _UpperCAmelCase     							=   bos_token_id
      _UpperCAmelCase     							=   eos_token_id
      _UpperCAmelCase     							=   slow_but_exact

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







class   A_	(  lowerCAmelCase_			):
 _lowerCamelCase  : Dict           =							version.parse("""1.12"""			)




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




 @property
 def      lowercase	(					self       :    Optional[int]    ):
      _UpperCAmelCase     							=   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_(snake_case_	,			direction="inputs"	,			inverted_values_shape=snake_case_    )
           _UpperCAmelCase     							=   {0: "batch", 1: "past_sequence + sequence"}
      else:
           _UpperCAmelCase     							=   {0: "batch", 1: "sequence"}

      return common_inputs




 @property
 def      lowercase	(					self       :    List[Any]    ):
      return self._config.n_layer




 @property
 def      lowercase	(					self       :    Optional[int]    ):
      return self._config.n_head




 @property
 def      lowercase	(					self       :    List[Any]    ):
      return 1e-3




 def      lowercase	(					self       :    Optional[int]	,			snake_case_       :    "PreTrainedTokenizer"	,			snake_case_       :    int = -1	,			snake_case_       :    int = -1	,			snake_case_       :    bool = False	,			snake_case_       :    Optional["TensorType"] = None	,			):
      _UpperCAmelCase     							=   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()
      _UpperCAmelCase     							=   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

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

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

      return ordered_inputs




 @property
 def      lowercase	(					self       :    Optional[Any]    ):
      return 1_3








from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_torch_available


lowerCAmelCase__      		= {'configuration_speech_encoder_decoder': ['SpeechEncoderDecoderConfig']}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCAmelCase__      		= ['SpeechEncoderDecoderModel']

try:
    if not is_flax_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCAmelCase__      		= ['FlaxSpeechEncoderDecoderModel']

if TYPE_CHECKING:
    from .configuration_speech_encoder_decoder import SpeechEncoderDecoderConfig

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_speech_encoder_decoder import SpeechEncoderDecoderModel

    try:
        if not is_flax_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_flax_speech_encoder_decoder import FlaxSpeechEncoderDecoderModel

else:
    import sys

    lowerCAmelCase__      		= _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
