from typing import List, Optional, Union

import numpy as np
import tensorflow as tf

from .utils import logging


A__           =							logging.get_logger(__name__)





def  _lowerCamelCase					(   a_				: Union[tf.Tensor, np.ndarray]):
			if isinstance(a_						,			np.ndarray):
						return list(tensor.shape)

			lowerCamelCase						:int						  =     tf.shape(a_)

			if tensor.shape == tf.TensorShape(a_):
						return dynamic

			lowerCamelCase						:Union[str, Any]						  =     tensor.shape.as_list()

			return [dynamic[i] if s is None else s for i, s in enumerate(a_)]





def  _lowerCamelCase					(   a_				: tf.Tensor						,			a_				: Optional[int] = None						,			a_				: Optional[str] = None):
			return tf.nn.softmax(logits=logits + 1e-9						,			axis=a_						,			name=a_)





def  _lowerCamelCase					(   a_				: Dict						,			a_				: Optional[int]						,			a_				: Union[str, Any]						,			a_				: str=1e-5						,			a_				: List[Any]=-1):
			# This is a very simplified functional layernorm, designed to duplicate
			# the functionality of PyTorch nn.functional.layer_norm when this is needed to port
			# models in Transformers.

			if weight.shape.rank != 1 or bias.shape.rank != 1 or not isinstance(a_						,			a_):
						raise NotImplementedError('''Only 1D weight and bias tensors are supported for now, with only a single axis.''')

			# Get mean and variance on the axis to be normalized
			lowerCamelCase  ,    lowerCamelCase						:Any						  =     tf.nn.moments(a_						,			axes=[axis]						,			keepdims=a_)

			if axis != -1:
						# Reshape scale and weight to have the same rank as inputs, but with 1 dimensions
						# on every dimension except axis
						lowerCamelCase						:Dict						  =     [1] * inputs.shape.rank
						lowerCamelCase						:Tuple						  =     shape_list(a_)[axis]
						lowerCamelCase						:List[Any]						  =     tf.reshape(a_						,			a_)
						lowerCamelCase						:str						  =     tf.reshape(a_						,			a_)

			# Compute layer normalization using the batch_normalization
			# function.
			lowerCamelCase						:Dict						  =     tf.nn.batch_normalization(
			    a_						,			a_						,			a_						,			offset=a_						,			scale=a_						,			variance_epsilon=a_						,			)
			return outputs





def  _lowerCamelCase					(   a_				: Dict						,			a_				: List[str]=0						,			a_				: Dict=-1):
			# Replicates the behavior of torch.flatten in TF

			# If end_dim or start_dim is negative, count them from the end
			if end_dim < 0:
						end_dim += input.shape.rank
			if start_dim < 0:
						start_dim += input.shape.rank

			if start_dim == end_dim:
						return input

			lowerCamelCase						:str						  =     tf.shape(a_)
			lowerCamelCase						:int						  =     tf.math.reduce_prod(in_shape[start_dim : end_dim + 1])
			lowerCamelCase						:int						  =     tf.concat([in_shape[:start_dim], [flattened_dim], in_shape[end_dim + 1 :]]						,			axis=0)
			return tf.reshape(a_						,			a_)





def  _lowerCamelCase					(   a_				: tf.Tensor):
			if not isinstance(a_						,			tf.Tensor):
						lowerCamelCase						:Optional[int]						  =     tf.convert_to_tensor(a_)  # Catches stray NumPy inputs
			if encoder_attention_mask.shape.rank == 3:
						lowerCamelCase						:int						  =     encoder_attention_mask[:, None, :, :]
			if encoder_attention_mask.shape.rank == 2:
						lowerCamelCase						:List[Any]						  =     encoder_attention_mask[:, None, None, :]
			# T5 has a mask that can compare sequence ids, we can simulate this here with this transposition
			# Cf. https://github.com/tensorflow/mesh/blob/8d2465e9bc93129b913b5ccc6a59aa97abd96ec6/mesh_tensorflow
			# /transformer/transformer_layers.py#L270
			# encoder_extended_attention_mask = (encoder_extended_attention_mask ==
			# encoder_extended_attention_mask.transpose(-1, -2))
			lowerCamelCase						:Tuple						  =     (
			    tf.cast(1						,			encoder_attention_mask.dtype) - encoder_extended_attention_mask
			) * encoder_extended_attention_mask.dtype.min

			return encoder_extended_attention_mask





def  _lowerCamelCase					(   a_				: tf.Tensor						,			a_				: int						,			a_				: str = "input_ids"):
			tf.debugging.assert_less(
			    a_						,			tf.cast(a_						,			dtype=tensor.dtype)						,			message=(
			        F"The maximum value of {tensor_name} ({tf.math.reduce_max(a_)}) must be smaller than the embedding "
			        F"layer's input dimension ({embed_dim}). The likely cause is some problem at tokenization time."
			    )						,			)





