


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


__A		=logging.get_logger(__name__)

__A		={
    '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 						_snake_case   (       a__		):
					lowerCAmelCase :Dict						=   '''bloom'''
					lowerCAmelCase :List[str]						=   ['''past_key_values''']
					lowerCAmelCase :Optional[Any]						=   {
					    '''num_hidden_layers''': '''n_layer''',
					    '''num_attention_heads''': '''n_head''',
					}




					def __init__( self							,							_lowerCamelCase=25_0880							,							_lowerCamelCase=64							,							_lowerCamelCase=2							,							_lowerCamelCase=8							,							_lowerCamelCase=1e-5							,							_lowerCamelCase=0.02							,							_lowerCamelCase=True							,							_lowerCamelCase=1							,							_lowerCamelCase=2							,							_lowerCamelCase=False							,							_lowerCamelCase=0.0							,							_lowerCamelCase=0.0							,							_lowerCamelCase=1							,							_lowerCamelCase=False							,							**_lowerCamelCase							,							):
								UpperCAmelCase__					:   List[Any]       				=       vocab_size
								# Backward compatibility with n_embed kwarg
								UpperCAmelCase__					:   Tuple       				=       kwargs.pop("""n_embed"""							,							_SCREAMING_SNAKE_CASE)
								UpperCAmelCase__					:   Optional[Any]       				=       hidden_size if n_embed is None else n_embed
								UpperCAmelCase__					:   List[Any]       				=       n_layer
								UpperCAmelCase__					:   Optional[Any]       				=       n_head
								UpperCAmelCase__					:   List[str]       				=       layer_norm_epsilon
								UpperCAmelCase__					:   int       				=       initializer_range
								UpperCAmelCase__					:   Any       				=       use_cache
								UpperCAmelCase__					:   Optional[int]       				=       pretraining_tp
								UpperCAmelCase__					:   Any       				=       apply_residual_connection_post_layernorm
								UpperCAmelCase__					:   Any       				=       hidden_dropout
								UpperCAmelCase__					:   Tuple       				=       attention_dropout

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

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


class 						_snake_case   (       a__		):
					lowerCAmelCase :List[Any]						=   version.parse('''1.12'''		)




					def __init__( self							,							_lowerCamelCase							,							_lowerCamelCase = "default"							,							_lowerCamelCase = None							,							_lowerCamelCase = False							,							):
								super().__init__(_SCREAMING_SNAKE_CASE							,							task=_SCREAMING_SNAKE_CASE							,							patching_specs=_SCREAMING_SNAKE_CASE							,							use_past=_SCREAMING_SNAKE_CASE)
								if not getattr(self._config							,							"""pad_token_id"""							,							_SCREAMING_SNAKE_CASE):
											# TODO: how to do that better?
											UpperCAmelCase__					:   Optional[Any]       				=       0




					@property
					def 			snake_case__  ( self):
								UpperCAmelCase__					:   List[str]       				=       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_(_SCREAMING_SNAKE_CASE							,							direction="""inputs"""							,							inverted_values_shape=_SCREAMING_SNAKE_CASE)
											UpperCAmelCase__					:   int       				=       {0: '''batch''', 1: '''past_sequence + sequence'''}
								else:
											UpperCAmelCase__					:   List[Any]       				=       {0: '''batch''', 1: '''sequence'''}

								return common_inputs




					@property
					def 			snake_case__  ( self):
								return self._config.n_layer




					@property
					def 			snake_case__  ( self):
								return self._config.n_head




					@property
					def 			snake_case__  ( self):
								return 1e-3




					def 			snake_case__  ( self							,							_lowerCamelCase							,							_lowerCamelCase = -1							,							_lowerCamelCase = -1							,							_lowerCamelCase = False							,							_lowerCamelCase = None							,							):
								UpperCAmelCase__					:   List[str]       				=       super(_SCREAMING_SNAKE_CASE							,							self).generate_dummy_inputs(
								    _SCREAMING_SNAKE_CASE							,							batch_size=_SCREAMING_SNAKE_CASE							,							seq_length=_SCREAMING_SNAKE_CASE							,							is_pair=_SCREAMING_SNAKE_CASE							,							framework=_SCREAMING_SNAKE_CASE)

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

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

								UpperCAmelCase__					:   Union[str, Any]       				=       common_inputs['''attention_mask''']
								if self.use_past:
											UpperCAmelCase__					:   str       				=       ordered_inputs['''attention_mask'''].dtype
											UpperCAmelCase__					:   Tuple       				=       torch.cat(
											    [ordered_inputs["""attention_mask"""], torch.ones(_SCREAMING_SNAKE_CASE							,							_SCREAMING_SNAKE_CASE							,							dtype=_SCREAMING_SNAKE_CASE)]							,							dim=1)

								return ordered_inputs




					@property
					def 			snake_case__  ( self):
								return 13



'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__A		={
    'configuration_table_transformer': [
        'TABLE_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'TableTransformerConfig',
        'TableTransformerOnnxConfig',
    ]
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		__A		=[
		    'TABLE_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST',
		    'TableTransformerForObjectDetection',
		    'TableTransformerModel',
		    'TableTransformerPreTrainedModel',
		]


if TYPE_CHECKING:
		from .configuration_table_transformer import (
		    TABLE_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    TableTransformerConfig,
		    TableTransformerOnnxConfig,
		)

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_table_transformer import (
				    TABLE_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
				    TableTransformerForObjectDetection,
				    TableTransformerModel,
				    TableTransformerPreTrainedModel,
				)

else:
		import sys

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