def  _lowerCamelCase					(   a_				: int						,			a_				: Dict						,			a_				: Any):
			lowerCamelCase						:Optional[Any]						  =     6_45_12
			# Check that no item in `data` is larger than `HDF5_OBJECT_HEADER_LIMIT`
			# because in that case even chunking the array would not make the saving
			# possible.
			lowerCamelCase						:str						  =     [x for x in data if len(a_) > HDF5_OBJECT_HEADER_LIMIT]

			# Expecting this to never be true.
			if bad_attributes:
						raise RuntimeError(
						    '''The following attributes cannot be saved to HDF5 file because '''
						    F"they are larger than {HDF5_OBJECT_HEADER_LIMIT} "
						    F"bytes: {bad_attributes}")

			lowerCamelCase						:Optional[int]						  =     np.asarray(a_)

			lowerCamelCase						:Union[str, Any]						  =     1
			lowerCamelCase						:Tuple						  =     np.array_split(a_						,			a_)

			# This will never loop forever thanks to the test above.
			while any(x.nbytes > HDF5_OBJECT_HEADER_LIMIT for x in chunked_data):
						num_chunks += 1
						lowerCamelCase						:List[str]						  =     np.array_split(a_						,			a_)

			if num_chunks > 1:
						for chunk_id, chunk_data in enumerate(a_):
									lowerCamelCase						:Any						  =     chunk_data
			else:
						lowerCamelCase						:List[Any]						  =     data





def  _lowerCamelCase					(   a_				: str						,			a_				: List[Any]):
			if name in group.attrs:
						lowerCamelCase						:Union[str, Any]						  =     [n.decode('''utf8''') if hasattr(a_						,			'''decode''') else n for n in group.attrs[name]]
			else:
						lowerCamelCase						:str						  =     []
						lowerCamelCase						:List[Any]						  =     0
						while "%s%d" % (name, chunk_id) in group.attrs:
									data.extend(
									    [n.decode('''utf8''') if hasattr(a_						,			'''decode''') else n for n in group.attrs['''%s%d''' % (name, chunk_id)]])
									chunk_id += 1
			return data





def  _lowerCamelCase					(   a_				: Optional[Any]):

			def _expand_single_ad_tensor(a_				: Any):
						if isinstance(a_						,			tf.Tensor) and t.shape.rank == 1:
									return tf.expand_dims(a_						,			axis=-1)
						return t

			return tf.nest.map_structure(_expand_single_ad_tensor						,			a_)




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


A__           =							{
    """configuration_layoutlmv2""": ["""LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP""", """LayoutLMv2Config"""],
    """processing_layoutlmv2""": ["""LayoutLMv2Processor"""],
    """tokenization_layoutlmv2""": ["""LayoutLMv2Tokenizer"""],
}

try:
			if not is_tokenizers_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			A__           =							["""LayoutLMv2TokenizerFast"""]

try:
			if not is_vision_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			A__           =							["""LayoutLMv2FeatureExtractor"""]
			A__           =							["""LayoutLMv2ImageProcessor"""]

try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			A__           =							[
			    """LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST""",
			    """LayoutLMv2ForQuestionAnswering""",
			    """LayoutLMv2ForSequenceClassification""",
			    """LayoutLMv2ForTokenClassification""",
			    """LayoutLMv2Layer""",
			    """LayoutLMv2Model""",
			    """LayoutLMv2PreTrainedModel""",
			]

if TYPE_CHECKING:
			from .configuration_layoutlmva import LAYOUTLMV2_PRETRAINED_CONFIG_ARCHIVE_MAP, LayoutLMvaConfig
			from .processing_layoutlmva import LayoutLMvaProcessor
			from .tokenization_layoutlmva import LayoutLMvaTokenizer

			try:
						if not is_tokenizers_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .tokenization_layoutlmva_fast import LayoutLMvaTokenizerFast

			try:
						if not is_vision_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .feature_extraction_layoutlmva import LayoutLMvaFeatureExtractor, LayoutLMvaImageProcessor

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_layoutlmva import (
						    LAYOUTLMV2_PRETRAINED_MODEL_ARCHIVE_LIST,
						    LayoutLMvaForQuestionAnswering,
						    LayoutLMvaForSequenceClassification,
						    LayoutLMvaForTokenClassification,
						    LayoutLMvaLayer,
						    LayoutLMvaModel,
						    LayoutLMvaPreTrainedModel,
						)
else:
			import sys

			A__           =							_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



